Aviso de fim do suporte: em 15 de setembro de 2025, o suporte para o Amazon Lex V1 AWS será interrompido. Após 15 de setembro de 2025, você não poderá mais acessar o console do Amazon Lex V1 nem os respectivos recursos. Se você estiver usando o Amazon Lex V2, consulte o [guia do Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html) em vez disso.
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á.
# Detalhes do fluxo de informações
Neste exercício, você se envolveu em uma conversa com o BookTrip bot do Amazon Lex usando o cliente de janela de teste fornecido no console do Amazon Lex. Esta seção explica o seguinte:
+ O fluxo de dados entre o cliente e o Amazon Lex..
A seção supõe que o cliente envia solicitações ao Amazon Lex usando a API de runtime `PostText` e mostra os detalhes da solicitação e da resposta adequadamente. Para obter mais informações sobre a API de runtime `PostText`, consulte [PostText](API_runtime_PostText.md).
**nota**
Para obter um exemplo do fluxo de informações entre o cliente e o Amazon Lex no qual o cliente usa a API `PostContent`, consulte [Etapa 2a (opcional): revisar os detalhes do fluxo de informações falado (console)](gs-bp-details-postcontent-flow.md).
+ O fluxo de dados entre Amazon Lex e a função do Lambda. Para obter mais informações, consulte [Evento de entrada de função do Lambda e formato de resposta](lambda-input-response-format.md).
**Topics**
+ [Fluxo de dados: intenção Book Hotel](#data-flow-book-hotel)
+ [Fluxo de dados: intenção Book Car](#data-flow-book-car)
## Fluxo de dados: intenção Book Hotel
Esta seção explica o que acontece após cada entrada do usuário.
1. Usuário: "reservar um hotel"
1. O cliente (console) envia a seguinte solicitação [PostText](API_runtime_PostText.md) para o Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"book a hotel",
"sessionAttributes":{}
}
```
Tanto o URI de solicitação como o corpo fornecem informações para Amazon Lex:
+ URI de solicitação — Fornece o nome do bot (BookTrip), o alias do bot (\$1LATEST) e o nome do usuário. O `text` final indica que esta é uma solicitação de API `PostText` (e não `PostContent`).
+ Corpo da solicitação: inclui a entrada do usuário (`inputText`) e `sessionAttributes` vazio. Inicialmente, esse é um objeto vazio e a função do Lambda primeiro define os atributos de sessão.
1. A partir de `inputText`, o Amazon Lex detecta a intenção (BookHotel). Essa intenção é configurado com uma função do Lambda como um hook de código para inicialização/validação de dados do usuário. Portanto, o Amazon Lex invoca essa função do Lambda passando as seguintes informações como o parâmetro do evento (consulte [Formato de eventos de entrada](lambda-input-response-format.md#using-lambda-input-event-format)):
```
{
"messageVersion":"1.0",
"invocationSource":"DialogCodeHook",
"userId":"wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes":{
},
"bot":{
"name":"BookTrip",
"alias":null,
"version":"$LATEST"
},
"outputDialogMode":"Text",
"currentIntent":{
"name":"BookHotel",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
},
"confirmationStatus":"None"
}
}
```
Além das informações enviadas pelo cliente, o Amazon Lex também inclui os seguintes dados adicionais:
+ `messageVersion`: atualmente, o Amazon Lex oferece suporte apenas à versão 1.0.
+ `invocationSource`: indica o objetivo da invocação da função do Lambda. Nesse caso, o objetivo é executar os dados de inicialização e validação do usuário (nesse momento, o Amazon Lex sabe que o usuário não forneceu todos os dados de slot para atender à intenção).
+ `currentIntent` - Todos os valores de slot são definidos como nulos.
1. No momento, todos os valores de slot são nulos. Não há nada para a função do Lambda validar. A função do Lambda retorna a seguinte resposta para Amazon Lex. Para obter mais informações sobre o formato de resposta, consulte [Formato de resposta](lambda-input-response-format.md#using-lambda-response-format).
```
{
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction":{
"type":"Delegate",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
}
}
}
```
**nota**
`currentReservation`: a função do Lambda inclui este atributo de sessão. Seu valor é uma cópia das informações do slot atual e do tipo de reserva.
Somente o cliente e a função do Lambda podem definir e atualizar esses atributos de sessão. Amazon Lex simplesmente passa esses valores.
`dialogAction.type`: ao definir esse valor como `Delegate`, a função do Lambda delega a responsabilidade da próxima ação para Amazon Lex.
Se a função do Lambda tiver detectado algo na validação dos dados do usuário, ela instruirá o Amazon Lex sobre o que fazer a seguir.
1. De acordo com o `dialogAction.type`, o Amazon Lex decide a próxima ação: obter dados do usuário para o slot `Location`. Ele seleciona um dos prompts de mensagens ("Em que cidade você se hospedará?") para esse slot, de acordo com a configuração da intenção, e envia a seguinte resposta de volta ao usuário:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-10.png)
Os atributos de sessão são passados para o cliente.
O cliente lê a resposta e, em seguida, exibe a mensagem: "Em qual cidade você se hospedará?"
1. Usuário: "Moscou"
1. O cliente envia a seguinte solicitação `PostText` para Amazon Lex (quebras de linha adicionadas para a capacidade de leitura):
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Moscow",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":null,
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
Além do `inputText`, o cliente inclui os mesmos atributos de sessão `currentReservation` que recebeu.
1. Primeiro, o Amazon Lex interpreta o `inputText` no contexto da intenção atual (o serviço lembra que pediu ao usuário específico informações sobre o slot `Location`). Ele atualiza o valor de slot para a intenção atual e invoca a função do Lambda usando o evento a seguir:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Moscow"
},
"confirmationStatus": "None"
}
}
```
**nota**
`invocationSource` continua sendo `DialogCodeHook`. Nesta etapa, estamos apenas validando os dados do usuário.
Amazon Lex está apenas passando o atributo de sessão para a função do Lambda.
Para `currentIntent.slots`, Amazon Lex atualizou o slot `Location` para `Moscow`.
1. A função do Lambda executa a validação dos dados do usuário e determina que `Moscow` é um local inválido.
**nota**
A função do Lambda neste exercício tem uma lista simples de cidades válidas e `Moscow` não está na lista. Em uma aplicação de produção, você pode usar um banco de dados de back-end para obter essas informações.
Ele redefine o valor de slot novamente como nulo e direciona o Amazon Lex a solicitar outro valor ao usuário enviando a seguinte resposta:
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Moscow\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": null
},
"slotToElicit": "Location",
"message": {
"contentType": "PlainText",
"content": "We currently do not support Moscow as a valid destination. Can you try a different city?"
}
}
}
```
**nota**
`currentIntent.slots.Location` é redefinido como nulo.
`dialogAction.type` é definido como `ElicitSlot`, que direciona Amazon Lex a solicitar o usuário novamente, fornecendo o seguinte:
`dialogAction.slotToElicit`: slot para onde obter dados do usuário.
`dialogAction.message`: um `message` para transmitir ao usuário.
1. Amazon Lex avisa o `dialogAction.type` e passa as informações para o cliente na resposta a seguir:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-20.png)
O cliente simplesmente exibe a mensagem: "No momento, não oferecemos suporte a Moscou como um destino válido. Poderia tentar outra cidade?"
1. Usuário: "Chicago"
1. O cliente envia a seguinte solicitação `PostText` para o Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Chicago",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Moscow\",
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
1. Amazon Lex sabe o contexto de onde estava escolhendo dados para o slot `Location`. Nesse contexto, ele sabe que o valor `inputText` é para o slot `Location`. Em seguida, ele invoca a função do Lambda enviando o seguinte evento:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":Moscow,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex atualizou o `currentIntent.slots` ao definir o slot `Location` como `Chicago`.
1. De acordo com o valor `invocationSource` de `DialogCodeHook`, a função do Lambda executa a validação dos dados do usuário. Ela reconhece `Chicago` como um valor de slot válido, atualiza o atributo de sessão adequadamente e, em seguida, retorna a seguinte resposta ao Amazon Lex.
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "Delegate",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
}
}
}
```
**nota**
`currentReservation`: a função do Lambda atualiza esse atributo de sessão definindo o `Location` como `Chicago`.
`dialogAction.type`: é definido como `Delegate`. Os dados do usuário são válidos e a função do Lambda direciona Amazon Lex a escolher a próxima ação.
1. De acordo com o `dialogAction.type`, Amazon Lex escolhe a próxima ação. Amazon Lex sabe que precisa de mais dados de slot e escolhe o próximo slot não preenchido (`CheckInDate`) com a maior prioridade de acordo com a configuração de intenção. Ele seleciona um dos prompts de mensagens ("Em que dia você deseja fazer check-in?") para esse slot, de acordo com a configuração da intenção, e envia a seguinte resposta de volta ao cliente:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots. O espaço de localização agora está preenchido como Chicago.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-30.png)
O cliente exibe a mensagem: "Em que dia você deseja fazer check-in?"
1. A interação do usuário continua. O usuário fornece os dados, a função do Lambda valida os dados e, em seguida, delega a próxima ação para o Amazon Lex. Por fim, o usuário fornece todos os dados do slot, a função do Lambda valida todas as entradas do usuário e, em seguida, o Amazon Lex reconhece que tem todos os dados do slot.
**nota**
Neste exercício, depois que o usuário fornece todos os dados do slot, a função do Lambda calcula o preço da reserva de hotel e o retorna como outro atributo de sessão (`currentReservationPrice`).
Nesse momento, a intenção está pronta para ser cumprida, mas a BookHotel intenção é configurada com um aviso de confirmação que exige a confirmação do usuário antes que o Amazon Lex possa cumprir a intenção. Portanto, o Amazon Lex envia a seguinte mensagem ao cliente solicitando a confirmação antes de reservar o hotel:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots. Todos os slots agora estão preenchidos.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-40.png)
O cliente exibe a mensagem: "OK, reservarei para você 5 diárias em Chicago a partir de 18/12/2016. Posso fazer a reserva?"
1. Usuário: "sim"
1. O cliente envia a seguinte solicitação `PostText` para o Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Yes",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}",
"currentReservationPrice":"1195"
}
}
```
1. O Amazon Lex interpreta o `inputText` no contexto de confirmação da intenção atual. Amazon Lex entende que o usuário deseja prosseguir com a reserva. Dessa vez, o Amazon Lex invoca a função do Lambda para atender à intenção enviando o seguinte evento. Ao definir o `invocationSource` como `FulfillmentCodeHook` no evento, ele envia para a função do Lambda. O Amazon Lex também define o `confirmationStatus` como `Confirmed`.
```
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservationPrice": "956"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": "queen",
"CheckInDate": "2016-12-18",
"Nights": "5",
"Location": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
**nota**
`invocationSource`: dessa vez, o Amazon Lex define esse valor como `FulfillmentCodeHook`, direcionando a função do Lambda a atender à intenção.
`confirmationStatus`: é definido como `Confirmed`.
1. Dessa vez, a função Lambda cumpre a BookHotel intenção, o Amazon Lex conclui a reserva e, em seguida, retorna a seguinte resposta:
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Thanks, I have placed your reservation. Please let me know if you would like to book a car rental, or another hotel."
}
}
}
```
**nota**
`lastConfirmedReservation`: é um novo atributo de sessão que a função do Lambda adicionou (em vez do `currentReservation`, `currentReservationPrice`).
`dialogAction.type`: a função do Lambda define esse valor como `Close`, indicando a Amazon Lex que não aguarde uma resposta do usuário.
`dialogAction.fulfillmentState`: é definido como `Fulfilled` e inclui uma `message` adequada para transmitir para o usuário.
1. Amazon Lex analisa o `fulfillmentState` e envia a resposta seguinte de volta para o cliente:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots. Todos os slots estão preenchidos, e um último campo de reserva confirmado nos atributos da sessão agora está preenchido.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-hotel-60.png)
**nota**
`dialogState`: o Amazon Lex define esse valor como `Fulfilled`.
`message`: é a mesma mensagem que a função do Lambda forneceu.
O cliente exibe a mensagem.
## Fluxo de dados: intenção Book Car
O BookTrip bot neste exercício apoia duas intenções (BookHotel e BookCar). Depois de reservar um hotel, o usuário pode continuar a conversa para reservar um carro. Desde que a sessão não tenha expirado, em cada solicitação subsequente o cliente continua a enviar os atributos de sessão (neste exemplo, o `lastConfirmedReservation`). A função Lambda pode usar essas informações para inicializar os dados do slot para a intenção. BookCar Isso mostra como é possível usar atributos de sessão no compartilhamento de informações entre intenções.
Especificamente, quando o usuário escolhe a BookCar intenção, a função Lambda usa informações relevantes no atributo de sessão para preencher previamente os slots (PickUpDate, ReturnDate, e) para a intenção. PickUpCity BookCar
**nota**
O console do Amazon Lex fornece o link **Limpar** que você pode usar para limpar os atributos da sessão anterior.
Siga as etapas neste procedimento para continuar a conversa.
1. Usuário: "também reservar um carro"
1. O cliente envia a seguinte solicitação `PostText` para o Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"also book a car",
"sessionAttributes":{
"lastConfirmedReservation":""{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
O cliente inclui o atributo de sessão `lastConfirmedReservation`.
1. O Amazon Lex detecta a intenção (BookCar) do. `inputText` Essa intenção também está configurada para invocar a função do Lambda para executar a inicialização e a validação dos dados do usuário. Amazon Lex invoca a função do Lambda com os seguintes eventos:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": null,
"ReturnDate": null,
"DriverAge": null,
"CarType": null,
"PickUpCity": null
},
"confirmationStatus": "None"
}
}
```
**nota**
`messageVersion`: atualmente, Amazon Lex oferece suporte apenas à versão 1.0.
`invocationSource`: indica que a finalidade de invocação é executar a inicialização e a validação dos dados do usuário.
`currentIntent`: inclui o nome da intenção e os slots. No momento, todos os valores de slot são nulos.
1. A função do Lambda observa todos os valores de slot nulos com nada para validar. No entanto, ela usa atributos de sessão para inicializar alguns dos valores de slot (`PickUpDate`, `ReturnDate` e `PickUpCity`) e, em seguida, retorna a seguinte resposta:
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"confirmationContext": "AutoPopulate"
},
"dialogAction": {
"type": "ConfirmIntent",
"intentName": "BookCar",
"slots": {
"PickUpCity": "Chicago",
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"CarType": null,
"DriverAge": null
},
"message": {
"contentType": "PlainText",
"content": "Is this car rental for your 5 night stay in Chicago on 2016-12-18?"
}
}
}
```
**nota**
Além do `lastConfirmedReservation`, a função do Lambda inclui mais atributos de sessão (`currentReservation` e `confirmationContext`).
`dialogAction.type`é definido como`ConfirmIntent`, o que informa ao Amazon Lex que uma resposta sim, não é esperada do usuário (o ConfirmationContext definido como, a função Lambda sabe yes/no que AutoPopulate a resposta do usuário é para obter a confirmação do usuário da inicialização realizada pela função Lambda (dados de slot preenchidos automaticamente).
A função do Lambda também inclui uma mensagem informativa na resposta no `dialogAction.message` para Amazon Lex retornar ao cliente.
O termo `ConfirmIntent` (valor do `dialogAction.type`) não é relacionado a nenhuma intenção de bot. No exemplo, a função Lambda usa esse termo para direcionar o Amazon Lex a receber uma yes/no resposta do usuário.
1. De acordo com o `dialogAction.type`, Amazon Lex retorna a seguinte resposta ao cliente:
![\[Resposta JSON contendo estado da caixa de diálogo, nome da intenção, mensagem, cartão de resposta, atributos da sessão, slot de evocação e slots.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-car-10.png)
O cliente exibe a mensagem: "Este aluguel de carro é para sua estadia de 5 diárias em Chicago em 18/12/2016?"
1. Usuário: "sim"
1. O cliente envia a seguinte solicitação `PostText` para o Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"yes",
"sessionAttributes":{
"confirmationContext":"AutoPopulate",
"currentReservation":"{\"ReservationType\":\"Car\",
\"PickUpCity\":null,
\"PickUpDate\":null,
\"ReturnDate\":null,
\"CarType\":null}",
"lastConfirmedReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
1. O Amazon Lex lê o `inputText` e sabe o contexto (solicitou que o usuário confirme o preenchimento automático). O Amazon Lex invoca a função do Lambda enviando o seguinte evento:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"confirmationContext": "AutoPopulate",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
Como o usuário respondeu Sim, Amazon Lex define o `confirmationStatus` como `Confirmed`.
1. A partir do `confirmationStatus`, a função do Lambda sabe que os valores preenchidos automaticamente estão corretos. A função do Lambda faz o seguinte:
+ Atualiza o atributo de sessão `currentReservation` para o valor de slot que tinha preenchido automaticamente.
+ Define o `dialogAction.type` como `ElicitSlot`
+ Define o valor `slotToElicit` como `DriverAge`.
A resposta seguinte é enviada:
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":\"Chicago\",\"PickUpDate\":\"2016-12-18\",\"ReturnDate\":\"2016-12-22\",\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"slotToElicit": "DriverAge",
"message": {
"contentType": "PlainText",
"content": "How old is the driver of this car rental?"
}
}
}
```
1. Amazon Lex retorna a seguinte resposta:
![\[Resposta em JSON mostrando a intenção de reservar um carro e uma mensagem indicando o slot de Idade do motorista.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/book-car-20.png)
O cliente exibe a mensagem "Quantos anos tem o motorista deste aluguel de carro?" e a conversa continua.