As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Integrando uma AWS Lambda função ao seu bot Amazon Lex V2 Com as funções do [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html), você pode estender e controlar melhor o comportamento do seu bot do Amazon Lex V2 por meio de funções personalizadas que você define. O Amazon Lex V2 usa uma função do Lambda por alias de bot por linguagem, em vez de uma função do Lambda para cada intenção. Antes de começar, determine de quais campos no [evento de entrada](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-input-format) você deseja extrair informações e quais campos na [resposta](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-response-format) você deseja manipular e retornar da sua função do Lambda. Para integrar uma função do Lambda ao seu bot do Amazon Lex V2, execute as seguintes etapas: 1. [Crie uma função](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach) AWS Lambda usando a linguagem de programação de sua escolha e escreva seu script. 1. Certifique-se de que a função retorna uma estrutura que corresponda ao [formato da resposta](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-response-format). 1. Implante a função do Lambda. 1. Associe a função do Lambda a um alias de bot do Amazon Lex V2 com o [console](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-console) ou as [operações de API](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-api). 1. Selecione os estágios de conversação nos quais você deseja invocar sua função do Lambda com o [console](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-console) ou as [operações da API](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-api). 1. Crie seu bot do Amazon Lex V2 e teste se a função do Lambda funciona, conforme o esperado. [Depure](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-debug) sua função com a ajuda da Amazon CloudWatch. **Topics** + [AWS Lambdaformato de evento de entrada para Lex V2](lambda-input-format.md) + [AWS Lambdaformato de resposta para Lex V2](lambda-response-format.md) + [Estruturas comuns em uma AWS Lambda função para o Amazon Lex V2](lambda-common-structures.md) + [Criação de uma AWS Lambda função para seu bot Amazon Lex V2](lambda-attach.md) + [Depuração de uma função Lambda usando registros de registros CloudWatch](lambda-debug.md) # AWS Lambdaformato de evento de entrada para Lex V2 A primeira etapa na integração de uma função do Lambda em seu bot do Amazon Lex V2 é entender os campos no evento Amazon Lex V2 e determinar as informações desses campos que você deseja usar ao escrever seu script. O objeto JSON a seguir mostra o formato geral de um evento do Amazon Lex V2 passado para uma função do Lambda: **nota** O formato de entrada pode mudar sem uma alteração correspondente para a `messageVersion`. Seu código não deve gerar um erro, se novos campos estiverem presentes. ``` { "messageVersion": "1.0", "invocationSource": "DialogCodeHook | FulfillmentCodeHook", "inputMode": "DTMF | Speech | Text", "responseContentType": "audio/mpeg | audio/ogg | audio/pcm | text/plain; charset=utf-8", "sessionId": string, "inputTranscript": string, "invocationLabel": string, "bot": { "id": string, "name": string, "localeId": string, "version": string, "aliasId": string, "aliasName": string }, "interpretations": [ { "interpretationSource": "Bedrock | Lex", "intent": { // see Intenção for details about the structure }, "nluConfidence": number, "sentimentResponse": { "sentiment": "MIXED | NEGATIVE | NEUTRAL | POSITIVE", "sentimentScore": { "mixed": number, "negative": number, "neutral": number, "positive": number } } }, ... ], "proposedNextState": { "dialogAction": { "slotToElicit": string, "type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot" }, "intent": { // see Intenção for details about the structure }, "prompt": { "attempt": string } }, "requestAttributes": { string: string, ... }, "sessionState": { // see Estado da sessão for details about the structure }, "transcriptions": [ { "transcription": string, "transcriptionConfidence": number, "resolvedContext": { "intent": string }, "resolvedSlots": { slot name: { // see Slots for details about the structure }, ... } }, ... ] } ``` Cada campo no evento de entrada é descrito a seguir: ## messageVersion A versão da mensagem que identifica o formato dos dados de evento que estão indo para a função do Lambda e o formato esperado da resposta de uma função do Lambda. **nota** Você configura esse valor ao definir uma intenção. Na implementação atual, apenas o Amazon Lex V2 oferece suporte à versão 1.0 da mensagem. Portanto, o console assume o valor padrão de 1.0 e não mostra a versão da mensagem. ## invocationSource O hook de código que o chamou da função do Lambda. Os seguintes valores são possíveis: `DialogCodeHook`: o Amazon Lex V2 chamou a função do Lambda após a entrada do usuário. `FulfillmentCodeHook`: o Amazon Lex V2 chamou a função do Lambda depois de preencher todos os slots necessários e a intenção estar pronta para ser cumprida. ## inputMode O modo do enunciado do usuário. Os valores possíveis são: `DTMF`: o usuário insere o enunciado usando um teclado de tom sensível ao toque (multifrequência de tons duplos). `Speech`: o usuário falou o enunciado. `Text`: o usuário digitou o enunciado. ## responseContentType O modo de resposta do bot ao usuário. `text/plain; charset=utf-8` indica que o último enunciado foi escrito, enquanto um valor que começa com `audio` indica que o último enunciado foi falado. ## sessionId O identificador de sessão alfanumérico usado para a conversa. ## inputTranscript Uma transcrição da entrada do usuário. + Para entrada de texto, esse é o texto que o usuário digitou. Para entrada DTMF, essa é a chave que o usuário insere. + Para entrada de voz, esse é o texto no qual o Amazon Lex V2 converte o enunciado do usuário para invocar uma intenção ou preencher um slot. ## invocationLabel Um valor que indica a resposta que invocou a função do Lambda. Você pode definir rótulos de invocação para a resposta inicial, os slots e a resposta de confirmação. ## bot Informações sobre o bot que processou a solicitação, consistindo nos seguintes campos: + **id**: o identificador atribuído ao bot quando você o criou. Você pode ver o ID do bot no console do Amazon Lex V2 na página **Configurações** do bot. + **name**: o nome que você deu ao bot ao criá-lo. + **localeId** – O identificador da localidade que você usou para o bot. Para obter uma lista de localidades, consulte [Idiomas e locais aceitos pelo Amazon Lex V2](how-languages.md). + **version**: a versão do bot que processou a solicitação. + **aliasId**: o identificador atribuído ao alias do bot quando você o criou. Você pode ver o ID do alias do bot no console do Amazon Lex V2 na página **Aliases**. Se você não conseguir ver o ID do alias na lista, escolha o ícone de engrenagem no canto superior direito e ative o **ID do alias**. + **aliasName**: o nome que você deu ao alias do bot. ## interpretations Uma lista de informações sobre intenções que o Amazon Lex V2 considera possíveis coincidências com o enunciado do usuário. Cada item é uma estrutura que fornece informações sobre a correspondência do enunciado com uma intenção, com o seguinte formato: ``` { "intent": { // see Intenção for details about the structure }, "interpretationSource": "Bedrock | Lex", "nluConfidence": number, "sentimentResponse": { "sentiment": "MIXED | NEGATIVE | NEUTRAL | POSITIVE", "sentimentScore": { "mixed": number, "negative": number, "neutral": number, "positive": number } } } ``` Os campos dentro da estrutura são os seguintes: + **intent**: uma estrutura que contém informações sobre a intenção. Consulte [Intenção](lambda-common-structures.md#lambda-intent) para obter detalhes sobre a estrutura. + **nluConfidence**: uma pontuação que indica o grau de confiança do Amazon Lex V2 de que a intenção corresponde à intenção do usuário. + **sentimentResponse**: uma análise do sentimento da resposta, que contém os seguintes campos: + **sentiment**: indica se o sentimento do enunciado é `POSITIVE`, `NEGATIVE`, `NEUTRAL`, ou `MIXED`. + **sentimentScore**: uma estrutura que mapeia cada sentimento em um número que indica o quanto o Amazon Lex V2 está confiante de que o enunciado transmite esse sentimento. + **InterpretationSource** — Indica se um slot foi resolvido pelo Amazon Lex V2 ou pelo Amazon Bedrock. ## proposedNextState Se a função do Lambda definir o `dialogAction` do `sessionState` para `Delegate`, esse campo aparecerá e mostrará a proposta do Amazon Lex V2 para a próxima etapa da conversa. Caso contrário, o próximo estado dependerá das configurações que você retorna na resposta da sua função do Lambda. Essa estrutura só estará presente se as duas afirmações abaixo forem verdadeiras: 1. O valor de `invocationSource` é `DialogCodeHook` 1. O `type` previsto de `dialogAction` é `ElicitSlot`. Você pode usar essas informações para adicionar `runtimeHints` no ponto certo da conversa. Consulte [Como melhorar o reconhecimento de valores de slots com dicas de runtime na conversa](using-hints.md) Para mais informações. `proposedNextState` é uma estrutura que contém os seguintes campos: A estrutura dos dados de `proposedNextState` é a seguinte: ``` "proposedNextState": { "dialogAction": { "slotToElicit": string, "type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot" }, "intent": { // see Intenção for details about the structure }, "prompt": { "attempt": string } } ``` + **dialogAction**: contém informações sobre a próxima etapa proposta pelo Amazon Lex V2. Os campos da estrutura são os seguintes: + **slotToElicit**— O slot a ser obtido a seguir, conforme proposto pelo Amazon Lex V2. Esse campo aparecerá somente se o valor de `type` for `ElicitSlot`. + **tipo**: a próxima etapa da conversa, conforme proposto pelo Amazon Lex V2. Os seguintes valores são possíveis: `Delegate`: o Amazon Lex V2 determina a próxima ação. `ElicitIntent`: a próxima ação é extrair uma intenção do usuário. `ElicitSlot`: a próxima ação é extrair um valor de slot do usuário. `Close`: encerra o processo de cumprimento da intenção e indica que não haverá uma resposta do usuário. `ConfirmIntent`: a próxima ação é perguntar ao usuário se os slots estão corretos e se a intenção está pronta para ser cumprida. + **intent**: a intenção que o bot determinou que o usuário está tentando cumprir. Consulte [Intenção](lambda-common-structures.md#lambda-intent) para obter detalhes sobre a estrutura. + **prompt**: uma estrutura que contém o campo `attempt`, que é mapeado para um valor que especifica quantas vezes o Amazon Lex V2 solicitou ao usuário o próximo slot. Os valores possíveis são `Initial` para a primeira tentativa e `Retry1`, `Retry2`, `Retry3`, `Retry4` e `Retry5` para as tentativas subsequentes. ## requestAttributes Uma estrutura que contém os atributos de sessão específicos à solicitação que o cliente envia na solicitação. Use atributos de solicitação para passar informações que não precisam ser mantidas durante toda a sessão. Se não houver atributos de solicitação, o valor será nulo. Para obter mais informações, consulte [Definição de atributos de solicitação para seu bot do Lex V2](context-mgmt-request-attribs.md). ## sessionState O estado atual da conversa entre o usuário e seu bot do Amazon Lex V2. Consulte [Estado da sessão](lambda-common-structures.md#lambda-session-state) para obter detalhes sobre a estrutura. ## transcriptions Uma lista de transcrições que o Amazon Lex V2 considera possíveis coincidências com o enunciado do usuário. Para obter mais informações, consulte [Uso de pontuações de confiança na transcrição de voz para melhorar as conversas com seu bot do Lex V2](using-transcript-confidence-scores.md). Cada item é um objeto com o seguinte formato que contém informações sobre uma possível transcrição: ``` { "transcription": string, "transcriptionConfidence": number, "resolvedContext": { "intent": string }, "resolvedSlots": { slot name: { // see Slots for details about the structure }, ... } } ``` Os campos são descritos abaixo: + **transcription**: uma transcrição que o Amazon Lex V2 considera uma possível correspondência com o enunciado de áudio do usuário. + **transcriptionConfidence**: uma pontuação que indica o grau de confiança do Amazon Lex V2 de que a intenção corresponde à intenção do usuário. + **resolvedContext**: uma estrutura que contém o campo `intent` que mapeia a intenção à qual o enunciado pertence. + **resolvedSlots**: uma estrutura cujas chaves são os nomes de cada slot que é resolvido pelo enunciado. Cada nome de slot é mapeado para uma estrutura que contém informações sobre esse slot. Consulte [Slots](lambda-common-structures.md#lambda-slot) para obter detalhes sobre a estrutura. # AWS Lambdaformato de resposta para Lex V2 A segunda etapa na integração de uma função do Lambda em seu bot do Amazon Lex V2 é entender os campos na resposta da função do Lambda e determinar quais parâmetros você deseja manipular. O objeto JSON a seguir mostra o formato geral de uma resposta do Lambda que é retornada ao Amazon Lex V2: ``` { "sessionState": { // see Estado da sessão for details about the structure }, "messages": [ { "contentType": "CustomPayload | ImageResponseCard | PlainText | SSML", "content": string, "imageResponseCard": { "title": string, "subtitle": string, "imageUrl": string, "buttons": [ { "text": string, "value": string }, ... ] } }, ... ], "requestAttributes": { string: string, ... } } ``` Cada campo na resposta é descrito abaixo: ## sessionState O estado da conversa entre o usuário e seu bot do Amazon Lex V2 que você deseja retornar. Consulte [Estado da sessão](lambda-common-structures.md#lambda-session-state) para obter detalhes sobre a estrutura. Este campo é sempre obrigatório. ## mensagens Uma lista de mensagens que o Amazon Lex V2 retorna ao cliente para a próxima rodada da conversa. Se o `contentType` que você fornecer for `PlainText`, `CustomPayload` ou `SSML`, escreva a mensagem que você deseja devolver ao cliente no campo `content`. Se o `contentType` que você fornecer for `ImageResponseCard`, forneça os detalhes do cartão no campo `imageResponseCard`. Se você não fornecer mensagens, o Amazon Lex V2 usa a mensagem apropriada definida quando o bot foi criado. O campo `messages` é obrigatório se `dialogAction.type` for `ElicitIntent` ou `ConfirmIntent`. Cada item na lista é uma estrutura no formato a seguir, contendo informações sobre uma mensagem a ser retornada ao usuário. Exemplo: ``` { "contentType": "CustomPayload | ImageResponseCard | PlainText | SSML", "content": string, "imageResponseCard": { "title": string, "subtitle": string, "imageUrl": string, "buttons": [ { "text": string, "value": string }, ... ] } } ``` Uma descrição para cada campo é fornecida abaixo: + **contentType**: o tipo de mensagem a ser usada. `CustomPayload`: uma string de resposta que você pode personalizar para incluir dados ou metadados para a aplicação. `ImageResponseCard`: uma imagem com botões que o cliente pode selecionar. Consulte [ImageResponseCard](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_ImageResponseCard.html) para obter mais informações. `PlainText`: uma string de texto simples. `SSML`: uma string que inclui Linguagem de marcação de síntese de fala para personalizar a resposta de áudio. + **content**: a mensagem a ser enviada ao usuário. Use esse campo se o tipo de mensagem for `PlainText`, `CustomPayload` ou `SSML`. + **imageResponseCard**— Contém a definição do cartão de resposta a ser mostrado ao usuário. Use esse campo se o tipo de mensagem for `ImageResponseCard`. Mapeia para uma estrutura que contém os seguintes campos: + **title**: o título do cartão de resposta. + **subtitle**: a solicitação para o usuário escolher um botão. + **imageUrl**: um link para uma imagem do cartão. + **buttons**: uma lista de estruturas que contém, informações sobre um botão. Cada estrutura contém um campo `text` com o texto a ser exibido e um campo `value` com o valor a ser enviado ao Amazon Lex V2, se o cliente selecionar esse botão. Você pode incluir até três botões. ## requestAttributes Uma estrutura que contém atributos específicos da solicitação para a resposta ao cliente. Consulte [Definição de atributos de solicitação para seu bot do Lex V2](context-mgmt-request-attribs.md) Para mais informações. Esse campo é opcional. ## Campos necessários na resposta No mínimo, a resposta do Lambda deve incluir um objeto `sessionState`. Dentro disso, forneça um objeto `dialogAction` e especifique o campo `type`. Dependendo do `type` de `dialogAction` que você fornecer, pode haver outros campos obrigatórios para a resposta do Lambda. Esses requisitos são descritos a seguir, juntamente com exemplos mínimos de trabalho: ### Delegate **Delegate** permite que o Amazon Lex V2 determine a próxima etapa. Nenhum outro campo é necessário. ``` { "sessionState": { "dialogAction": { "type": "Delegate" } } ``` ### ElicitIntent **ElicitIntent**solicita que o cliente expresse uma intenção. Você deve incluir pelo menos uma mensagem no campo `messages` para solicitar a elicitação de uma intenção. ``` { "sessionState": { "dialogAction": { "type": "ElicitIntent" }, "messages": [ { "contentType": PlainText, "content": "How can I help you?" } ] } ``` ### ElicitSlot **ElicitSlot**solicita que o cliente forneça um valor de slot. Você deve incluir o nome do slot no campo `slotToElicit` do objeto `dialogAction`. Você também deve incluir o `name` do `intent` no objeto `sessionState`. ``` {` "sessionState": { "dialogAction": { "slotToElicit": "OriginCity", "type": "ElicitSlot" }, "intent": { "name": "BookFlight" } } } ``` ### ConfirmIntent **ConfirmIntent**confirma os valores dos slots do cliente e se a intenção está pronta para ser cumprida. Você deve incluir o `name` do `intent` no objeto `sessionState` e o `slots` a ser confirmado. Você também deve incluir pelo menos uma mensagem no campo `messages` para solicitar ao usuário a confirmação dos valores dos slots. Sua mensagem deve gerar uma resposta “sim” ou “não”. Se o usuário responder “sim”, o Amazon Lex V2 define `confirmationState` da intenção como `Confirmed`. Se o usuário responder “não”, o Amazon Lex V2 define o `confirmationState` da intenção como `Denied`. ``` { "sessionState": { "dialogAction": { "type": "ConfirmIntent" }, "intent": { "name": "BookFlight", "slots": { "DepartureDate": { "value": { "originalValue": "tomorrow", "interpretedValue": "2023-05-09", "resolvedValues": [ "2023-05-09" ] } }, "DestinationCity": { "value": { "originalValue": "sf", "interpretedValue": "sf", "resolvedValues": [ "sf" ] } }, "OriginCity": { "value": { "originalValue": "nyc", "interpretedValue": "nyc", "resolvedValues": [ "nyc" ] } } } } }, "messages": [ { "contentType": PlainText, "content": "Okay, you want to fly from {OriginCity} to \ {DestinationCity} on {DepartureDate}. Is that correct?" } ] } ``` ### Fechar **Fechar** encerra o processo de cumprimento da intenção e indica que nenhuma resposta adicional é esperada do usuário. Você deve incluir o `name` e o `state` do `intent` no objeto `sessionState`. Os estados de intenção compatíveis são `Failed`, `Fulfilled` e `InProgress`. ``` "sessionState": { "dialogAction": { "type": "Close" }, "intent": { "name": "BookFlight", "state": "Failed | Fulfilled | InProgress" } } ``` # Estruturas comuns em uma AWS Lambda função para o Amazon Lex V2 Na resposta do Lambda, há várias estruturas que se repetem. Detalhes sobre essas estruturas comuns são fornecidos nesta seção. ## Intenção ``` "intent": { "confirmationState": "Confirmed | Denied | None", "name": string, "slots": { // see Slots for details about the structure }, "state": "Failed | Fulfilled | FulfillmentInProgress | InProgress | ReadyForFulfillment | Waiting", "kendraResponse": { // Only present when intent is KendraSearchIntent. For details, see // https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html#API_Query_ResponseSyntax } } ``` O campo `intent` é mapeado para um objeto com os seguintes campos: ### confirmationState Indica se o usuário confirmou os slots da intenção e se a intenção está pronta para ser atendida. Os seguintes valores são possíveis: `Confirmed`: o usuário confirma que os valores do slot estão corretos. `Denied`: o usuário indica que os valores do slot estão incorretos. `None`: o usuário ainda não chegou ao estágio de confirmação. ### name O nome da intenção. ### slots Informações sobre os slots necessários para cumprir a intenção. Consulte [Slots](#lambda-slot) para obter detalhes sobre a estrutura. ### estado Indica o estado de cumprimento da intenção. Os seguintes valores são possíveis: `Failed`: o bot falhou em cumprir a intenção. `Fulfilled`: o bot concluiu o cumprimento da intenção. `FulfillmentInProgress`: o bot está no meio do cumprimento da intenção. `InProgress`: o bot está no meio da obtenção dos valores de slot necessários para cumprir a intenção. `ReadyForFulfillment`: o bot obteve todos os valores do slot para a intenção e está pronto para cumpri-la. `Waiting`: o bot está aguardando uma resposta do usuário (limitado a conversas de streaming). ### kendraResponse Contém informações sobre os resultados da consulta de pesquisa do Kendra. Esse campo aparecerá somente se a intenção for `KendraSearchIntent`. Consulte [a sintaxe de resposta na chamada de API de Consulta para Kendra](https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html#API_Query_ResponseSyntax) Para mais informações. ## Slots O campo `slots` existe dentro de uma estrutura `intent` e é mapeado para uma estrutura cujas chaves são os nomes dos slots para essa intenção. Se o slot não for um slot de vários valores (consulte [Usar vários valores em um slot](multi-valued-slots.md) para obter mais detalhes), ele será mapeado para uma estrutura com o formato a seguir. Observe que o `shape` é `Scalar`. ``` { slot name: { "shape": "Scalar", "value": { "originalValue": string, "interpretedValue": string, "resolvedValues": [ string, ... ] } } } ``` Se o slot for um slot de vários valores, o objeto para o qual ele é mapeado contém outro campo chamado `values`, que é mapeado para uma lista de estruturas, cada uma contendo informações sobre um slot que compõe o slot de vários valores. O formato de cada objeto na lista corresponde ao do objeto para o qual um slot normal é mapeado. Observe que o `shape` é `List`, mas o `shape` dos slots de componentes abaixo `values` é `Scalar`. ``` { slot name: { "shape": "List", "value": { "originalValue": string, "interpretedValue": string, "resolvedValues": [ string, ... ] }, "values": [ { "shape": "Scalar", "value": { "originalValue": string, "interpretedValue": string, "resolvedValues": [ string, ... ] } }, { "shape": "Scalar", "value": { "originalValue": string, "interpretedValue": string, "resolvedValues": [ string, ... ] } }, ... ] } ``` Os campos no objeto do slot estão descritos abaixo: ### shape O formato do slot. Esse valor é `List` válido se houver vários valores no slot (consulte [Usar vários valores em um slot](multi-valued-slots.md) para obter mais detalhes) e, caso contrário, é `Scalar`. ### valor Um objeto contendo informações sobre o valor que o usuário forneceu para um slot e a interpretação do Amazon Lex V2, no seguinte formato: ``` { "originalValue": string, "interpretedValue": string, "resolvedValues": [ string, ... ] } ``` Os campos são descritos abaixo: + **OriginalValue** — A parte da resposta do usuário à elicitação do slot que o Amazon Lex V2 determina ser relevante para o valor do slot. + **InterpretedValue** — O valor que o Amazon Lex V2 determina para o slot, de acordo com a entrada do usuário. + **ResolvedValues** — Uma lista de valores que o Amazon Lex V2 determina como possíveis resoluções para a entrada do usuário. ### values Uma lista de objetos contendo informações sobre os slots que compõem o slot de vários valores. O formato de cada objeto corresponde ao de um slot normal, com os campos `shape` e `value` descritos acima. `values` só aparece se o slot consistir em vários valores (consulte [Usar vários valores em um slot](multi-valued-slots.md) para obter mais detalhes). O objeto JSON a seguir mostra dois slots de componentes: ``` "values": [ { "shape": "Scalar", "value": { "originalValue": string, "interpretedValue": string, "resolvedValues": [ string, ... ] } }, { "shape": "Scalar", "value": { "originalValue": string, "interpretedValue": string, "resolvedValues": [ string, ... ] } }, ... ] ``` ## Estado da sessão O campo `sessionState` é mapeado para um objeto contendo informações sobre o estado da conversa com o usuário. Os campos reais que aparecem no objeto dependem do tipo de ação da caixa de diálogo. Consulte [Campos necessários na resposta](lambda-response-format.md#lambda-response-required) para obter os campos obrigatórios em uma resposta do Lambda. O formato do objeto `sessionState` é o seguinte: ``` "sessionState": { "activeContexts": [ { "name": string, "contextAttributes": { string: string }, "timeToLive": { "timeToLiveInSeconds": number, "turnsToLive": number } }, ... ], "sessionAttributes": { string: string, ... }, "runtimeHints": { "slotHints": { intent name: { slot name: { "runtimeHintValues": [ { "phrase": string }, ... ] }, ... }, ... } }, "dialogAction": { "slotElicitationStyle": "Default | SpellByLetter | SpellByWord", "slotToElicit": string, "type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot" }, "intent": { // see Intenção for details about the structure }, "originatingRequestId": string } ``` Os campos são descritos abaixo: ### activeContexts Uma lista de objetos que contém informações sobre um contexto que um usuário está usando em uma sessão. Use contextos para facilitar e controlar o reconhecimento de intenções. Para mais informações sobre contextos, consulte [Definição do contexto de intenção para seu bot do Lex V2](context-mgmt-active-context.md). Cada objeto é formatado como segue: ``` { "name": string, "contextAttributes": { string: string }, "timeToLive": { "timeToLiveInSeconds": number, "turnsToLive": number } } ``` Os campos são descritos abaixo: + **name**: o nome do contexto. + **contextAttributes**: um objeto que contém os nomes dos atributos do contexto e os valores para os quais eles são mapeados. + **timeToLive**— Um objeto que especifica por quanto tempo o contexto permanece ativo. Esse objeto pode conter um ou ambos os seguintes campos: + **timeToLiveInSeconds**— O número de segundos em que o contexto permanece ativo. + **turnsToLive**— O número de turnos em que o contexto permanece ativo. ### sessionAttributes Um mapa de key/value pares representando informações de contexto específicas da sessão. Para obter mais informações, consulte [Definição de atributos de sessão para seu bot do Lex V2](context-mgmt-session-attribs.md). O objeto é formatado da seguinte forma: ``` { string: string, ... } ``` ### runtimeHints Fornece dicas sobre as frases que um cliente provavelmente usará em um slot para melhorar o reconhecimento de áudio. Os valores que você fornece nas dicas aumentam o reconhecimento de áudio desses valores em relação a palavras com sons semelhantes. O formato do objeto `runtimeHints` é o seguinte: ``` { "slotHints": { intent name: { slot name: { "runtimeHintValues": [ { "phrase": string }, ... ] }, ... }, ... } } ``` O campo `slotHints` é mapeado para um objeto cujos campos são os nomes das intenções no bot. Cada nome de intenção é mapeado para um objeto cujos campos são os nomes dos slots dessa intenção. Cada nome de slot é mapeado para uma estrutura com um único campo `runtimeHintValues`, que é uma lista de objetos. Cada objeto contém um campo `phrase` que é mapeado para uma dica. ### dialogAction Determina a próxima ação a ser tomada pelo Amazon Lex V2. O formato do objeto é o seguinte: ``` { "slotElicitationStyle": "Default | SpellByLetter | SpellByWord", "slotToElicit": string, "type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot" } ``` Os campos são descritos abaixo: + **slotElicitationStyle**— Determina como o Amazon Lex V2 interpreta a entrada de áudio do usuário, se for o `type` caso. `dialogAction` `ElicitSlot` Para obter mais informações, consulte [Captura de valores de slots com estilos ortográficos durante a conversa](spelling-styles.md). Os seguintes valores são possíveis: `Default`: o Amazon Lex V2 interpreta a entrada de áudio da maneira padrão para preencher um slot. `SpellByLetter`: o Amazon Lex V2 escuta a ortografia do valor do slot pelo usuário. `SpellByWord`: o Amazon Lex V2 escuta a ortografia do valor do slot pelo usuário usando palavras associadas a cada letra (por exemplo, “a como em avião”). + **slotToElicit**— Define o slot a ser extraído do usuário se o `type` for. `dialogAction` `ElicitSlot` + **type**: define a ação que o bot deve executar. Os seguintes valores são possíveis: `Delegate`: permite que o Amazon Lex V2 determine a próxima etapa. `ElicitIntent`: solicita que o cliente expresse uma intenção. `ConfirmIntent`: confirma os valores dos slots do cliente e se a intenção está pronta para ser cumprida. `ElicitSlot`: solicita que o cliente forneça um valor de slot para uma intenção. `Close`: encerra o processo de cumprimento da intenção. ### intent Consulte [Intenção](#lambda-intent) para obter a estrutura do campo `intent`. ### originatingRequestId Um identificador exclusivo da solicitação. Esse campo é opcional para a resposta do Lambda. # Criação de uma AWS Lambda função para seu bot Amazon Lex V2 Para criar uma função Lambda para seu bot Amazon Lex V2, acesse AWS Lambda seu AWS Management Console e crie uma nova função. Você pode consultar o [guia do AWS Lambda desenvolvedor](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) para obter mais detalhes sobreAWS Lambda. 1. Faça login no AWS Management Console e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Escolha **Funções** na barra lateral esquerda. 1. Selecione **Criar função**. 1. Você pode selecionar **Criar do zero** para começar com o mínimo de código, **Usar um esquema** para selecionar o código de amostra para casos de uso comuns em uma lista, ou **Imagem do contêiner** para selecionar um contêiner a ser implantado em sua função. Se você selecionar **Criar do zero**, continue com as seguintes etapas: 1. Dê à sua função um **Nome de função** significativo para descrever o que ela faz. 1. Escolha um idioma no menu suspenso em **Runtime** para escrever sua função. 1. Selecione uma **Arquitetura** de conjunto de instruções para sua função. 1. Por padrão, o Lambda cria um perfil com permissões básicas. Para usar uma função existente ou criar uma função usando modelos de políticas da AWS, expanda o menu **Alterar função de execução padrão** e selecione uma opção. 1. Expanda o menu **Configurações avançadas** para configurar mais opções. 1. Selecione **Criar função**. A imagem a seguir mostra o que você vê ao criar uma nova função do zero: ![\[Uma nova função do Lambda.\]](http://docs.aws.amazon.com/pt_br/lexv2/latest/dg/images/lambda/lambda-new-function.png) A função do manipulador do Lambda difere dependendo da linguagem que você usa. Ele usa minimamente um objeto JSON do `event` como argumento. Você pode ver os campos no `event` que o Amazon Lex V2 fornece em [AWS Lambdaformato de evento de entrada para Lex V2](lambda-input-format.md). Modifique a função do manipulador para finalmente retornar um objeto JSON de `response` que corresponda ao formato descrito em [AWS Lambdaformato de resposta para Lex V2](lambda-response-format.md). + Depois de terminar de escrever sua função, selecione **Implantar** para permitir que a função seja usada. Lembre-se de que você pode associar cada alias de bot a, no máximo, uma função do Lambda. No entanto, você pode definir quantas funções precisar para seu bot no código do Lambda e chamar essas funções na função do manipulador do Lambda. Por exemplo, embora todas as intenções no mesmo alias de bot devam chamar a mesma função do Lambda, você pode criar uma função de roteador que ative uma função separada para cada intenção. Veja a seguir um exemplo de função de roteador que você pode usar ou modificar para sua aplicação: ``` import os import json import boto3 # reuse client connection as global client = boto3.client('lambda') def router(event): intent_name = event['sessionState']['intent']['name'] fn_name = os.environ.get(intent_name) print(f"Intent: {intent_name} -> Lambda: {fn_name}") if (fn_name): # invoke lambda and return result invoke_response = client.invoke(FunctionName=fn_name, Payload = json.dumps(event)) print(invoke_response) payload = json.load(invoke_response['Payload']) return payload raise Exception('No environment variable for intent: ' + intent_name) def lambda_handler(event, context): print(event) response = router(event) return response ``` **Quando usar AWS Lambda funções nas conversas de bots do Amazon Lex V2** Você pode usar as funções do Lambda nos seguintes pontos de uma conversa com um usuário: + Na resposta inicial após o reconhecimento da intenção. Por exemplo, depois que o usuário diz que quer pedir uma pizza. + Depois de obter um valor de slot do usuário. Por exemplo, depois que o usuário informa ao bot o tamanho da pizza que deseja pedir. + Entre cada nova tentativa para obter um slot. Por exemplo, se o cliente não usar um tamanho de pizza reconhecido. + Ao confirmar uma intenção. Por exemplo, ao confirmar um pedido de pizza. + Para cumprir uma intenção. Por exemplo, para fazer um pedido de pizza. + Depois de cumprir a intenção e antes que seu bot encerre a conversa. Por exemplo, para mudar para a intenção de pedir uma bebida. **Topics** + [Anexe uma AWS Lambda função a um bot do Amazon Lex V2 usando o console](lambda-attach-console.md) + [Anexe uma AWS Lambda função a um bot do Amazon Lex V2 usando operações de API](lambda-attach-api.md) # Anexe uma AWS Lambda função a um bot do Amazon Lex V2 usando o console Você deve primeiro anexar uma função Lambda ao seu alias de bot do Amazon Lex V2 antes de poder invocá-la. Você só pode anexar uma função do Lambda a cada alias do bot. Execute estas etapas para anexar a função do Lambda usando o Console da AWS. 1. Faça login no AWS Management Console e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/). 1. Escolha **Bots** no painel lateral esquerdo e, na lista de bots, escolha o nome do bot ao qual você deseja anexar uma função do Lambda. 1. No painel do lado esquerdo, selecione **Aliases** no menu **Implantação**. 1. Na lista de aliases, escolha o nome do alias ao qual você deseja anexar uma função do Lambda. 1. No painel **Idiomas**, selecione o idioma para o qual você deseja que uma função do Lambda use. Selecione **Gerenciar idiomas no alias** para adicionar um idioma, se ele não estiver no painel. 1. No menu suspenso **Fonte**, escolha o nome da função do Lambda que você deseja anexar. 1. No menu suspenso **Versão da função do Lambda ou do alias**, escolha a versão ou o alias da função do Lambda que você deseja usar. Em seguida, selecione**Salvar**. A mesma função do Lambda é usada para todos os efeitos em uma linguagem com suporte pelo bot. **Configurando uma intenção do Amazon Lex V2 para invocar uma função Lambda usando o console** 1. Depois de selecionar um bot, selecione **Intenções** no menu do lado esquerdo, abaixo do idioma do bot para o qual você deseja invocar a função do Lambda. 1. Escolha a intenção na qual você deseja invocar a função do Lambda para abrir o editor de intenção. 1. Há duas opções para configurar o hook de código do Lambda: 1. Para invocar a função do Lambda após cada etapa da conversa, vá até a seção **Hooks de código** na parte inferior do editor de intenção e marque a caixa de seleção **Usar uma função do Lambda para inicialização e validação**, como na imagem a seguir: ![\[A seção de hooks de código do editor de intenções do Amazon Lex V2.\]](http://docs.aws.amazon.com/pt_br/lexv2/latest/dg/images/lambda/lambda-code-hooks-all.png) 1. Como alternativa, use a seção **Hook de código de diálogo** nos estágios de conversação para invocar a função do Lambda. A seção de **Hook de código de diálogo** aparece da seguinte forma: ![\[A seção de hooks de código do editor de intenções do Amazon Lex V2.\]](http://docs.aws.amazon.com/pt_br/lexv2/latest/dg/images/lambda/lambda-code-hook-step.png) Há duas maneiras de controlar como o Amazon Lex V2 chama o hook de código para obter uma resposta: + Alterne o botão **Ativo** para marcá-lo como *ativo* ou *inativo*. Quando um hook de código está *ativo*, o Amazon Lex V2 chama o hook de código. Quando o hook de código está *inativo*, o Amazon Lex V2 não executa o hook de código. + Expanda a seção de **Hook de código de diálogo do Lambda** e marque a caixa de seleção **Invocar função do Lambda** para marcá-la como *habilitada* ou *desabilitada*. Você só pode habilitar ou desabilitar um hook de código quando ele estiver marcado como ativo. Quando marcado como *habilitado*, o hook de código é executado normalmente. Quando estiver *desabilitado*, o hook de código não é chamado e o Amazon Lex V2 age como se o hook de código tivesse sido retornado com sucesso. Para configurar respostas após o gancho do código de diálogo ser bem-sucedido, falhar ou expirar, selecione **Opções avançadas** O hook de código do Lambda pode ser invocado nos seguintes estágios de conversação: + Para invocar a função como **resposta inicial**, vá até a seção **Resposta inicial**, expanda a seta ao lado de **Resposta para reconhecer a solicitação do usuário** e selecione **Opções avançadas**. Encontre a seção **Hook de código de diálogo** na parte inferior do menu que aparece. + Para invocar a função após a **elicitação do slot**, vá até a seção **Slots**, expanda a seta ao lado da **Solicitação de slot** relevante e selecione **Opções avançadas**. Encontre a seção de **Hook de código de diálogo** na parte inferior do menu que aparece, logo acima dos **Valores padrão**. Você também pode invocar a função após cada elicitação. Para fazer isso, expanda a opção **Bot elicita informações** na seção **Mensagens de slot**, selecione **Mais opções de prompt** e marque a caixa de seleção ao lado de **Invocar hook de código do Lambda após cada elicitação**. + Para invocar a função para **confirmação da intenção**, vá até a seção **Confirmação**, expanda a seta ao lado de **Solicitações para confirmar a intenção** e selecione **Opções avançadas.** Encontre a seção **Hook de código de diálogo** na parte inferior do menu que aparece. + Para invocar a função para **cumprimento da intenção**, vá até a seção **Cumprimento**. Alterne o botão **Ativo** para definir o hook de código como *ativo*. Expanda a seta ao lado de **Sobre o atendimento bem-sucedido** e selecione **Opções avançadas**. Marque a caixa de seleção ao lado de **Usar uma função do Lambda para cumprimento** na seção **Hook de código do Lambda de atendimento** para definir o hook de código como *habilitado*. 1. Depois de definir os estágios da conversa nos quais será invocada a função do Lambda, **Crie** o bot novamente para testar a função. # Anexe uma AWS Lambda função a um bot do Amazon Lex V2 usando operações de API Você deve primeiro anexar uma função Lambda ao seu alias de bot do Amazon Lex V2 antes de poder invocá-la. Você só pode associar uma função do Lambda a cada alias do bot. Execute estas etapas para anexar a função do Lambda usando operações de API. Se você estiver criando um novo alias de bot, use a [CreateBotAlias](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateBotAlias.html)operação para anexar uma função Lambda. Para anexar uma função Lambda a um alias de bot existente, use a operação. [UpdateBotAlias](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateBotAlias.html) Modifique o campo `botAliasLocaleSettings` para conter as configurações corretas: ``` { "botAliasLocaleSettings" : { locale: { "codeHookSpecification": { "lambdaCodeHook": { "codeHookInterfaceVersion": "1.0", "lambdaARN": "arn:aws:lambda:region:account-id:function:function-name" } }, "enabled": true }, ... } } ``` 1. O campo `botAliasLocaleSettings` é mapeado para um objeto cujas chaves são as localidades nas quais você deseja anexar a função do Lambda. Consulte [Idiomas e locais compatíveis](how-languages.md#supported-languages) para obter uma lista das localidades com suporte e os códigos que são chaves válidas. 1. Para encontrar uma função Lambda, abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/casa](https://console.aws.amazon.com/lambda/home), selecione **Funções** na barra lateral esquerda e selecione a função a ser associada ao alias do bot. `lambdaARN` No lado direito da **Visão geral da função**, encontre o `lambdaARN` em **ARN da função**. Ele deve conter uma região, o ID da conta e o nome da função. 1. Para permitir que o Amazon Lex V2 invoque a função do Lambda para o alias, defina o campo `enabled` como `true`. **Definindo uma intenção do Amazon Lex V2 para invocar uma função Lambda usando operações de API** Para configurar a invocação da função Lambda durante uma intenção, use a [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)operação se estiver criando uma nova intenção ou a [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)operação se estiver invocando a função em uma intenção existente. Os campos que controlam a invocação da função do Lambda nas operações de intenção são `dialogCodeHook`, `initialResponseSetting`, `intentConfirmationSetting` e `fulfillmentCodeHook`. Se você invocar a função durante a elicitação de um slot, use a [CreateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html)operação se estiver criando um novo slot ou a [UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html)operação para invocar a função em um slot existente. O campo que controla a invocação da função do Lambda nas operações do slot é o `slotCaptureSetting` do objeto `valueElicitationSetting`. 1. Para configurar o gancho de código de diálogo do Lambda para ser executado após cada turno da conversa, defina o `enabled` campo do seguinte [DialogCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogCodeHookSettings.html)objeto no `dialogCodeHook` campo como: `true` ``` "dialogCodeHook": { "enabled": boolean } ``` 1. Como alternativa, você pode definir o gancho de código de diálogo do Lambda para ser executado somente em pontos específicos das conversas, modificando o `codeHook` and/or `elicitationCodeHook` campo nas estruturas que correspondem aos estágios da conversa nos quais você deseja invocar a função. Para usar o gancho de código de diálogo Lambda para cumprimento da intenção, use o `fulfillmentCodeHook` campo na operação ou. [CreateIntent[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html) As estruturas e os usos desses três tipos de hooks de código são os seguintes: ## codeHook O campo `codeHook` define as configurações para que o hook de código seja executado em um determinado estágio da conversa. É um [DialogCodeHookInvocationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogCodeHookInvocationSetting.html)objeto com a seguinte estrutura: ``` "codeHook": { "active": boolean, "enableCodeHookInvocation": boolean, "invocationLabel": string, "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html), } ``` + Altere o campo `active` para `true` para que o Amazon Lex V2 chame o hook de código nesse ponto da conversa. + Altere o campo `enableCodeHookInvocation` para `true` para o Amazon Lex V2 permitir que o hook de código seja executado normalmente. Se você marcá-lo como `false`, o Amazon Lex V2 age como se o hook de código tivesse sido retornado com sucesso. + O `invocationLabel` indica a etapa da caixa de diálogo a partir da qual o hook de código é invocado. + Use o campo `postCodeHookSpecification` para especificar as ações e mensagens que ocorrem após o hook de código ser bem-sucedido, falhar ou atingir o tempo limite. ## elicitationCodeHook O campo `elicitationCodeHook` define as configurações para que o hook de código seja executado no caso de um slot ou slots precisarem ser reutilizados. Esse cenário pode ocorrer se a elicitação do slot falhar ou a confirmação da intenção for negada. O `elicitationCodeHook` campo é um [ElicitationCodeHookInvocationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ElicitationCodeHookInvocationSetting.html)objeto com a seguinte estrutura: ``` "elicitationCodeHook": { "enableCodeHookInvocation": boolean, "invocationLabel": string } ``` + Altere o campo `enableCodeHookInvocation` para `true` para o Amazon Lex V2 permitir que o hook de código seja executado normalmente. Se você marcá-lo como `false`, o Amazon Lex V2 age como se o hook de código tivesse sido retornado com sucesso. + O `invocationLabel` indica a etapa da caixa de diálogo a partir da qual o hook de código é invocado. ## fulfillmentCodeHook O campo `fulfillmentCodeHook` define as configurações do hook de código a ser executado para cumprir a intenção. Ele mapeia para o seguinte [FulfillmentCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentCodeHookSettings.html)objeto: ``` "fulfillmentCodeHook": { "active": boolean, "enabled": boolean, "fulfillmentUpdatesSpecification": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html), "postFulfillmentStatusSpecification": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html) } ``` + Altere o campo `active` para `true` para que o Amazon Lex V2 chame o hook de código nesse ponto da conversa. + Altere o campo `enabled` para `true` para o Amazon Lex V2 permitir que o hook de código seja executado normalmente. Se você marcá-lo como `false`, o Amazon Lex V2 age como se o hook de código tivesse sido retornado com sucesso. + Use o campo `fulfillmentUpdatesSpecification` para especificar as mensagens que aparecem para atualizar o usuário durante o cumprimento da intenção e o tempo associado a elas. + Use o campo `postFulfillmentStatusSpecification` para especificar as mensagens e ações que ocorrem após o hook de código ser bem-sucedido, falhar ou atingir o tempo limite. Você pode invocar o hook de código do Lambda nos seguintes pontos de uma conversa definindo os campos `active` e `enableCodeHookInvocation`/`enabled` como `true`: ## Durante a resposta inicial Para invocar a função Lambda na resposta inicial após o reconhecimento da intenção, use `codeHook` a estrutura no campo `initialResponse` da [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)operação or. [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html) O `initialResponse` campo mapeia para o seguinte [InitialResponseSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_InitialResponseSetting.html)objeto: ``` "initialResponse": { "codeHook": { "active": boolean, "enableCodeHookInvocation": boolean, "invocationLabel": string, "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html), }, "initialResponse": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html), "nextStep": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html), "conditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html) } ``` ## Após a elicitação do slot ou durante a nova elicitação do slot Para invocar a função Lambda depois de obter um valor de slot, use `slotCaptureSetting` o campo dentro do campo `valueElicitation` da operação ou. [CreateSlot[UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html)](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html) O `slotCaptureSetting` campo mapeia para o seguinte [SlotCaptureSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_SlotCaptureSetting.html)objeto: ``` "slotCaptureSetting": { "captureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html), "captureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html), "captureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html), "codeHook": { "active": true, "enableCodeHookInvocation": true, "invocationLabel": string, "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html), }, "elicitationCodeHook": { "enableCodeHookInvocation": boolean, "invocationLabel": string }, "failureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html), "failureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html), "failureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html) } ``` + Para invocar a função do Lambda depois que a elicitação do slot for bem-sucedida, use o campo `codeHook`. + Para invocar a função do Lambda depois que a elicitação de slots falhar e o Amazon Lex V2 tentar novamente a elicitação de slots, use o campo `elicitationCodeHook`. ## Após confirmação ou negação da intenção Para invocar a função Lambda ao confirmar uma intenção, use `intentConfirmationSetting` o campo da operação ou. [CreateIntent[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html) O `intentConfirmation` campo mapeia para o seguinte [IntentConfirmationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_IntentConfirmationSetting.html)objeto: ``` "intentConfirmationSetting": { "active": boolean, "codeHook": { "active": boolean, "enableCodeHookInvocation": boolean, "invocationLabel": string, "postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html), }, "confirmationConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html), "confirmationNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html), "confirmationResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialResponseSpecificationogState.html), "declinationConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html), "declinationNextStep": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html), "declinationResponse": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html), "elicitationCodeHook": { "enableCodeHookInvocation": boolean, "invocationLabel": string, }, "failureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html), "failureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html), "failureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html), "promptSpecification": [PromptSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PromptSpecification.html) } ``` + Para invocar a função do Lambda após o usuário confirmar a intenção e seus slots, use o campo `codeHook`. + Para invocar a função do Lambda depois que o usuário negar a confirmação da intenção e o Amazon Lex V2 tentar novamente a elicitação de slots, use o campo `elicitationCodeHook`. ## Durante o cumprimento da intenção Para invocar a função Lambda para cumprir uma intenção, use `fulfillmentCodeHook` o campo na [CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)operação ou. [UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html) O `fulfillmentCodeHook` campo mapeia para o seguinte [FulfillmentCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentCodeHookSettings.html)objeto: ``` { "active": boolean, "enabled": boolean, "fulfillmentUpdatesSpecification": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html), "postFulfillmentStatusSpecification": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html) } ``` 3. Depois de definir os estágios da conversa nos quais invocar a função do Lambda, use a operação `BuildBotLocale` para reconstruir o bot a fim de testar a função. # Depuração de uma função Lambda usando registros de registros CloudWatch O [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) é uma ferramenta para rastrear chamadas e métricas de API que você pode usar para ajudar a depurar suas funções do Lambda. Quando você testa seu bot no console ou com chamadas de API, CloudWatch registra cada etapa da conversa. Se você usar uma função de impressão em seu código Lambda, ela também CloudWatch será exibida. **Para visualizar CloudWatch os registros da sua função Lambda** 1. Faça login no AWS Management Console e abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No menu **Logs** na barra lateral esquerda, selecione **Grupos de logs**. 1. Selecione seu grupo de logs de funções do Lambda, que deve ter o formato `/aws/lambda/function-name`. 1. A lista de **Fluxos de log** contém um log para cada sessão com um bot. Escolha um fluxo de logs para visualizá-lo. 1. Na lista de **Eventos do log**, selecione a seta para a direita ao lado de **Data e hora** para expandir os detalhes desse evento. Tudo o que você imprimir do seu código Lambda aparecerá como um evento de log. Use essas informações para depurar seu código. 1. Depois de depurar seu código, lembre-se de **implantar** a função do Lambda e, se estiver usando o console, de recarregar a janela de teste antes de **Testar** novamente o comportamento do bot.