Fulfillment do build (Dialogflow)

O fulfillment define a interface de conversa do projeto do Actions para receber a entrada do usuário e a lógica para processá-la e, por fim, realizar a ação.

Informações gerais

O fulfillment recebe solicitações do Google Assistente, as processa e responde. Esse processo de idas e vindas de solicitações e respostas leva a conversa adiante até que você atenda à solicitação inicial do usuário.

As etapas a seguir descrevem como criar o fulfillment usando o SDK do Actions com o Node.js ou a biblioteca de cliente Java/Kotlin:

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

Como criar caixas de diálogo

Inicializar o objeto ActionsSdkApp

O código a seguir instancia o ActionsSdkApp e faz algumas configurações padrão do Node.js para o 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 lidar com solicitações

Quando os usuários falam uma frase, você recebe uma solicitação do Google Assistente. Para atender às intents que vêm nas solicitações, crie funções que processem 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 um 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 suas 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
  // ...
}

Encerrando conversas

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

Como processar a intent de invocação principal

Quando os usuários acionam a intent app.intent.action.MAIN, você normalmente não precisa fazer nenhum processamento de entrada do usuário. Se o pacote contiver muitas ações e abranger muitos casos de uso, é recomendável orientar o usuário informando algumas ações possíveis.

  1. Chame a função conv.ask() transmitindo sua resposta como um argumento. O Google Assistente fala sua resposta ao usuário e espera que o usuário acione 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 estiver usando a API de webhook HTTP/JSON de conversa, será possível manter o estado das conversas com um objeto formatado em JSON (conversationToken) que é transmitido entre você e o Google Assistente. Se você estiver usando a biblioteca de cliente Node.js, poderá gravar e ler a partir do campo conv.data diretamente. Esse 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");