Flujo de datos: intención de reservar un hotel Flujo de datos: intención de reservar un automóvil

Detalles del flujo de información

En este ejercicio ha iniciado una conversación con el bot BookTrip de Amazon Lex a través de la ventana de pruebas del cliente proporcionada en la consola de Amazon Lex. En esta sección se explica lo siguiente:

El flujo de datos entre el cliente y Amazon Lex.

En esta sección se supone que el cliente envía solicitudes a Amazon Lex mediante la API en tiempo de ejecución PostText y se muestran los detalles correspondientes de la solicitud y la respuesta. Para obtener más información acerca de la API en tiempo de ejecución PostText, consulte PostText.

nota
Para ver un ejemplo de flujo de información entre el cliente y Amazon Lex en el que el usuario usa la API PostContent, consulte Paso 2a (opcional): revisión de los detalles del flujo de información escrita (consola) .
El flujo de datos entre Amazon Lex y la función de Lambda. Para obtener más información, consulte Formato del evento de entrada y de la respuesta de la función de Lambda.

Temas

Flujo de datos: intención de reservar un hotel
Flujo de datos: intención de reservar un automóvil

Flujo de datos: intención de reservar un hotel

En esta sección se explica lo que ocurre después de cada entrada del usuario.

Usuario: "reservar un hotel"
1. El cliente (la consola) envía la siguiente solicitud PostText a 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 la URI de la solicitud como el cuerpo proporcionan información a Amazon Lex:
  - URI de la solicitud: proporciona el nombre del bot (BookTrip), el alias del bot ($LATEST) y el nombre de usuario. El text de cola indica que se trata de una solicitud de API PostText (no PostContent).
  - Cuerpo de la solicitud: incluye la entrada del usuario (inputText). No hay sessionAttributes. Inicialmente, se trata de un objeto vacío y la función de Lambda establece primero los atributos de sesión.
2. Amazon Lex deduce la intención (BookHotel) a partir de inputText. Esta intención está configurada con una función de Lambda como enlace de código para las tareas de inicialización y validación de los datos del usuario. Por ello, Amazon Lex invoca la función de Lambda pasando la siguiente información como parámetro de evento (consulte Formato del evento 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"
   }
}
```
  Además de la información que envía el cliente, Amazon Lex también incluye los siguientes datos adicionales:
  - messageVersion: actualmente Amazon Lex solo es compatible con la versión 1.0.
  - invocationSource: indica la finalidad de invocar la función de Lambda. En este caso, se trata de inicializar y validar los datos del usuario (en este punto Amazon Lex sabe que el usuario aún no ha proporcionado todos los datos de ranura para llevar a cabo la intención).
  - currentIntent: todos los valores de ranura se configuran como nulos.
3. En este momento, todos los valores de slot son nulos. La función de Lambda no tiene que validar nada y devuelve la siguiente respuesta a Amazon Lex. Para obtener más información sobre el formato de la respuesta, consulte Formato de respuesta.
```
{
   "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: la función de Lambda incluye este atributo de la sesión. Su valor es una copia de la información actual de slot y el tipo de reserva.
  
  Solo el cliente y la función de Lambda pueden actualizar estos atributos de la sesión. Amazon Lex simplemente pasa estos valores.
  
  dialogAction.type: al configurar este valor como Delegate, la función de Lambda delega la responsabilidad del siguiente procedimiento en Amazon Lex.
  
  Si la función de Lambda detecta algo en la validación de los datos del usuario, le indica a Amazon Lex qué debe hacer a continuación.
4. Según dialogAction.type, Amazon Lex decide el siguiente paso: obtener datos del usuario para la ranura Location. Selecciona uno de los mensajes de pregunta ("¿En qué ciudad va a pernoctar?") para este slot, según la configuración de la intención, y luego envía esta respuesta al usuario:
  
  Los atributos de la sesión se transfieren al cliente.
  
  El cliente lee la respuesta y, a continuación, muestra el mensaje: "¿En qué ciudad va a pernoctar?"

Usuario: "Moscú"

El cliente envía la siguiente solicitud PostText a Amazon Lex (se añaden saltos de línea para facilitar la lectura):


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

Además de inputText, el cliente incluye los mismos atributos de la sesión currentReservation que ha recibido.

En primer lugar, Amazon Lex interpreta inputText en el contexto de la intención actual (el servicio recuerda que ha solicitado al usuario información sobre la ranura Location). Actualiza el valor de la ranura para la intención actual e invoca la función de Lambda con el siguiente evento:


{
    "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 sigue siendo DialogCodeHook. En este paso, solo se validan los datos del usuario.
Amazon Lex simplemente transfiere el atributo de la sesión a la función de Lambda.
Para currentIntent.slots, Amazon Lex ha actualizado la ranura Location con Moscow.

La función de Lambda valida los datos del usuario y determina que Moscow es una ubicación no válida.

nota
En este ejercicio, la función de Lambda cuenta con una lista de ciudades muy simple y Moscow no aparece en ella. En una aplicación de producción, es posible que pueda utilizar una base de datos back-end para obtener esta información.

Restablece el valor de la ranura a nulo e indica a Amazon Lex que solicite al usuario otro valor enviando la siguiente respuesta:
```
{
    "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 se vuelve a fijar como nulo.
- dialogAction.type se establece en ElicitSlot, por lo que Amazon Lex vuelve a preguntar al usuario proporcionando lo siguiente:
  
  dialogAction.slotToElicit: slot para el que se obtienen datos del usuario.
  
  dialogAction.message: un message que se transmite al usuario.
Amazon Lex tiene en cuenta dialogAction.type y pasa la información al cliente con la siguiente respuesta:

El cliente simplemente muestra el mensaje: "En la actualidad, no se admite Moscú como destino válido. ¿Puede probar con otra ciudad?"

Usuario: "Chicago"

El cliente envía la siguiente solicitud PostText a 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}"
   }
}

Amazon Lex conoce el contexto, es decir, que estaba obteniendo datos para la ranura Location. En este contexto, sabe que el valor de inputText es para el slot Location. A continuación, invoca la función de Lambda mediante el envío del siguiente 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 ha actualizado currentIntent.slots al configurar la ranura Location con Chicago.

Al establecer el valor invocationSource como DialogCodeHook, la función de Lambda valida los datos del usuario. Reconoce Chicago como un valor de ranura válido, actualiza el atributo de sesión según corresponda y devuelve la siguiente respuesta a 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: la función de Lambda actualiza este atributo de la sesión al configurar Location con Chicago.
- dialogAction.type: se establece en Delegate. Los datos del usuario son válidos, por lo que la función de Lambda indica a Amazon Lex que decida el siguiente paso.
Amazon Lex elige el siguiente paso en función de dialogAction.type. Amazon Lex sabe que necesita más datos de ranura, de modo que elige la siguiente ranura vacía (CheckInDate) con la mayor prioridad, según la configuración de la intención. Selecciona uno de los mensajes de pregunta ("¿Qué día desea registrarse?") para este slot, según la configuración de la intención, y entonces envía esta respuesta al cliente:

El cliente muestra el mensaje: "¿Qué día desea registrarse?"

La interacción con el usuario continúa: el usuario proporciona los datos, la función de Lambda los valida y delega el siguiente paso en Amazon Lex. Al final, el usuario proporciona todos los datos de ranura, la función de Lambda valida todas las entradas del usuario y Amazon Lex reconoce que cuenta con todos los datos de ranura.

nota
En este ejercicio, después de que el usuario proporcione todos los datos de ranura, la función de Lambda calcula el precio de la reserva de hotel y lo devuelve como otro atributo de sesión (currentReservationPrice).

En este momento, la intención ya se puede cumplir, pero BookHotel se ha configurado con una pregunta para requerir la confirmación del usuario antes de que Amazon Lex la cumpla. Por este motivo, Amazon Lex envía el siguiente mensaje al cliente para solicitar su confirmación antes de reservar el hotel:

El cliente muestra el mensaje: "De acuerdo, tengo anotado que busca alojamiento para 5 noches en Chicago a partir del 18/12/2016. ¿Tramito la reserva?"

Usuario: "sí"

El cliente envía la siguiente solicitud PostText a 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"
   }
}

Amazon Lex interpreta inputText en el contexto de la confirmación de la intención actual. Amazon Lex entiende que el usuario quiere continuar con la reserva. Esta vez Amazon Lex llama a la función de Lambda para que cumpla con la intención mediante el envío del siguiente evento. Al configurar invocationSource como FulfillmentCodeHook en el evento, lo envía a la función de Lambda. Amazon Lex también establece confirmationStatus en 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: esta vez, Amazon Lex configura este valor como FulfillmentCodeHook, por lo que indica a la función de Lambda que cumpla con la intención.
confirmationStatus: se establece en Confirmed.

Esta vez, la función de Lambda lleva a cabo la intención BookHotel, Amazon Lex efectúa la reserva y, a continuación, devuelve la siguiente respuesta:
```
{
    "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: es un nuevo atributo de la sesión que ha añadido la función de Lambda (en lugar de currentReservation, currentReservationPrice).
- dialogAction.type: la función de Lambda establece este valor en Close, lo que indica que Amazon Lex no esperará ninguna respuesta del usuario.
- dialogAction.fulfillmentState: se establece en Fulfilled e incluye un message adecuado para transmitir al usuario.
Amazon Lex analiza fulfillmentState y envía la siguiente respuesta al cliente:
nota
- dialogState: Amazon Lex establece este valor en Fulfilled.
- message: es el mismo mensaje que ha proporcionado la función de Lambda.
El cliente muestra el mensaje.

Flujo de datos: intención de reservar un automóvil

En este ejercicio, el bot BookTrip admite dos intenciones (BookHotel y BookCar). Después de reservar un hotel, el usuario puede continuar la conversación para reservar un automóvil. Mientras la sesión no haya caducado, en cada solicitud subsiguiente el cliente sigue enviando los atributos de la sesión (en este ejemplo, la lastConfirmedReservation). La función de Lambda puede utilizar esta información para inicializar los datos de ranura de la intención BookCar. Aquí se muestra cómo puede utilizar los atributos de la sesión en el uso compartido de datos entre intenciones.

En concreto, cuando el usuario elige la intención BookCar, la función de Lambda utiliza la información pertinente del atributo de sesión para rellenar previamente las ranuras (PickUpDate, ReturnDate y PickUpCity) para la intención BookCar.

nota

La consola de Amazon Lex proporciona el enlace Borrar, que puede utilizar para borrar los atributos de sesión anteriores.

Siga los pasos descritos en este procedimiento para continuar con la conversación.

Usuario: "reservar también un automóvil"

El cliente envía la siguiente solicitud PostText a 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\"}"
   }
}

El cliente incluye el atributo de la sesión lastConfirmedReservation.

Amazon Lex deduce la intención (BookHotel) a partir de inputText. Esta intención también está configurada para invocar la función de Lambda, para que realice las tareas de inicialización y validación de los datos del usuario. Amazon Lex invoca la función de Lambda con los siguientes 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: actualmente Amazon Lex solo es compatible con la versión 1.0.
invocationSource: indica que el objetivo de la invocación es inicializar y validar los datos del usuario.
currentIntent: incluye el nombre de la intención y las ranuras. En este momento, todos los valores de slot son nulos.

La función de Lambda observa que todos los valores de ranura son nulos y no hay nada que validar. Sin embargo, utiliza los atributos de la sesión para inicializar algunos de los valores de slot (PickUpDate, ReturnDate y PickUpCity) y, a continuación, devuelve la siguiente respuesta:
```
{
    "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
- Además de lastConfirmedReservation, la función de Lambda incluye más atributos de la sesión (currentReservation y confirmationContext).
- dialogAction.type toma el valor ConfirmIntent, lo que indica a Amazon Lex que se espera una respuesta sí/no del usuario (si el valor de confirmationContext es AutoPopulate, la función de Lambda sabe que la respuesta sí/no del usuario sirve para obtener su confirmación de la inicialización que la función de Lambda ha realizado (de los datos de ranura rellenados automáticamente)).
  
  La función de Lambda también incluye en la respuesta un mensaje informativo en dialogAction.message para que Amazon Lex se lo envíe al cliente.
  
  nota
  El término ConfirmIntent (valor del dialogAction.type) no está relacionado con ninguna intención del bot. En el ejemplo, la función de Lambda utiliza este término para indicar a Amazon Lex que obtenga una respuesta sí/no del usuario.
Amazon Lex devuelve la siguiente respuesta al cliente en función de dialogAction.type:

El cliente muestra el mensaje: "¿El alquiler de este automóvil es para su estancia de 5 noches en Chicago a partir del 18/12/2016?"

Usuario: "sí"

El cliente envía la siguiente solicitud PostText a 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\"}"
   }
}

Amazon Lex lee inputText y conoce el contexto (pedirá al usuario que confirme los datos rellenados de forma automática). Amazon Lex invoca la función de Lambda al enviar el siguiente 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"
    }
}

Dado que el usuario ha respondido con un Sí, Amazon Lex establece confirmationStatus en Confirmed.

Por el valor de confirmationStatus, la función de Lambda sabe que los valores rellenados previamente son correctos. La función de Lambda hace lo siguiente:

Actualiza el atributo de la sesión currentReservation con el valor de slot rellenado previamente.
Establece el dialogAction.type en ElicitSlot
Establece el valor de slotToElicit en DriverAge.

Se envía la siguiente respuesta:


{
    "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?"
        }
    }
}

Amazon Lex devuelve la siguiente respuesta:

El cliente muestra el mensaje “¿Qué edad tiene el conductor del automóvil de alquiler?” y la conversación continúa.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Paso 4: adición de la función de Lambda como enlace de código

Ejemplo: uso de una tarjeta de respuesta