Detalhes do fluxo de informações - Amazon Lex V1
Fluxo de dados: intenção Book HotelFluxo de dados: intenção Book Car

Se você estiver usando o Amazon Lex V2, consulte o Guia do Amazon Lex V2.

 

Se você estiver usando o Amazon Lex V1, recomendamos atualizar seus bots para o Amazon Lex V2. Não estamos mais adicionando novos atributos à V1 e recomendamos o uso da V2 para todos os novos bots.

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ê participou de uma conversa com o bot BookTrip do Amazon Lex usando o cliente da janela de teste fornecido no console do Amazon Lex. Esta seção explica o seguinte:

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 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 ($LATEST) 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.

    2. No inputText, 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):

      {
   "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.

    3. 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. 

      {
   "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.

    4. 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 uma das mensagens de solicitação ("What city will you be staying in? (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.

      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á?"

  2. 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.

    2. 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 do 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.

    3. 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 do 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.

    4. 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.

      O cliente simplesmente exibe a mensagem: "No momento, não oferecemos suporte a Moscou como um destino válido. Poderia tentar outra cidade?"

  3. 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}"
   }
}

    2. 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.

    3. 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.

       

    4. 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 uma das mensagens de solicitação ("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.

      O cliente exibe a mensagem: "Em que dia você deseja fazer check-in?"

  4. 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 Lamda calcula o preço da reserva de hotel e o retorna como outro atributo de sessão (currentReservationPrice).

    Neste momento, a intenção está pronta para ser atendida, mas a intenção BookHotel está configurada com uma solicitação de confirmação que exige a confirmação do usuário para que o Amazon Lex possa atender à 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.

    O cliente exibe a mensagem: "OK, reservarei para você 5 diárias em Chicago a partir de 18/12/2016. Posso fazer a reserva?"

  5. 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"
   }
}

    2. 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.

    3. Dessa vez, a função do Lambda atende à intenção BookHotel, 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.

    4. 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.
      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 bot BookTrip neste exercício oferece suporte a 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 do 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 intenção BookCar, a função do Lambda usa as informações relevantes no atributo de sessão para preencher os slots automaticamente (PickUpDate, ReturnDate e PickUpCity) para a intenção 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.

    2. 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.

    3. 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, que informa ao Amazon Lex que uma resposta sim ou não é esperada do usuário (o confirmationContext definido como AutoPopulate, a função do Lambda sabe que a resposta sim/não do usuário é para obter a confirmação do usuário da inicialização que a função do Lambda executou (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.

        nota

        O termo ConfirmIntent (valor do dialogAction.type) não é relacionado a nenhuma intenção de bot. No exemplo, a função do Lambda usa esse termo para direcionar o Amazon Lex para obter uma resposta sim/não do usuário.

    4. 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.

      O cliente exibe a mensagem: "Este aluguel de carro é para sua estadia de 5 diárias em Chicago em 18/12/2016?"

  2. 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\"}"
   }
}

    2. 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.

    3. 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?"
        }
    }
}

    4. 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.

      O cliente exibe a mensagem "Quantos anos tem o motorista deste aluguel de carro?" e a conversa continua.