Fulfillment do build (Dialogflow)

O fulfillment define a interface de conversa para receber o projeto do Actions a entrada do usuário e a lógica para processar a entrada e realizar a ação.

Visão geral

O atendimento do pedido recebe e processa solicitações do Google Assistente. responde. Esse processo contínuo de solicitação e resposta gera a conversa adiante até você atender à solicitação inicial do usuário.

As etapas a seguir descrevem como criar o fulfillment usando as Ações SDK com a biblioteca de cliente Node.js ou Java/Kotlin:

  1. Inicialize o objeto ActionsSdkApp.
  2. Crie funções para processar solicitações na lógica de fulfillment.
.

Como criar caixas de diálogo

Inicializar o objeto ActionsSdkApp

O código a seguir instancia ActionsSdkApp e faz algumas configurações padrão do Node.js no Google Cloud Functions:

SDK do Actions (Node.js)
'use strict';

const {actionssdk} = require('actions-on-google');
const functions = require('firebase-functions');

const app = actionssdk({debug: true});

app.intent('actions.intent.MAIN', (conv) => {
  conv.ask('Hi!');
});

// More intent handling if needed
exports.myFunction = functions.https.onRequest(app);
SDK do Actions (Java)
ResponseBuilder responseBuilder = getResponseBuilder(request).add("Hi!");
return responseBuilder.build();
JSON
{
  "expectUserResponse": true,
  "expectedInputs": [
    {
      "inputPrompt": {
        "richInitialPrompt": {
          "items": [
            {
              "simpleResponse": {
                "textToSpeech": "Hi!"
              }
            }
          ]
        }
      },
      "possibleIntents": [
        {
          "intent": "actions.intent.TEXT"
        }
      ]
    }
  ],
  "conversationToken": "{\"data\":{}}",
  "userStorage": "{\"data\":{}}"
}

Criar funções para processar solicitações

Quando os usuários falam uma frase, você recebe uma solicitação do Google Assistente. Para atender às intents das solicitações, criar funções que processam as a intent acionada.

Para processar solicitações:

  1. Realizar qualquer lógica necessária para processar a entrada do usuário.

  2. Chame a função conv.ask() transmitindo a resposta que você quer mostrar como argumento.

O código a seguir mostra como criar uma resposta simples:

SDK do Actions (Node.js)
conv.ask(`Hi! Say something, and I'll repeat it.`);
SDK do Actions (Java)
ResponseBuilder responseBuilder =
    getResponseBuilder(request).add("Hi! Say something, and I'll repeat it.");
return responseBuilder.build();
JSON
{
  "expectUserResponse": true,
  "expectedInputs": [
    {
      "inputPrompt": {
        "richInitialPrompt": {
          "items": [
            {
              "simpleResponse": {
                "textToSpeech": "Hi! Say something, and I'll repeat it."
              }
            }
          ]
        }
      },
      "possibleIntents": [
        {
          "intent": "actions.intent.TEXT"
        }
      ]
    }
  ],
  "conversationToken": "{\"data\":{}}",
  "userStorage": "{\"data\":{}}"
}

Como processar intents

Quando você tiver todas as funções para processar intents acionadas, use app.intent para atribuir gerenciadores a intents.

SDK do Actions (Node.js)
app.intent('actions.intent.TEXT', (conv) => {
  // handle text intent.
});
app.intent('actions.intent.MAIN', (conv) => {
  // handle main intent.
});
SDK do Actions (Java)
@ForIntent("actions.intent.MAIN")
public ActionResponse main(ActionRequest request) {
  // handle main intent
  // ...
}

@ForIntent("actions.intent.TEXT")
public ActionResponse text(ActionRequest request) {
  // handle text intent
  // ...
}

Encerrar conversas

Quando você não quiser mais receber nenhuma entrada do usuário e quiser encerrar a conversa, chame a função conv.close(). Essa função diz ao Google Assistente para responder o texto ao usuário e encerrar a conversa fechando o microfone.

Como processar a intent de invocação principal

Quando os usuários acionam a intent app.intent.action.MAIN, você normalmente não faz para processar as entradas do usuário. Se o pacote de ações tiver muitos ações e abrange muitos casos de uso, é uma boa ideia orientar o usuário dizendo algumas coisas que eles podem fazer.

  1. Chame a função conv.ask() transmitindo sua resposta como um argumento. O Google Assistente fala sua resposta para o usuário e depois espera o usuário acionar uma das intents especificadas.

O snippet a seguir mostra como processar uma intent de boas-vindas simples:

SDK do Actions (Node.js)
// handle the initialTrigger
function handleMainIntent(conv, input) {
  conv.ask(input);
}
SDK do Actions (Java)
private ActionResponse handleMainIntent(ResponseBuilder rb, String input) {
  return rb.add(input).build();
}

Estado da conversa

Se você estiver usando a API de webhook HTTP/JSON de conversa, poderá manter o o estado das suas conversas com um objeto formatado em JSON (conversationToken). que é transmitido entre você e o Google Assistente. Se você for usando a biblioteca de cliente Node.js, pode gravar e ler diretamente no campo conv.data. Este campo é transmitido automaticamente entre solicitações e respostas.

SDK do Actions (Node.js)
conv.data = {something: 10};
let value = conv.data.something;
SDK do Actions (Java)
ResponseBuilder rb = getResponseBuilder(request);
rb.getConversationData().put("something", 10);
Object value = rb.getConversationData().get("something");