本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 将AWS Lambda功能集成到您的 Amazon Lex V2 机器人中
借助 [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) 函数，您可以通过自己定义的自定义函数扩展并更好地控制 Amazon Lex V2 机器人的行为。Amazon Lex V2 为每种语言的每个机器人别名使用一个 Lambda 函数，而不是为每种意图使用一个 Lambda 函数。在开始之前，请确定要从[输入事件](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-input-format)中的哪些字段中提取信息，以及要操作[响应](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-response-format)中的哪些字段，然后从 Lambda 函数返回这些字段
要将 Lambda 函数与您的 Amazon Lex V2 机器人集成，请执行以下步骤：
1. AWS Lambda使用您选择的编程语言@@ [创建函数](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach)并编写脚本。
1. 确保该函数返回的结构与[响应格式](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-response-format)相匹配。
1. 部署 Lambda 函数。
1. 通过[控制台](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-console)或 [API 操作](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-api)，将 Lambda 函数与 Amazon Lex V2 机器人别名相关联。
1. 选择要通过[控制台](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-console)或 [API 操作](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-api)调用 Lambda 函数的对话阶段。
1. 构建您的 Amazon Lex V2 机器人并测试 Lambda 函数是否按预期运行。在 Amazon 的帮助下@@ [调试](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-debug)您的函数 CloudWatch。
**Topics**
+ [AWS LambdaLex V2 的输入事件格式](lambda-input-format.md)
+ [AWS LambdaLex V2 的响应格式](lambda-response-format.md)
+ [Amazon Lex V2 AWS Lambda 函数中的常见结构](lambda-common-structures.md)
+ [为你的 Amazon Lex V2 机器人创建AWS Lambda函数](lambda-attach.md)
+ [使用 CloudWatch 日志日志调试 Lambda 函数](lambda-debug.md)
# AWS LambdaLex V2 的输入事件格式
将 Lambda 函数集成到您的 Amazon Lex V2 机器人的第一步是了解 Amazon Lex V2 事件中的字段，并从这些字段中确定在编写脚本时需要使用的信息。以下 JSON 对象显示了传递给 Lambda 函数的 Amazon Lex V2 事件的一般格式：
**注意**
输入格式可以更改，但不必对 `messageVersion` 做出相应更改。您的代码不应在有新字段时引发错误。
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook | FulfillmentCodeHook",
"inputMode": "DTMF | Speech | Text",
"responseContentType": "audio/mpeg | audio/ogg | audio/pcm | text/plain; charset=utf-8",
"sessionId": string,
"inputTranscript": string,
"invocationLabel": string,
"bot": {
"id": string,
"name": string,
"localeId": string,
"version": string,
"aliasId": string,
"aliasName": string
},
"interpretations": [
{
"interpretationSource": "Bedrock | Lex",
"intent": {
// see 意图 for details about the structure
},
"nluConfidence": number,
"sentimentResponse": {
"sentiment": "MIXED | NEGATIVE | NEUTRAL | POSITIVE",
"sentimentScore": {
"mixed": number,
"negative": number,
"neutral": number,
"positive": number
}
}
},
...
],
"proposedNextState": {
"dialogAction": {
"slotToElicit": string,
"type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot"
},
"intent": {
// see 意图 for details about the structure
},
"prompt": {
"attempt": string
}
},
"requestAttributes": {
string: string,
...
},
"sessionState": {
// see 会话状态 for details about the structure
},
"transcriptions": [
{
"transcription": string,
"transcriptionConfidence": number,
"resolvedContext": {
"intent": string
},
"resolvedSlots": {
slot name: {
// see 槽值 for details about the structure
},
...
}
},
...
]
}
```
输入事件中的每个字段如下所述：
## messageVersion
消息的版本，用于标识进入 Lambda 函数的事件数据的格式以及来自 Lambda 函数的响应的预期格式。
**注意**
您在定义意图时可以配置此值。在当前实现中，Amazon Lex V2 仅支持消息版本 1.0。因此，控制台假定 1.0 的默认值，并且不显示消息版本。
## invocationSource
调用 Lambda 函数的代码挂钩。以下是可能的值：
`DialogCodeHook`：Amazon Lex V2 在用户输入内容后调用了 Lambda 函数。
`FulfillmentCodeHook`：Amazon Lex V2 在填充了所有必需的槽位后调用了 Lambda 函数并且意图已准备好履行。
## inputMode
用户言语模式。可能的值如下所示：
`DTMF`：用户通过按键键盘（双音多频）输入言语。
`Speech`：用户说出了言语。
`Text`：用户键入了言语。
## responseContentType
机器人对用户的响应模式。`text/plain; charset=utf-8` 表示写入了最后一个言语，而以 `audio` 开头的值表示说出了最后一个言语。
## sessionId
用于对话的字母数字会话标识符。
## inputTranscript
用户输入的转录。
+ 对于文本输入，表示用户键入的文本。对于 DTMF 输入，表示用户输入的密钥。
+ 对于语音输入，这是 Amazon Lex V2 将用户言语转换成的文本，以便调用意图或填补槽位。
## invocationLabel
该取值表示调用 Lambda 函数的响应。您可以为初始响应、槽位和确认响应设置调用标签。
## 自动程序
有关处理请求的机器人的信息，包括以下字段：
+ **id**：创建机器人时分配给机器人的标识符。您可以在 Amazon Lex V2 控制台的机器人**设置**页面上看到该机器人 ID。
+ **name**：创建机器人时赋予机器人的名称。
+ **localeId**：用于机器人的区域设置的标识符。有关区域设置列表，请参阅 [Amazon Lex V2 支持的语言和区域设置](how-languages.md)。
+ **version**：用于处理请求的机器人的版本。
+ **aliasId**：创建机器人别名时，为其分配的标识符。您可以在 Amazon Lex V2 控制台的**别名**页面上看到该机器人别名 ID。如果列表中未显示别名 ID，请选择右上角的齿轮图标并打开**别名 ID**。
+ **aliasName**：为机器人提供的别名。
## interpretations
Amazon Lex V2 认为可能与用户言语相匹配的意图相关信息的列表。每一项都是一个结构，提供有关言语与意图的匹配的信息，格式如下：
```
{
"intent": {
// see 意图 for details about the structure
},
"interpretationSource": "Bedrock | Lex",
"nluConfidence": number,
"sentimentResponse": {
"sentiment": "MIXED | NEGATIVE | NEUTRAL | POSITIVE",
"sentimentScore": {
"mixed": number,
"negative": number,
"neutral": number,
"positive": number
}
}
}
```
结构中的字段如下：
+ **intent**：包含意图相关信息的结构。有关结构的详细信息，请参阅[意图](lambda-common-structures.md#lambda-intent)。
+ **nluConfidence**：该分数表明 Amazon Lex V2 对意图与用户意图相匹配的信心程度。
+ **sentimentResponse**：对响应情绪的分析，包含以下字段：
+ **sentiment**：表示言语的情绪，取值为 `POSITIVE`、`NEGATIVE`、`NEUTRAL` 或 `MIXED`。
+ **sentimentScore**：将每种情绪映射到一个数字的结构，该数字表明 Amazon Lex V2 对言语传达这种情绪的信心程度。
+ **InterpretationSourc** e — 表示插槽是由 Amazon Lex V2 还是由 Amazon Bedrock 解析的。
## proposedNextState
如果 Lambda 函数将 `sessionState` 的 `dialogAction` 设置为 `Delegate`，则会出现此字段，并显示 Amazon Lex V2 对下一步对话的建议。否则，下一个状态取决于您在 Lambda 函数响应中返回的设置。只有满足以下两个语句时，此结构才存在：
1. `invocationSource` 的值为 `DialogCodeHook`。
1. `dialogAction` 的预测 `type` 是 `ElicitSlot`。
您可以通过此信息在对话的正确位置添加 `runtimeHints`。有关更多信息，请参阅 [在对话中使用运行时提示改善对槽位值的识别](using-hints.md)。`proposedNextState` 是包含以下字段的结构：
`proposedNextState` 的结构如下所示：
```
"proposedNextState": {
"dialogAction": {
"slotToElicit": string,
"type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot"
},
"intent": {
// see 意图 for details about the structure
},
"prompt": {
"attempt": string
}
}
```
+ **dialogAction**：包含有关 Amazon Lex V2 提出的下一步行动的信息。结构中的字段如下：
+ **slotToElicit**— 按照 Amazon Lex V2 的提议，接下来要引出的时段。仅当 `type` 的值为 `ElicitSlot` 时才显示此字段。
+ **type**：Amazon Lex V2 提出的下一步对话。以下是可能的值：
`Delegate`：Amazon Lex V2 决定下一步操作。
`ElicitIntent`：下一步操作是引发用户的意图。
`ElicitSlot`：下一步操作是从用户引发槽位值。
`Close`：结束意图履行流程并表示用户不会做出回应。
`ConfirmIntent`：下一步操作是询问用户槽位是否正确以及意图是否已准备履行。
+ **intent**：机器人已确定用户正在尝试履行的意图。有关结构的详细信息，请参阅[意图](lambda-common-structures.md#lambda-intent)。
+ **prompt**：包含字段 `attempt` 的结构，该字段映射到一个值，该值指定 Amazon Lex V2 提示用户进入下一槽位的次数。可能的值为第一次尝试的 `Initial`，以及后续尝试的 `Retry1`、`Retry2`、`Retry3`、`Retry4` 和 `Retry5`。
## requestAttributes
一种结构，其中包含客户端在请求中发送的请求特定的属性。可以使用请求属性传递不需要在整个会话中保留的信息。如果没有请求属性，该值将为空。有关更多信息，请参阅 [设置 Lex V2 机器人的请求属性](context-mgmt-request-attribs.md)。
## sessionState
用户与您的 Amazon Lex V2 机器人之间对话的当前状态。有关结构的详细信息，请参阅[会话状态](lambda-common-structures.md#lambda-session-state)。
## transcriptions
Amazon Lex V2 认为可能与用户言语匹配的转录的列表。有关更多信息，请参阅 [使用语音转录置信度分数来改善与 Lex V2 机器人的对话](using-transcript-confidence-scores.md)。每一项都是一个对象，具有以下格式，包含有关一个可能转录的信息：
```
{
"transcription": string,
"transcriptionConfidence": number,
"resolvedContext": {
"intent": string
},
"resolvedSlots": {
slot name: {
// see 槽值 for details about the structure
},
...
}
}
```
这些字段如下所述：
+ **transcription**：Amazon Lex V2 认为可能与用户的音频话言语匹配的转录。
+ **transcriptionConfidence**：该分数表明 Amazon Lex V2 对意图与用户意图相匹配的信心程度。
+ **resolvedContext**：一种包含字段 `intent` 的结构，该字段映射到言语相关意图。
+ **resolvedSlots**：一种结构，其键是通过言语解析的每个槽位的名称。每个槽位名称都映射到一个包含该槽位相关信息的结构。有关结构的详细信息，请参阅[槽值](lambda-common-structures.md#lambda-slot)。
# AWS LambdaLex V2 的响应格式
将 Lambda 函数集成到您的 Amazon Lex V2 机器人中的第二步是了解 Lambda 函数响应中的字段，并确定您要操作哪些参数。以下 JSON 对象显示了返回到 Amazon Lex V2 的 Lambda 响应的一般格式：
```
{
"sessionState": {
// see 会话状态 for details about the structure
},
"messages": [
{
"contentType": "CustomPayload | ImageResponseCard | PlainText | SSML",
"content": string,
"imageResponseCard": {
"title": string,
"subtitle": string,
"imageUrl": string,
"buttons": [
{
"text": string,
"value": string
},
...
]
}
},
...
],
"requestAttributes": {
string: string,
...
}
}
```
响应中的每个字段如下所述：
## sessionState
您想要返回的用户与您的 Amazon Lex V2 机器人之间的对话状态。有关结构的详细信息，请参阅[会话状态](lambda-common-structures.md#lambda-session-state)。此字段为必填。
## messages
Amazon Lex V2 在下一轮对话中返回给客户的消息的列表。如果您提供的 `contentType` 取值是 `PlainText`、`CustomPayload` 或 `SSML`，请在 `content` 字段中写下您要返回给客户的消息。如果您提供的 `contentType` 取值是 `ImageResponseCard`，请在 `imageResponseCard` 字段中提供卡的详细信息。如果您不提供消息，Amazon Lex V2 将使用创建机器人时定义的相应消息。
如果 `dialogAction.type` 的取值是 `ElicitIntent` 或 `ConfirmIntent`，则 `messages` 字段为必填字段。
列表中的每一项都是以下格式的结构，其中包含要返回给用户的消息的相关信息。示例如下：
```
{
"contentType": "CustomPayload | ImageResponseCard | PlainText | SSML",
"content": string,
"imageResponseCard": {
"title": string,
"subtitle": string,
"imageUrl": string,
"buttons": [
{
"text": string,
"value": string
},
...
]
}
}
```
每个字段的描述如下：
+ **contentType**：要使用的消息类型。
`CustomPayload`：一个响应字符串，您可以自定义该字符串以包含应用程序的数据或元数据。
`ImageResponseCard`：带有按钮的图像，客户可以选择。请参阅[ImageResponseCard](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_runtime_ImageResponseCard.html)了解更多信息。
`PlainText`：纯文本字符串。
`SSML`：包含语音合成标记语言的字符串，用于自定义音频响应。
+ **content**：要发送给用户的消息。如果消息类型为 `PlainText`、`CustomPayload` 或 `SSML`，则使用此字段。
+ **imageResponseCard**— 包含要向用户显示的响应卡的定义。如果消息类型为 `ImageResponseCard`，则使用此字段。映射到一个包含以下字段的结构：
+ **title**：响应卡的标题。
+ **subtitle**：提示用户选择按钮。
+ **imageUrl**：指向卡的图像的链接。
+ **buttons**：包含按钮相关信息的结构的列表。如果客户选择该按钮，每个结构都包含一个包含要显示文本的 `text` 字段，以及一个包含要发送到 Amazon Lex V2 的值的 `value` 字段。最多可以包含三个按钮。
## requestAttributes
一种结构，其中包含针对客户的响应的请求特定的属性。请参阅[设置 Lex V2 机器人的请求属性](context-mgmt-request-attribs.md)了解更多信息。该字段是可选的。
## 响应中的必填字段
Lambda 响应必须包含至少一个 `sessionState` 对象。该响应提供一个 `dialogAction` 对象并指定 `type` 字段。根据您提供的 `dialogAction` 的 `type`，Lambda 响应可能还包含其他必填字段。这些要求如下所述，并附带最少的工作示例：
### Delegate
**Delegate** 让 Amazon Lex V2 决定下一步操作。没有其他必填字段。
```
{
"sessionState": {
"dialogAction": {
"type": "Delegate"
}
}
```
### ElicitIntent
**ElicitIntent**提示客户表达意图。`messages` 字段中必须包含至少一条消息才能提示引发意图。
```
{
"sessionState": {
"dialogAction": {
"type": "ElicitIntent"
},
"messages": [
{
"contentType": PlainText,
"content": "How can I help you?"
}
]
}
```
### ElicitSlot
**ElicitSlot**提示客户提供槽位值。`dialogAction` 对象的 `slotToElicit` 字段中必须包含槽位的名称。还必须包含 `sessionState` 对象中 `intent` 的 `name`。
```
{`
"sessionState": {
"dialogAction": {
"slotToElicit": "OriginCity",
"type": "ElicitSlot"
},
"intent": {
"name": "BookFlight"
}
}
}
```
### ConfirmIntent
**ConfirmIntent**确认客户的槽位值以及意图是否已准备就绪。必须包含 `sessionState` 对象中 `intent` 的 `name`，以及待确认的 `slots`。`messages` 字段中还必须包含至少一条消息，要求用户确认槽位值。您的消息应提示响应“是”或“否”。如果用户响应“是”，则 Amazon Lex V2 会将意图的 `confirmationState` 设置为 `Confirmed`。如果用户响应“否”，则 Amazon Lex V2 会将意图的 `confirmationState` 设置为 `Denied`。
```
{
"sessionState": {
"dialogAction": {
"type": "ConfirmIntent"
},
"intent": {
"name": "BookFlight",
"slots": {
"DepartureDate": {
"value": {
"originalValue": "tomorrow",
"interpretedValue": "2023-05-09",
"resolvedValues": [
"2023-05-09"
]
}
},
"DestinationCity": {
"value": {
"originalValue": "sf",
"interpretedValue": "sf",
"resolvedValues": [
"sf"
]
}
},
"OriginCity": {
"value": {
"originalValue": "nyc",
"interpretedValue": "nyc",
"resolvedValues": [
"nyc"
]
}
}
}
}
},
"messages": [
{
"contentType": PlainText,
"content": "Okay, you want to fly from {OriginCity} to \
{DestinationCity} on {DepartureDate}. Is that correct?"
}
]
}
```
### Close
**Close** 结束意图的履行过程，并表示预计用户不会给出进一步的响应。您必须在 `sessionState` 对象中包含 `intent` 的 `name` 和 `state`。兼容的意图状态包括 `Failed`、`Fulfilled` 和 `InProgress`。
```
"sessionState": {
"dialogAction": {
"type": "Close"
},
"intent": {
"name": "BookFlight",
"state": "Failed | Fulfilled | InProgress"
}
}
```
# Amazon Lex V2 AWS Lambda 函数中的常见结构
在 Lambda 响应中，有许多结构会反复出现。本节提供了有关这些常见结构的详细信息。
## 意图
```
"intent": {
"confirmationState": "Confirmed | Denied | None",
"name": string,
"slots": {
// see 槽值 for details about the structure
},
"state": "Failed | Fulfilled | FulfillmentInProgress | InProgress | ReadyForFulfillment | Waiting",
"kendraResponse": {
// Only present when intent is KendraSearchIntent. For details, see
// https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html#API_Query_ResponseSyntax }
}
```
`intent` 字段映射到包含以下字段的对象：
### confirmationState
表示用户是否已确认意图的槽位，以及此意图是否已准备履行。以下是可能的值：
`Confirmed`：用户确认槽位值正确。
`Denied`：用户表示槽位值不正确。
`None`：用户尚未进入确认阶段。
### name
意图的名称。
### slots
有关履行意图所需的槽位的信息。有关结构的详细信息，请参阅[槽值](#lambda-slot)。
### 状态
表示意图的履行状态。以下是可能的值：
`Failed`：机器人未能履行意图。
`Fulfilled`：机器人已完成意图的履行。
`FulfillmentInProgress`：机器人正在履行意图。
`InProgress`：机器人正在引发履行意图所需的槽位值。
`ReadyForFulfillment`：机器人已引发意图的所有槽位值，并已准备好履行意图。
`Waiting`：机器人正在等待用户响应（仅限流式对话）。
### kendraResponse
包含有关 Kendra 搜索查询结果的信息。仅当意图为 `KendraSearchIntent` 时才显示此字段。有关更多信息，请参阅 [Kendra 的查询 API 调用中的响应语法](https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html#API_Query_ResponseSyntax)。
## 槽值
`slots` 字段存在于 `intent` 结构中，并映射到一个结构，该结构的键是用于此意图的槽位的名称。如果该槽位不是多值槽位（有关更多详细信息，请参阅 [使用一个槽位中的多个值](multi-valued-slots.md)），则会将其映射到具有以下格式的结构。请注意，`shape` 取值为 `Scalar`。
```
{
slot name: {
"shape": "Scalar",
"value": {
"originalValue": string,
"interpretedValue": string,
"resolvedValues": [
string,
...
]
}
}
}
```
如果该槽位是多值槽位，则其映射到的对象中包含另一个名为 `values` 的字段，该字段映射到一个结构列表，其中每个结构都包含有关构成多值槽位的槽位信息。列表中每个对象的格式与常规槽位所映射到的对象的格式相匹配。请注意，`shape` 的取值为 `List`，但 `values` 下面组件槽位的 `shape` 的取值为 `Scalar`。
```
{
slot name: {
"shape": "List",
"value": {
"originalValue": string,
"interpretedValue": string,
"resolvedValues": [
string,
...
]
},
"values": [
{
"shape": "Scalar",
"value": {
"originalValue": string,
"interpretedValue": string,
"resolvedValues": [
string,
...
]
}
},
{
"shape": "Scalar",
"value": {
"originalValue": string,
"interpretedValue": string,
"resolvedValues": [
string,
...
]
}
},
...
]
}
```
槽位对象中的字段如下所述：
### shape
槽位的形状。如果槽位中有多个值（有关更多详细信息，请参阅 [使用一个槽位中的多个值](multi-valued-slots.md)），则该值为 `List`，否则该值为 `Scalar`。
### 值
一个对象，其中包含有关用户为插槽提供的值以及 Amazon Lex V2 的解释的信息，格式如下：
```
{
"originalValue": string,
"interpretedValue": string,
"resolvedValues": [
string,
...
]
}
```
这些字段如下所述：
+ **OriginalValue** — Amazon Lex V2 确定用户对插槽引发的响应中与槽位值相关的部分。
+ **Interpreted** Value — Amazon Lex V2 根据用户输入为该时段确定的值。
+ r@@ **esolved** Values — Amazon Lex V2 确定为用户输入的可能分辨率的值列表。
### 值
包含有关构成多值槽位的槽位信息的对象的列表。每个对象的格式与普通槽位的格式相匹配，`shape` 和 `value` 字段如上所述。仅当槽位由多个值组成时，`values` 才会出现（有关更多详细信息，请参阅 [使用一个槽位中的多个值](multi-valued-slots.md)）。以下 JSON 对象显示了两个组件槽位：
```
"values": [
{
"shape": "Scalar",
"value": {
"originalValue": string,
"interpretedValue": string,
"resolvedValues": [
string,
...
]
}
},
{
"shape": "Scalar",
"value": {
"originalValue": string,
"interpretedValue": string,
"resolvedValues": [
string,
...
]
}
},
...
]
```
## 会话状态
`sessionState` 字段映射到一个对象，该对象包含与用户对话的状态相关的信息。该对象中实际显示的字段取决于对话操作的类型。有关 Lambda 响应中的必填字段，请参阅 [响应中的必填字段](lambda-response-format.md#lambda-response-required)。`sessionState` 对象的格式如下所示：
```
"sessionState": {
"activeContexts": [
{
"name": string,
"contextAttributes": {
string: string
},
"timeToLive": {
"timeToLiveInSeconds": number,
"turnsToLive": number
}
},
...
],
"sessionAttributes": {
string: string,
...
},
"runtimeHints": {
"slotHints": {
intent name: {
slot name: {
"runtimeHintValues": [
{
"phrase": string
},
...
]
},
...
},
...
}
},
"dialogAction": {
"slotElicitationStyle": "Default | SpellByLetter | SpellByWord",
"slotToElicit": string,
"type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot"
},
"intent": {
// see 意图 for details about the structure
},
"originatingRequestId": string
}
```
这些字段如下所述：
### activeContexts
包含用户在会话中使用的上下文相关信息的对象的列表。通过上下文来促进和控制意图识别。有关上下文的更多信息，请参阅 [设置 Lex V2 机器人的意图上下文](context-mgmt-active-context.md)。每个对象的格式如下：
```
{
"name": string,
"contextAttributes": {
string: string
},
"timeToLive": {
"timeToLiveInSeconds": number,
"turnsToLive": number
}
}
```
这些字段如下所述：
+ **name**：上下文的名称。
+ **contextAttributes**：一个对象，其中包含上下文属性名称及其映射到的值。
+ **timeToLive**— 一个对象，用于指定上下文保持活动状态多长时间。此对象可以包含以下一个或两个字段：
+ **timeToLiveInSeconds**— 上下文保持活动状态的秒数。
+ **turnsToLive**— 上下文保持活动状态的回合数。
### sessionAttributes
表示会话特定上下文信息的 key/value 对映射。有关更多信息，请参阅 [设置 Lex V2 机器人的会话属性](context-mgmt-session-attribs.md)。对象的格式如下：
```
{
string: string,
...
}
```
### runtimeHints
为客户可能在槽位中使用的短语提供提示，以提高音频识别能力。与发音相似的单词相比，您在提示中提供的值可以增强对这些值的音频识别。`runtimeHints` 对象的格式如下所示：
```
{
"slotHints": {
intent name: {
slot name: {
"runtimeHintValues": [
{
"phrase": string
},
...
]
},
...
},
...
}
}
```
`slotHints` 字段映射到一个对象，该对象中的字段是机器人中意图的名称。每个意图名称都映射到一个对象，该对象的字段是对应意图的槽位名称。每个槽位名称都映射到一个带有单个字段 `runtimeHintValues` 的结构，即对象列表。每个对象都包含一个映射到提示的 `phrase` 字段。
### dialogAction
确定 Amazon Lex V2 要采取的下一步操作。对象的格式如下所示：
```
{
"slotElicitationStyle": "Default | SpellByLetter | SpellByWord",
"slotToElicit": string,
"type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot"
}
```
这些字段如下所述：
+ **slotElicitationStyle**— 确定 Amazon Lex V2 如何解释来自用户的音频输入（如果是）`type`。`dialogAction` `ElicitSlot`有关更多信息，请参阅 [在对话期间使用拼写样式捕获槽位值](spelling-styles.md)。以下是可能的值：
`Default`：Amazon Lex V2 以默认方式解释音频输入以履行槽位。
`SpellByLetter`：Amazon Lex V2 监听用户对槽位值的拼写。
`SpellByWord`：Amazon Lex V2 根据与每个字母相关的单词（例如，“a as in apple”）来监听用户对槽位值的拼写。
+ **slotToElicit**— 如果是 of，则定义要从用户那里获得`type`的`dialogAction`插槽。`ElicitSlot`
+ **type**：定义机器人应执行的操作。以下是可能的值：
`Delegate`：让 Amazon Lex V2 决定下一步操作。
`ElicitIntent`：提示客户表达意图。
`ConfirmIntent`：确认客户的槽位值以及意图是否准备履行。
`ElicitSlot`：提示客户为意图提供槽位值。
`Close`：结束意图履行流程。
### 意图
有关 `intent` 字段的结构，请参阅 [意图](#lambda-intent)。
### originatingRequestId
请求的唯一标识符。该字段对于 Lambda 响应是可选字段。
# 为你的 Amazon Lex V2 机器人创建AWS Lambda函数
要为您的 Amazon Lex V2 机器人创建 Lambda 函数，AWS Lambda请从 AWS 管理控制台访问并创建一个新函数。您可以参阅[AWS Lambda开发者指南](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)，了解有关的更多详细信息AWS Lambda。
1. 登录 AWS 管理控制台并在上打开AWS Lambda控制台[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)。
1. 在左侧边栏中选择**函数**。
1. 选择**创建函数**。
1. 您可以选择**从头开始创作**以最少的代码开始，选择**使用蓝图**以从列表中选择常见用例的示例代码，或者选择**容器镜像**为您的函数选择要部署的容器镜像。如果您选择**从头开始创作**，请继续执行以下步骤：
1. 给您的函数起一个有意义的**函数名称**来描述它的作用。
1. 从**运行时**下拉菜单中选择一种语言来编写函数。
1. 为您的函数选择一个指令集**架构**。
1. 默认情况下，Lambda 创建具有基本权限的新角色。要使用现有角色或使用 AWS 策略模板创建角色，请展开**更改默认执行角色**菜单并选择一个选项。
1. 展开**高级设置**菜单以配置更多选项。
1. 选择**创建函数**。
从头开始创建新函数时所看到的内容如下图所示。
![\[新的 Lambda 函数。\]](http://docs.aws.amazon.com/zh_cn/lexv2/latest/dg/images/lambda/lambda-new-function.png)
Lambda 处理程序函数因您使用的语言而异。它至少需要一个 `event` JSON 对象作为参数。您可以进入 [AWS LambdaLex V2 的输入事件格式](lambda-input-format.md) 查看 Amazon Lex V2 提供的 `event` 中包含的字段。修改处理程序函数，最终返回与 [AWS LambdaLex V2 的响应格式](lambda-response-format.md) 中所述格式相匹配的 `response` JSON 对象。
+ 编写完函数后，选择**部署**以允许使用该函数。
请记住，您最多可以将每个机器人别名与一个 Lambda 函数相关联。但是，您可以在 Lambda 代码中为机器人定义任意数量的函数，然后在 Lambda 处理程序函数中调用这些函数。例如，虽然同一个机器人别名中的所有意图都必须调用相同的 Lambda 函数，但您可以创建一个路由器函数来为每个意图激活单独的函数。可以为应用程序使用或修改的路由器函数示例如下所示：
```
import os
import json
import boto3
# reuse client connection as global
client = boto3.client('lambda')
def router(event):
intent_name = event['sessionState']['intent']['name']
fn_name = os.environ.get(intent_name)
print(f"Intent: {intent_name} -> Lambda: {fn_name}")
if (fn_name):
# invoke lambda and return result
invoke_response = client.invoke(FunctionName=fn_name, Payload = json.dumps(event))
print(invoke_response)
payload = json.load(invoke_response['Payload'])
return payload
raise Exception('No environment variable for intent: ' + intent_name)
def lambda_handler(event, context):
print(event)
response = router(event)
return response
```
**何时在 Amazon Lex V2 机器人对话中使用AWS Lambda功能**
在与用户的对话中，您可以在以下时间使用 Lambda 函数：
+ 在识别意图后的初始响应中，例如，在用户说要订购披萨之后。
+ 从用户引发槽位值后，例如，在用户告诉机器人他们要订购的披萨大小之后。
+ 在每次重试之间引发一个槽位时，例如，客户没有使用公认的披萨尺寸时。
+ 确认意图时，例如，在确认披萨订单时。
+ 要履行意图时，例如，要订购披萨时。
+ 在履行意图之后以及机器人结束对话之前。例如，切换到点饮料的意图时。
**Topics**
+ [使用控制台将AWS Lambda函数附加到 Amazon Lex V2 机器人](lambda-attach-console.md)
+ [使用 API 操作将AWS Lambda函数附加到 Amazon Lex V2 机器人](lambda-attach-api.md)
# 使用控制台将AWS Lambda函数附加到 Amazon Lex V2 机器人
您必须先将 Lambda 函数附加到您的 Amazon Lex V2 机器人别名中，然后才能调用该函数。每个机器人别名只能关联一个 Lambda 函数。使用 AWS 管理控制台执行这些步骤以关联 Lambda 函数。
1. 登录 AWS 管理控制台并通过以下网址打开 Amazon Lex 控制台[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/)。
1. 从左侧面板中选择**机器人**，然后从机器人列表中选择要关联 Lambda 函数的机器人的名称。
1. 在左侧面板中，从**部署**菜单下选择**别名**。
1. 从别名列表中，选择要向其关联 Lambda 函数的别名。
1. 在**语言**面板中，选择您希望 Lambda 函数使用的语言。如果面板中不存在某种语言，请选择**管理别名中的语言**以添加该语言。
1. 在**源**下拉菜单中，选择要关联的 Lambda 函数的名称。
1. 在 **Lambda 函数版本或别名**下拉菜单中，选择要使用的 Lambda 函数的版本或别名。然后选择**保存**。在机器人支持的语言中，所有意图都使用相同的 Lambda 函数。
**将 Amazon Lex V2 意图设置为使用控制台调用 Lambda 函数**
1. 选择机器人后，在要调用 Lambda 函数的机器人的语言下方的左侧菜单中选择**意图**。
1. 选择要在其中调用 Lambda 函数的意图以打开意图编辑器。
1. 设置 Lambda 代码挂钩有两个选项：
1. 要在对话的每一步之后调用 Lambda 函数，请滚动到意图编辑器底部的**代码挂钩**部分，然后选中**使用 Lambda 函数进行初始化和验证**复选框，如下图所示：
![\[Amazon Lex V2 意图编辑器的代码挂钩部分。\]](http://docs.aws.amazon.com/zh_cn/lexv2/latest/dg/images/lambda/lambda-code-hooks-all.png)
1. 或者，在对话阶段使用**对话框代码挂钩**部分来调用 Lambda 函数。**对话框代码挂钩**部分如下所示：
![\[Amazon Lex V2 意图编辑器的代码挂钩部分。\]](http://docs.aws.amazon.com/zh_cn/lexv2/latest/dg/images/lambda/lambda-code-hook-step.png)
可通过两种方法控制 Amazon Lex V2 如何调用代码挂钩以获取响应：
+ 切换**活动**按钮以将其标记为*活动*或*非活动*状态。当代码挂钩处于*活动*状态时，Amazon Lex V2 将调用该代码挂钩。当代码挂钩处于*非活动*状态时，Amazon Lex V2 不会运行代码挂钩。
+ 展开 **Lambda 对话框代码挂钩**部分，然后选中**调用 Lambda 函数**复选框将其标记为*已启用*或*已禁用*。只有在代码挂钩标记为活动状态时，才能启用或禁用该挂钩。当标记为*已启用*时，代码挂钩正常运行。当标记为*已禁用*时，不会调用代码挂钩，Amazon Lex V2 则表现为代码挂钩已成功返回。要配置对话框代码挂钩成功、失败或超时后的响应，请选择**高级选项**。
可以在以下对话阶段调用 Lambda 代码挂钩：
+ 要调用该函数作为**初始响应**，请滚动到**初始响应**部分，点击**响应以确认用户的请求**旁边的箭头展开，然后选择**高级选项**。在弹出的菜单底部找到**对话框代码挂钩**。
+ 要在**槽位引发**后调用该函数，请滚动到**槽位**部分，单击相关**槽位提示**旁边的箭头展开，然后选择**高级选项**。在弹出的菜单底部附近找到**对话框代码挂钩**，位于**默认值**正上方。
您也可以在每次引发后调用该函数。为此，请展开**槽位提示**部分的**机器人引发信息**，选择**更多提示选项**，然后选择**每次引发后调用 Lambda 代码挂钩**对应复选框。
+ 要调用**意图确认**函数，请滚动至**确认**部分，点击**确认意图提示**旁边的箭头展开，然后选择**高级选项**。在弹出的菜单底部找到**对话框代码挂钩**。
+ 要调用**意图履行**函数，请滚动至**履行**部分。切换**活动**按钮以将代码挂钩设置为*活动*状态。点击**成功履行时**旁边的箭头展开，然后选择**高级选项**。选中**履行 Lambda 代码挂钩**部分的**使用 Lambda 函数进行履行**旁边的复选框，将代码挂钩设置为*已启用*。
1. 设置调用 Lambda 函数的对话阶段后，请再次**构建**机器人以测试该函数。
# 使用 API 操作将AWS Lambda函数附加到 Amazon Lex V2 机器人
您必须先将 Lambda 函数附加到您的 Amazon Lex V2 机器人别名中，然后才能调用该函数。每个机器人别名只能关联一个 Lambda 函数。使用 API 操作执行以下步骤以关联 Lambda 函数。
如果您要创建新的机器人别名，请使用[CreateBotAlias](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateBotAlias.html)操作来附加 Lambda 函数。要将 Lambda 函数附加到现有机器人别名，请使用操作。[UpdateBotAlias](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateBotAlias.html)修改 `botAliasLocaleSettings` 字段以包含正确的设置：
```
{
"botAliasLocaleSettings" : {
locale: {
"codeHookSpecification": {
"lambdaCodeHook": {
"codeHookInterfaceVersion": "1.0",
"lambdaARN": "arn:aws:lambda:region:account-id:function:function-name"
}
},
"enabled": true
},
...
}
}
```
1. `botAliasLocaleSettings` 字段映射到一个对象，该对象的键是要在其中关联 Lambda 函数的区域设置。有关支持的区域设置和有效密钥代码的列表，请参阅 [支持的语言和区域设置](how-languages.md#supported-languages)。
1. 要查找 Lambda 函数，请在[https://console.aws.amazon.com/lambda/家](https://console.aws.amazon.com/lambda/home)中打开AWS Lambda控制台，在左侧边栏中选择**函**数，然后选择要与机器人别名关联的函数。`lambdaARN`在**函数概述**的右侧，找到**函数 ARN** 下的 `lambdaARN`。其中应包含区域、账户 ID 和函数名称。
1. 要允许 Amazon Lex V2 为别名调用 Lambda 函数，请将 `enabled` 字段设置为 `true`。
**将 Amazon Lex V2 意图设置为使用 API 操作调用 Lambda 函数**
要在意图期间设置 Lambda 函数调用，请在创建新意图时使用该[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)操作；如果您在现有意图中调用该函数，则使用该[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作。在意图操作中控制 Lambda 函数调用的字段是 `dialogCodeHook`、`initialResponseSetting`、`intentConfirmationSetting` 和 `fulfillmentCodeHook`。
如果在获取插槽期间调用该函数，则在创建新插槽时使用该[CreateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html)操作，或者使用该[UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html)操作在现有插槽中调用该函数。在槽位操作中控制 Lambda 函数调用的字段是 `valueElicitationSetting` 对象的 `slotCaptureSetting` 字段。
1. 要将 Lambda 对话框代码挂钩设置为在对话的每回合之后运行，请将该`enabled`字段中以下[DialogCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogCodeHookSettings.html)对象的`dialogCodeHook`字段设置为：`true`
```
"dialogCodeHook": {
"enabled": boolean
}
```
1. 或者，您可以将 Lambda 对话框代码挂钩设置为仅在对话中的特定时刻运行，方法是修改结构中与您要调用该函数的对话阶段相对应的`codeHook` and/or `elicitationCodeHook`字段。要使用 Lambda 对话框代码挂钩实现意图，请使用[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)或`fulfillmentCodeHook`[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作中的字段。这三种类型的代码挂钩的结构和用途如下：
## codeHook
`codeHook` 字段定义了代码挂钩在对话的给定阶段运行的设置。它是一个具有以下结构的[DialogCodeHookInvocationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogCodeHookInvocationSetting.html)对象：
```
"codeHook": {
"active": boolean,
"enableCodeHookInvocation": boolean,
"invocationLabel": string,
"postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
}
```
+ 将 Amazon Lex V2 的 `active` 字段更改为 `true`，从而在对话中该取值对应的时刻调用代码挂钩。
+ 将 Amazon Lex V2 的 `enableCodeHookInvocation` 字段更改为 `true`，从而允许代码挂钩正常运行。如果将其标记为 `false`，Amazon Lex V2 则表现为代码挂钩已成功返回。
+ `invocationLabel` 表示调用代码挂钩的对话步骤。
+ 通过 `postCodeHookSpecification` 字段指定代码挂钩成功、失败或超时后的操作和消息。
## elicitationCodeHook
`elicitationCodeHook` 字段定义了在需要重新引发一个或多个槽位时运行的代码挂钩的设置。如果槽位引发失败或意图确认被拒绝，则可能会出现这种情况。该`elicitationCodeHook`字段是一个具有以下结构的[ElicitationCodeHookInvocationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ElicitationCodeHookInvocationSetting.html)对象：
```
"elicitationCodeHook": {
"enableCodeHookInvocation": boolean,
"invocationLabel": string
}
```
+ 将 Amazon Lex V2 的 `enableCodeHookInvocation` 字段更改为 `true`，从而允许代码挂钩正常运行。如果将其标记为 `false`，Amazon Lex V2 则表现为代码挂钩已成功返回。
+ `invocationLabel` 表示调用代码挂钩的对话步骤。
## fulfillmentCodeHook
`fulfillmentCodeHook` 字段定义了为履行意图而运行的代码挂钩的设置。它映射到以下[FulfillmentCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentCodeHookSettings.html)对象：
```
"fulfillmentCodeHook": {
"active": boolean,
"enabled": boolean,
"fulfillmentUpdatesSpecification": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
"postFulfillmentStatusSpecification": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html)
}
```
+ 将 Amazon Lex V2 的 `active` 字段更改为 `true`，从而在对话中该取值对应的时刻调用代码挂钩。
+ 将 Amazon Lex V2 的 `enabled` 字段更改为 `true`，从而允许代码挂钩正常运行。如果将其标记为 `false`，Amazon Lex V2 则表现为代码挂钩已成功返回。
+ 通过 `fulfillmentUpdatesSpecification` 字段指定在履行意图期间出现用户更新的消息以及与之相关的时间。
+ 通过 `postFulfillmentStatusSpecification` 字段指定代码挂钩成功、失败或超时后的消息和操作。
您可以通过将 `active` 和 `enableCodeHookInvocation`/`enabled` 字段设置为 `true`，在对话的以下时间点调用 Lambda 代码挂钩：
## 初始响应中
要在识别意图后在初始响应中调用 Lambda 函数，请使用[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)或[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作`initialResponse`字段中的`codeHook`结构。该`initialResponse`字段映射到以下[InitialResponseSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_InitialResponseSetting.html)对象：
```
"initialResponse": {
"codeHook": {
"active": boolean,
"enableCodeHookInvocation": boolean,
"invocationLabel": string,
"postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
},
"initialResponse": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
"nextStep": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html),
"conditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html)
}
```
## 引发槽位之后或重新引发槽位期间
要在获得槽值后调用 Lambda 函数，请使用或`slotCaptureSetting`操作`valueElicitation`字段中的字段。[CreateSlot[UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html)](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html)该`slotCaptureSetting`字段映射到以下[SlotCaptureSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_SlotCaptureSetting.html)对象：
```
"slotCaptureSetting": {
"captureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
"captureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
"captureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html),
"codeHook": {
"active": true,
"enableCodeHookInvocation": true,
"invocationLabel": string,
"postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
},
"elicitationCodeHook": {
"enableCodeHookInvocation": boolean,
"invocationLabel": string
},
"failureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
"failureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
"failureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html)
}
```
+ 要在成功引发槽位后调用 Lambda 函数，请使用 `codeHook` 字段。
+ 要在槽位引发失败且 Amazon Lex V2 尝试重试槽位引发后调用 Lambda 函数，请使用 `elicitationCodeHook` 字段。
## 确认或拒绝意图后
要在确认意图时调用 Lambda 函数，请使用[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)或`intentConfirmationSetting`[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作的字段。该`intentConfirmation`字段映射到以下[IntentConfirmationSetting](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_IntentConfirmationSetting.html)对象：
```
"intentConfirmationSetting": {
"active": boolean,
"codeHook": {
"active": boolean,
"enableCodeHookInvocation": boolean,
"invocationLabel": string,
"postCodeHookSpecification": [PostDialogCodeHookInvocationSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostDialogCodeHookInvocationSpecification.html),
},
"confirmationConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
"confirmationNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
"confirmationResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialResponseSpecificationogState.html),
"declinationConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
"declinationNextStep": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
"declinationResponse": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html),
"elicitationCodeHook": {
"enableCodeHookInvocation": boolean,
"invocationLabel": string,
},
"failureConditional": [ConditionalSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ConditionalSpecification.html),
"failureNextStep": [DialogState object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_DialogState.html),
"failureResponse": [ResponseSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_ResponseSpecification.html),
"promptSpecification": [PromptSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PromptSpecification.html)
}
```
+ 要在用户确认意图及其槽位后调用 Lambda 函数，请使用 `codeHook` 字段。
+ 要在用户拒绝意图确认且 Amazon Lex V2 尝试重试槽位引发后调用 Lambda 函数，请使用 `elicitationCodeHook` 字段。
## 履行意图期间
要调用 Lambda 函数来实现意图，请使用[CreateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateIntent.html)或`fulfillmentCodeHook`[UpdateIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateIntent.html)操作中的字段。该`fulfillmentCodeHook`字段映射到以下[FulfillmentCodeHookSettings](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentCodeHookSettings.html)对象：
```
{
"active": boolean,
"enabled": boolean,
"fulfillmentUpdatesSpecification": [FulfillmentUpdatesSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_FulfillmentUpdatesSpecification.html),
"postFulfillmentStatusSpecification": [PostFulfillmentStatusSpecification object](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_PostFulfillmentStatusSpecification.html)
}
```
3. 设置调用 Lambda 函数的对话阶段后，请执行 `BuildBotLocale` 操作重建机器人以测试该函数。
# 使用 CloudWatch 日志日志调试 Lambda 函数
[Ama CloudWatch zon Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) 是一款用于跟踪 API 调用和指标的工具，您可以使用它来帮助调试 Lambda 函数。当你在控制台中测试机器人或通过 API 调用测试机器人时，会 CloudWatch 记录对话的每个步骤。如果您在 Lambda 代码中使用打印函数，也会 CloudWatch 显示该函数。
**查看 Lambda 函数的 CloudWatch 日志**
1. 登录 AWS 管理控制台并在上打开 CloudWatch 控制台[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)。
1. 在左侧栏的**日志**菜单下，选择**日志组**。
1. 选择您的 Lambda 函数日志组，其格式应为 `/aws/lambda/function-name`。
1. **日志流**列表中包含与机器人进行的每个会话的日志。选择要查看的日志流。
1. 在**日志事件**列表中，点击**时间戳**旁边的右箭头以展开该事件的详细信息。您从 Lambda 代码中打印的任何内容都将显示为日志事件。根据该信息来调试您的代码。
1. 调试代码后，请记得**部署** Lambda 函数。如果您选择通过控制台部署，请在重新测试机器人行为之前重新加载**测试**窗口。