Informationsfluss im Detail

Benutzer: „Buche ein Hotel“

1. Der Client (Konsole) sendet die folgende PostText-Anforderung an Amazon Lex:

   POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
   "Content-Type":"application/json"
   "Content-Encoding":"amz-1.0"
   
   {
      "inputText":"book a hotel",
      "sessionAttributes":{}
   }

   Sowohl die Anforderungs-URI als auch der Text stellen Amazon Lex Informationen zur Verfügung:

   • Anfrage-URI — Stellt den Bot-Namen (BookTrip), den Bot-Alias ($LATEST) und den Benutzernamen bereit. Der abschließende text zeigt an, dass es sich um eine PostText-API-Anforderung handelt (und nicht um PostContent).

   • Anforderungsinhalt: Enthält die Benutzereingabe (inputText) und leere sessionAttributes. Anfänglich ist dies ein leeres Objekt und die Lambda-Funktion legt zuerst die Sitzungsattribute fest.

2. Anhand inputText von erkennt Amazon Lex die Absicht (BookHotel). Diese Absicht ist mit einer Lambda-Funktion als Code-Hook für die Initialisierung/Validierung von Benutzerdaten konfiguriert. Daher ruft Amazon Lex diese Lambda-Funktion auf, indem es die folgenden Informationen als Ereignisparameter übergibt (sieheEingabe-Ereignis-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"
      }
   }

   Zusätzlich zu den vom Kunden gesendeten Informationen enthält Amazon Lex auch die folgenden zusätzlichen Daten:

   • messageVersion— Derzeit unterstützt Amazon Lex nur die Version 1.0.

   • invocationSource— Zeigt den Zweck des Aufrufs der Lambda-Funktion an. In diesem Fall erfolgt die Initialisierung und Validierung der Benutzerdaten (zu diesem Zeitpunkt weiß Amazon Lex, dass der Benutzer nicht alle Slot-Daten zur Erfüllung der Absicht bereitgestellt hat).

   • currentIntent: Alle Slot-Werte werden auf Null gesetzt.

3. Zu diesem Zeitpunkt sind alle Slot-Werte auf Null gesetzt. Die Lambda-Funktion muss nichts validieren. Die Lambda-Funktion gibt die folgende Antwort an Amazon Lex zurück. Weitere Informationen über das Antwortformat finden Sie unter Reaktion-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
         }
      }
   }

   Anmerkung

   • currentReservation— Die Lambda-Funktion beinhaltet dieses Sitzungsattribut. Sein Wert ist eine Kopie der aktuellen Slot-Informationen und des Reservierungstyps.

     Nur die Lambda-Funktion und der Client können diese Sitzungsattribute aktualisieren. Amazon Lex gibt diese Werte einfach weiter.

   • dialogAction.type— Wenn Sie diesen Wert auf setzenDelegate, delegiert die Lambda-Funktion die Verantwortung für die nächste Vorgehensweise an Amazon Lex.

     Wenn die Lambda-Funktion bei der Überprüfung der Benutzerdaten etwas entdeckt hat, weist sie Amazon Lex an, was als Nächstes zu tun ist.

4. Gemäß dem dialogAction.type entscheidet Amazon Lex über die nächste Vorgehensweise — das Abrufen von Daten vom Benutzer für den Slot. Location Es wählt eine der Aufforderungsmitteilungen ("In welcher Stadt werden Sie bleiben?") gemäß der Konfiguration der Absicht für diesen Slot aus und sendet dann die folgende Antwort an den Benutzer:

   

   Die Sitzungsattribute werden an den Client übergeben.

   Der Client liest die Antwort und zeigt dann die Mitteilung an: „In welcher Stadt werden Sie bleiben?“

Benutzer: „Moskau“

1. Der Client sendet die folgende PostText Anfrage an Amazon Lex (Zeilenumbrüche wurden zur besseren Lesbarkeit hinzugefügt):

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

   Zusätzlich zu dem inputText fügt der Client die gleichen currentReservation-Sitzungsattribute hinzu, die er erhalten hat.

2. Amazon Lex interpretiert das zunächst inputText im Kontext der aktuellen Absicht (der Service erinnert sich, dass er den bestimmten Benutzer nach Informationen über den Location Slot gefragt hat). Es aktualisiert den Slot-Wert für die aktuelle Absicht und ruft die Lambda-Funktion mit dem folgenden Ereignis auf:

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

   Anmerkung

   • invocationSource ist weiterhin DialogCodeHook. In diesem Schritt validieren wir nur Benutzerdaten.

   • Amazon Lex übergibt lediglich das Sitzungsattribut an die Lambda-Funktion.

   • Denn currentIntent.slots Amazon Lex hat den Location Slot auf aktualisiertMoscow.

3. Die Lambda-Funktion führt die Überprüfung der Benutzerdaten durch und stellt fest, dass Moscow es sich um einen ungültigen Standort handelt.

   Anmerkung

   Die Lambda-Funktion in dieser Übung hat eine einfache Liste gültiger Städte und Moscow ist nicht in der Liste enthalten. In einer Produktionsanwendung würden Sie eventuell eine Backend-Datenbank verwenden, um diese Information zu erhalten.

   Es setzt den Slot-Wert wieder auf Null zurück und weist Amazon Lex an, den Benutzer erneut zur Eingabe eines anderen Werts aufzufordern, indem die folgende Antwort gesendet wird:

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

   Anmerkung

   • currentIntent.slots.Location wird auf Null zurückgesetzt.

   • dialogAction.typeist auf gesetztElicitSlot, was Amazon Lex anweist, den Benutzer erneut aufzufordern, indem es Folgendes angibt:

     • dialogAction.slotToElicit: Slot, für den Daten vom Benutzer erfragt werden

     • dialogAction.message: Eine an den Benutzer zu übermittelnde message

4. Amazon Lex bemerkt das dialogAction.type und leitet die Informationen in der folgenden Antwort an den Kunden weiter:

   

   Der Client zeigt die Mitteilung einfach an: „Wir unterstützen derzeit Moskau als gültiges Ziel nicht. Können Sie es mit einer anderen Stadt versuchen?“

Benutzer: „Chicago“

1. Der Client sendet die folgende PostText Anfrage an 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 kennt den Kontext, in dem Daten für den Location Slot abgerufen wurden. In diesem Kontext weiß es, dass der Wert inputText für den Slot Location ist. Anschließend ruft es die Lambda-Funktion auf, indem es das folgende Ereignis sendet:

   {
       "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 hat das aktualisiert, currentIntent.slots indem es den Location Slot auf gesetzt hatChicago.

3. Je nach invocationSource Wert von DialogCodeHook führt die Lambda-Funktion eine Benutzerdatenvalidierung durch. Es erkennt Chicago einen gültigen Slot-Wert, aktualisiert das Sitzungsattribut entsprechend und gibt dann die folgende Antwort an Amazon Lex zurück.

   {
       "sessionAttributes": {
           "currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
       },
       "dialogAction": {
           "type": "Delegate",
           "slots": {
               "RoomType": null,
               "CheckInDate": null,
               "Nights": null,
               "Location": "Chicago"
           }
       }
   }

   Anmerkung

   • currentReservation— Die Lambda-Funktion aktualisiert dieses Sitzungsattribut, indem sie den Wert Location auf Chicago setzt.

   • dialogAction.type: Wird auf Delegate gesetzt. Die Benutzerdaten waren gültig, und die Lambda-Funktion weist Amazon Lex an, die nächste Vorgehensweise zu wählen.

    

4. Demnach entscheidet dialogAction.type sich Amazon Lex für die nächste Vorgehensweise. Amazon Lex weiß, dass mehr Slot-Daten benötigt werden, und wählt den nächsten unbesetzten Slot (CheckInDate) mit der höchsten Priorität entsprechend der Intent-Konfiguration aus. Es wählt eine der Aufforderungsmitteilungen ("An welchem Tag möchten Sie einchecken?") gemäß der Konfiguration der Absicht für diesen Slot aus und sendet dann die folgende Antwort an den Kunden:

   

   Der Client zeigt die Nachricht an: „An welchem Tag möchten Sie anreisen?“

Die Benutzerinteraktion wird fortgesetzt — der Benutzer stellt Daten bereit, die Lambda-Funktion validiert Daten und delegiert dann die nächste Vorgehensweise an Amazon Lex. Schließlich stellt der Benutzer alle Slot-Daten bereit, die Lambda-Funktion validiert alle Benutzereingaben, und dann erkennt Amazon Lex, dass es über alle Slot-Daten verfügt.

Zu diesem Zeitpunkt ist die Absicht bereit, erfüllt zu werden, aber die BookHotel Absicht ist mit einer Bestätigungsaufforderung konfiguriert, die eine Bestätigung durch den Benutzer erfordert, bevor Amazon Lex die Absicht erfüllen kann. Daher sendet Amazon Lex die folgende Nachricht an den Kunden und bittet um Bestätigung, bevor er das Hotel bucht:

Der Client zeigt die Nachricht an: „Okay, ich habe einen Aufenthalt für 5 Nächte in Chicago ab 18.12.2016 notiert. Soll ich die Reservierung vornehmen?“

Benutzer: „Ja“

1. Der Client sendet die folgende PostText Anfrage an 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. Amazon Lex interpretiert das inputText im Zusammenhang mit der Bestätigung der aktuellen Absicht. Amazon Lex geht davon aus, dass der Benutzer mit der Reservierung fortfahren möchte. Diesmal ruft Amazon Lex die Lambda-Funktion auf, um die Absicht zu erfüllen, indem das folgende Ereignis gesendet wird. Wenn Sie das Ereignis invocationSource FulfillmentCodeHook auf setzen, wird es an die Lambda-Funktion gesendet. Amazon Lex legt auch das confirmationStatus auf festConfirmed.

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

   Anmerkung

   • invocationSource— Diesmal hat Amazon Lex diesen Wert auf gesetzt und die Lambda-Funktion angewiesenFulfillmentCodeHook, die Absicht zu erfüllen.

   • confirmationStatus: Wird auf Confirmed gesetzt.

3. Diesmal erfüllt die Lambda-Funktion die BookHotel Absicht, Amazon Lex schließt die Reservierung ab und gibt dann die folgende Antwort zurück:

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

   Anmerkung

   • lastConfirmedReservation— Ist ein neues Sitzungsattribut, das die Lambda-Funktion hinzugefügt hat (anstelle voncurrentReservation,currentReservationPrice).

   • dialogAction.type— Die Lambda-Funktion setzt diesen Wert aufClose, was bedeutet, dass Amazon Lex keine Benutzerantwort erwartet.

   • dialogAction.fulfillmentState: Ist auf Fulfilled eingestellt und enthält eine geeignete message zur Übermittlung an den Benutzer.

4. Amazon Lex überprüft das fulfillmentState und sendet die folgende Antwort an den Kunden:

   

   Anmerkung

   • dialogState— Amazon Lex legt diesen Wert auf festFulfilled.

   • message— Ist dieselbe Nachricht, die die Lambda-Funktion bereitgestellt hat.

   Der Client zeigt die Mitteilung an.

Benutzer: „Buche ebenfalls ein Auto“

1. Der Client sendet die folgende PostText Anfrage an 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\"}"
      }
   }

   Der Client schließt das Sitzungsattribut lastConfirmedReservation ein.

2. Amazon Lex erkennt die Absicht (BookCar) aus deminputText. Diese Absicht ist auch so konfiguriert, dass sie die Lambda-Funktion aufruft, um die Initialisierung und Validierung der Benutzerdaten durchzuführen. Amazon Lex ruft die Lambda-Funktion mit dem folgenden Ereignis auf:

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

   Anmerkung

   • messageVersion— Derzeit unterstützt Amazon Lex nur die Version 1.0.

   • invocationSource: Zeigt an, dass der Zweck des Aufrufs ist, Initialisierung und Validierung von Benutzerdaten durchzuführen.

   • currentIntent— Es enthält den Namen der Absicht und die Slots. Zu diesem Zeitpunkt sind alle Slot-Werte auf Null gesetzt.

3. Die Lambda-Funktion erkennt alle Null-Slot-Werte und es gibt nichts zu validieren. Sie verwendet jedoch Sitzungsattribute, um einige der Slot-Werte zu initialisieren (PickUpDate, ReturnDate und PickUpCity), und gibt dann die folgende Antwort zurück:

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

   Anmerkung

   • Darüber hinaus enthält die lastConfirmedReservation Lambda-Funktion weitere Sitzungsattribute (currentReservationundconfirmationContext).

   • dialogAction.typeist auf gesetztConfirmIntent, was Amazon Lex darüber informiert, dass eine Antwort mit Ja, Nein vom Benutzer erwartet wird (der confirmationContext ist auf gesetzt, die Lambda-Funktion weiß AutoPopulate, dass die Ja/Nein-Benutzerantwort darin besteht, vom Benutzer eine Bestätigung der Initialisierung zu erhalten, die die Lambda-Funktion durchgeführt hat (auto aufgefüllte Steckplatzdaten).

      

     Die Lambda-Funktion enthält in der Antwort auch eine informative Nachricht, die dialogAction.message Amazon Lex an den Client zurücksenden soll.

     Anmerkung

     Der Ausdruck ConfirmIntent (Wert des dialogAction.type) hat keinen Bezug zu einer Bot-Absicht. In diesem Beispiel verwendet die Lambda-Funktion diesen Begriff, um Amazon Lex anzuweisen, eine Ja/Nein-Antwort vom Benutzer zu erhalten.

4. Laut dem dialogAction.type gibt Amazon Lex die folgende Antwort an den Kunden zurück:

   

   Der Client zeigt die Mitteilung an: „Ist dieser Mietwagen für Ihren 5-Nächte-Aufenthalt in Chicago am 18.12.2016?“

Benutzer: „Ja“

1. Der Client sendet die folgende PostText Anfrage an 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. Amazon Lex liest das inputText und kennt den Kontext (hat den Benutzer gebeten, die auto Population zu bestätigen). Amazon Lex ruft die Lambda-Funktion auf, indem es das folgende Ereignis sendet:

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

   Da der Benutzer mit Ja geantwortet hat, setzt Amazon Lex den confirmationStatus Wert aufConfirmed.

3. Aus dem confirmationStatus weiß die Lambda-Funktion, dass die vorab ausgefüllten Werte korrekt sind. Die Lambda-Funktion bewirkt Folgendes:

   • Sie aktualisiert das Sitzungsattribut currentReservation auf den vorab ausgefüllten Slot-Wert.

   • Sie setzt den dialogAction.type auf ElicitSlot.

   • Sie setzt den Wert slotToElicit auf DriverAge.

   Die folgende Antwort wird gesendet:

   {
       "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 gibt folgende Antwort zurück:

   

   Der Kunde zeigt die Meldung „Wie alt ist der Fahrer dieser Autovermietung?“ und die Unterhaltung wird fortgesetzt.