翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# AWS Lambda関数を Amazon Lex V2 ボットに統合する
<a name="lambda"></a>

[AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) 関数を使用すると、定義したカスタム関数を使用して Amazon Lex V2 ボットの動作を拡張すると同時に、より適切に制御できます。Amazon Lex V2 は、インテントごとではなく、各言語のボットのエイリアスごとに 1 つの 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. Lambda 関数を[コンソール](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-console)または [API オペレーション](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-attach-api)の 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 CloudWatch を使用して関数を[デバッグ](https://docs.aws.amazon.com/lexv2/latest/dg/lambda-debug)します。

**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 Logs のログを使用した Lambda 関数のデバッグ](lambda-debug.md)

# AWS LambdaLex V2 の入力イベント形式
<a name="lambda-input-format"></a>

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 Intent 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 Intent 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 Slots for details about the structure
                },
                ...
            }
        },
        ...
    ]
}
```

入力イベントの各フィールドは次の通りです。

## messageVersion
<a name="lambda-input-messageversion"></a>

Lambda 関数に渡されるイベントデータの形式と Lambda 関数から返す必要があるレスポンスの形式を識別するメッセージのバージョン。

**注記**  
インテントを定義するときに、この値を設定します。現在の実装で Amazon Lex V2 がサポートしているのは、メッセージバージョンのみです。そのため、コンソールではデフォルト値の 1.0 が想定され、メッセージのバージョンは表示されません。

## invocationSource
<a name="lambda-input-invocationsource"></a>

Lambda 関数を呼び出したコードフック。以下の値を指定できます。

`DialogCodeHook` — Amazon Lex V2 は、ユーザーからの入力後に Lambda 関数を呼び出します。

`FulfillmentCodeHook` — Amazon Lex V2 は、必要なスロットがすべて満たされ、インテントフルフィルメントの準備ができた後に Lambda 関数を呼び出します。

## inputMode
<a name="lambda-input-inputmode"></a>

ユーザー発話のモード。指定できる値は次のとおりです。

`DTMF` — ユーザーがタッチトーンキーパッド (デュアルトーンマルチ周波数) を使用して発話を入力します。

`Speech` — ユーザーが発話を行いました。

`Text` — ユーザーが発話を入力しました。

## responseContentType
<a name="lambda-input-responsecontenttype"></a>

ユーザーに対するボットの応答の仕組み。`text/plain; charset=utf-8` は、最後の発話が書き込まれたことを示し、`audio` で始まる値は最後の発話が行われたことを示します。

## sessionId
<a name="lambda-input-sessionid"></a>

会話に使用される英数字のセッション識別子。

## inputTranscript
<a name="lambda-input-inputtranscript"></a>

ユーザーからの入力の文字起こし。
+ テキスト入力の場合、これはユーザーが入力したテキストです。DTMF 入力の場合、これはユーザーが入力するキーです。
+ 音声入力の場合は、インテントを呼び出すか、スロットを埋めるために、Amazon Lex V2 がユーザーの発話を変換したテキストです。

## invocationLabel
<a name="lambda-input-invocationlabel"></a>

Lambda 関数を呼び出した応答を示す値。初期応答、スロット、確認応答に呼び出しラベルを設定できます。

## ボット
<a name="lambda-input-bot"></a>

リクエストを処理したボットに関する情報。以下のフィールドで構成されます。
+ **id** - その作成時にボットに割り当てた識別子。ボットの Amazon Lex V2 コンソールでボット ID は、**設定** ページを参照してください。
+ **Name** - ジョブを作成したときにジョブに指定する名前。
+ **localeId** — ボットに使用したロケールの識別子。ロケールのリストについては、「[Amazon Lex V2 でサポートされている言語とロケール](how-languages.md)」を参照してください。
+ **version** - リクエストを処理したボットのバージョン。
+ **aliasId** — ボットのエイリアスの作成時に割り当てた識別子。ボットのエイリアス ID は、Amazon Lex V2 コンソールの **エイリアス** ページで参照してください。リストにエイリアス ID が表示されない場合は、**エイリアス ID** で右上の歯車アイコンを選択してオンにします。
+ **aliasName** — ボットエイリアスに付けた名前。

## 解釈
<a name="lambda-input-interpretations"></a>

Amazon Lex V2 がユーザーの発話と一致する可能性があると考えるインテントに関する情報のリスト。各項目は、発話とインテントの一致に関する情報を次の形式で提供する構造です。

```
{
    "intent": {
        // see Intent 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** – インテントに関する情報が含まれる構造。構造の詳細については、「[Intent](lambda-common-structures.md#lambda-intent)」を参照してください。
+ **nluConfidence** – インテントがユーザーのインテントに一致しているという Amazon Lex V2 の信頼度を示すスコア。
+ **sentimentResponse** — 応答のセンチメントの分析。以下のフィールドが含まれます。
  + **sentiment** — 発話のセンチメントが `POSITIVE`、`NEGATIVE`、`NEUTRAL`、または `MIXED` であるかどうかを示します。
  + **sentimentScore** — 各センチメントを数値にマッピングした構造で、Amazon Lex V2 が発話によるセンチメントの伝達に関する信頼度を示します。
+ **interpretationSource** – スロットが Amazon Lex V2 または Amazon Bedrock によって解決されるかどうかを示します。

## proposedNextState
<a name="lambda-input-proposednextstate"></a>

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 Intent 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** — ユーザーが達成しようとしているとボットが判断したインテント。構造の詳細については、「[Intent](lambda-common-structures.md#lambda-intent)」を参照してください。
+ **prompt** — Amazon Lex V2 がユーザーに次のスロットの入力を促した回数を指定する値に対応するフィールド `attempt` を含む構造。指定できる値は、1 回目の試行に対する `Initial`、それ以降の試行に対する `Retry1`、`Retry2`、`Retry3`、`Retry4` および `Retry5` です。

## requestAttributes
<a name="lambda-input-requestattributes"></a>

クライアントがリクエストで送信するリクエスト固有の属性を含む構造。セッション全体を通しては保持する必要がない情報は、リクエスト属性を使用して渡します。リクエスト属性がない場合、値は null になります。詳細については、「[Lex V2 ボットのリクエスト属性の設定](context-mgmt-request-attribs.md)」を参照してください。

## sessionState
<a name="lambda-input-sessionstate"></a>

ユーザーと Amazon Lex V2 ボット間の会話の現在の状態。構造の詳細については、「[セッション状態](lambda-common-structures.md#lambda-session-state)」を参照してください。

## 文字起こし
<a name="lambda-input-transcriptions"></a>

Amazon Lex V2 がユーザーの発話と一致する可能性があると考える文字起こしのリスト。詳細については、「[音声文字起こしの信頼度スコアを使用した Lex V2 ボットとの会話の改善](using-transcript-confidence-scores.md)」を参照してください。各項目は次の形式のオブジェクトで、1 つの可能な文字起こしに関する情報が含まれています。

```
{
    "transcription": string,
    "transcriptionConfidence": number,
    "resolvedContext": {
        "intent": string
    },
    "resolvedSlots": {
        slot name: {
            // see Slots for details about the structure
        },
        ...
    }
}
```

各フィールドについて以下に説明します。
+ **transcription** – Amazon Lex V2 がユーザーの音声発話と一致する可能性があると考える文字起こし。
+ **transcriptionConfidence** – インテントがユーザーのインテントに一致しているという Amazon Lex V2 の信頼度を示すスコア。
+ **resolvedContext** — フィールド `intent` を含む構造で、発話に関係するインテントと一致します。
+ **resolvedSlots** — 発話によって解決される各スロットの名前をキーとする構造。各スロット名は、そのスロットに関する情報を含む構造にマップされます。構造の詳細については、「[Slots](lambda-common-structures.md#lambda-slot)」を参照してください。

# AWS LambdaLex V2 のレスポンス形式
<a name="lambda-response-format"></a>

Lambda 関数を Amazon Lex V2 ボットに統合する 2 番目のステップは、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
<a name="lambda-response-sessionstate"></a>

ユーザーと返したい Amazon Lex V2 ボット間の会話の状態。構造の詳細については、「[セッション状態](lambda-common-structures.md#lambda-session-state)」を参照してください。このフィールドは常に必須です。

## メッセージ
<a name="lambda-response-messages"></a>

会話の次のターンに 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` フィールドが含まれます。最大 3 つのボタンを含めることができます。

## requestAttributes
<a name="lambda-response-requestattributes"></a>

顧客への応答に必要な要求固有の属性を含む構造。詳細については「[Lex V2 ボットのリクエスト属性の設定](context-mgmt-request-attribs.md)」を参照してください。このフィールドはオプションです。

## 応答内の必須フィールド
<a name="lambda-response-required"></a>

最低でも、Lambda 応答には `sessionState` オブジェクトを含める必要があります。その中で、`dialogAction` オブジェクトを提供し、`type` フィールドを指定します。提供する `dialogAction` の `type` によっては、Lambda 応答に他の必須フィールドがある場合があります。これらの要件は、最小限の実例とともに次のように説明されています。

### 受任者
<a name="lambda-response-delegate"></a>

**Delegate** は、Amazon Lex V2 が次のアクションを決定できるようにします。その他に必須フィールドはありません。

```
{
    "sessionState": {
        "dialogAction": {
            "type": "Delegate"
    }
}
```

### ElicitIntent
<a name="lambda-response-elicitintent"></a>

**ElicitIntent** は、顧客にインテントを表明するよう促します。インテントを誘発するには、`messages` フィールドに少なくとも 1 つのメッセージを含める必要があります。

```
{
    "sessionState": {
        "dialogAction": {
            "type": "ElicitIntent"
    },
    "messages": [
        {
            "contentType": PlainText,
            "content": "How can I help you?"
        }
    ]
}
```

### ElicitSlot
<a name="lambda-response-elicitslot"></a>

**ElicitSlot** は、顧客にスロット値を入力するよう求めます。`dialogAction` オブジェクトの `slotToElicit` フィールドにはスロットの名前を含める必要があります。`sessionState` オブジェクトには `intent` の `name` も含める必要があります。

```
{`
    "sessionState": {
        "dialogAction": {
            "slotToElicit": "OriginCity",
            "type": "ElicitSlot"
        },
        "intent": {
            "name": "BookFlight"
        }
    }
}
```

### ConfirmIntent
<a name="lambda-response-confirmintent"></a>

**ConfirmIntent** は、顧客のスロット値と、そのインテントを達成する準備ができているかどうかを確認します。`sessionState` オブジェクトの `intent` の `name` と、確認する `slots` を含める必要があります。また、`messages` フィールドには、ユーザーにスロット値の確認を求めるメッセージを少なくとも 1 つ含める必要があります。メッセージに「はい」か「いいえ」の応答を求める必要があります。ユーザーの応答が「はい」であった場合、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?"
        }
    ]
}
```

### 閉じる
<a name="lambda-response-close"></a>

**Close** は、インテントのフルフィルメントプロセスを終了し、これ以上ユーザーからの応答が予想されないことを通知します。`sessionState` オブジェクトには `intent` の `name` と `state` を含める必要があります。互換性のあるインテントステートは`Failed`、`Fulfilled`、および `InProgress`です。

```
"sessionState": {
    "dialogAction": {
        "type": "Close"
    },
    "intent": {
        "name": "BookFlight",
        "state": "Failed | Fulfilled | InProgress"
    }
}
```

# Amazon Lex V2 の AWS Lambda関数の一般的な構造
<a name="lambda-common-structures"></a>

Lambda レスポンスには、繰り返し発生する構造が数多くあります。これらの一般的な構造について詳しくは、このセクションで説明しています。

## Intent
<a name="lambda-intent"></a>

```
"intent": {
    "confirmationState": "Confirmed | Denied | None",
    "name": string,
    "slots": {
        // see Slots 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
<a name="lambda-intent-confirmationstate"></a>

ユーザーがインテントのスロットを確認し、インテントフルフィルメントの準備ができているかどうかを示します。以下の値を指定できます。

`Confirmed` — ユーザーはスロット値が正しいことを確認します。

`Denied` — ユーザーがスロット値が正しくないことを示しています。

`None` — ユーザーはまだ確認ステージに達していません。

### 名前
<a name="lambda-intent-name"></a>

インテントの名前。

### slots
<a name="lambda-intent-slots"></a>

インテントを達成するために必要なスロットに関する情報。構造の詳細については、「[Slots](#lambda-slot)」を参照してください。

### state
<a name="lambda-intent-state"></a>

インテントのフルフィルメントステータスを示します。以下の値を指定できます。

`Failed` — ボットはインテントを達成できませんでした。

`Fulfilled` — ボットはインテントのフルフィルメントを完了しました。

`FulfillmentInProgress` — ボットはインテントを達成している最中です。

`InProgress` — ボットは、インテントを達成するために必要なスロット値を誘発している最中です。

`ReadyForFulfillment` — ボットはインテントのすべてのスロット値を誘発し、インテントを実行する準備ができています。

`Waiting` — ボットはユーザーからの応答を待っています (会話のストリーミングに限定される)。

### kendraResponse
<a name="lambda-intent-kendraresponse"></a>

Kendra 検索クエリの結果に関する情報が含まれます。このフィールドは、インテントが `KendraSearchIntent` の場合のみ表示されます。詳細については、「[Kendra の Query API 呼び出しの応答構文](https://docs.aws.amazon.com/kendra/latest/dg/API_Query.html#API_Query_ResponseSyntax)」を参照してください。

## Slots
<a name="lambda-slot"></a>

`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
<a name="lambda-slots-shape"></a>

スロットの形状。この値は、スロットに複数の値がある場合は `List` で (詳細については「[スロットで複数の値を使用する](multi-valued-slots.md)」を参照)、そうでない場合は `Scalar` です。

### 値
<a name="lambda-slots-value"></a>

ユーザーがスロットと Amazon Lex V2 の解釈に提供した値に関する情報を次の形式で含むオブジェクト。

```
{
    "originalValue": string,
    "interpretedValue": string,
    "resolvedValues": [
        string,
        ...
    ]
}
```

各フィールドについて以下に説明します。
+ **originalValue** – Amazon Lex V2 がスロット値に関連していると判断したスロット誘発に対するユーザーのレスポンスの一部。
+ **interpretedValue** – ユーザー入力を考慮して Amazon Lex V2 がスロットに対して決定する値。
+ **resolvedValues** – Amazon Lex V2 がユーザー入力で解決できると判断した値のリスト。

### 値
<a name="lambda-slots-values"></a>

複数値スロットを構成するスロットに関する情報を含むオブジェクトのリスト。各オブジェクトの形式は、上記で説明した `shape` および `value` フィールドを含む通常のスロットの形式と一致します。`values` は、スロットが複数の値で構成されている場合にのみ表示されます (詳細は「[スロットで複数の値を使用する](multi-valued-slots.md)」を参照)。次の JSON オブジェクトは 2 つのコンポーネントスロットを示しています。

```
"values": [
    {
        "shape": "Scalar",
        "value": {
            "originalValue": string,
            "interpretedValue": string,
            "resolvedValues": [
                string,
                ...
            ]
        }
    },
    {
        "shape": "Scalar",
        "value": {
            "originalValue": string,
            "interpretedValue": string,
            "resolvedValues": [
                string,
                ...
            ]
        }
    },
    ...
]
```

## セッション状態
<a name="lambda-session-state"></a>

`sessionState` フィールドは、ユーザーとの会話の状態に関する情報を含むオブジェクトにマップされます。オブジェクトに表示される実際のフィールドは、ダイアログアクションのタイプによって異なります。レスポンスの必須フィールドについては、「[応答内の必須フィールド](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 Intent for details about the structure
    },
    "originatingRequestId": string
}
```

各フィールドについて以下に説明します。

### activeContexts
<a name="lambda-active-contexts"></a>

ユーザーがセッションで使用しているコンテキストに関する情報を含むオブジェクトのリスト。コンテキストを使用してインテントを認識しやすくし、制御します。コンテキストの詳細については、「[Lex V2 ボットのインテントコンテキストの設定](context-mgmt-active-context.md)」を参照してください。各オブジェクトの形式は次のとおりです:

```
{
    "name": string,
    "contextAttributes": {
        string: string
    },
    "timeToLive": {
        "timeToLiveInSeconds": number,
        "turnsToLive": number
    }
}
```

各フィールドについて以下に説明します。
+ **name** – コンテキストの名前。
+ **contextAttributes** — コンテキストの属性名とそれらがマップされる値を含むオブジェクト。
+ **timeToLive** — コンテキストがアクティブである期間を指定するオブジェクト。このオブジェクトには、次の一方または両方のフィールドを含めることができます。
  + **timeToLiveInSeconds** — コンテキストがアクティブのままである秒数。
  + **turnsToLive** – コンテキストがアクティブなままのターン数。

### sessionAttributes
<a name="lambda-session-attributes"></a>

セッション固有のコンテキスト情報を表すキーバリューのペアのマップ。詳細については、「[Lex V2 ボットのセッション属性の設定](context-mgmt-session-attribs.md)」を参照してください。オブジェクトの形式は次のとおりです:

```
{
    string: string,
    ...
}
```

### runtimeHints
<a name="lambda-runtime-hints"></a>

音声認識を改善するために、ユーザーがスロットに使用する可能性が高いフレーズのヒントを提供します。ヒントに入力した値によって、似たような言葉よりもそれらの値の音声認識が向上します。`runtimeHints` オブジェクトの形式は次のとおりです。

```
{
    "slotHints": {
        intent name: {
            slot name: {
                "runtimeHintValues": [
                    {
                        "phrase": string
                    },
                    ...
                ]
            },
            ...
        },
        ...
    }
}
```

`slotHints` フィールドは、ボットのインテントの名前をフィールドとするオブジェクトにマップされます。各インテント名は、そのインテントのスロットの名前をフィールドとするオブジェクトにマップされます。各スロット名は、オブジェクトのリストである 1 つのフィールド `runtimeHintValues` を持つ構造にマップされます。各オブジェクトには、ヒントに対応する `phrase` フィールドが含まれています。

### dialogAction
<a name="lambda-dialog-action"></a>

Amazon Lex V2 が次に実行するアクションを決定します。オブジェクトの形式は次のとおりです。

```
{
    "slotElicitationStyle": "Default | SpellByLetter | SpellByWord",
    "slotToElicit": string,
    "type": "Close | ConfirmIntent | Delegate | ElicitIntent | ElicitSlot"
}
```

各フィールドについて以下に説明します。
+  **slotElicitationStyle** — `dialogAction` の `type` が `ElicitSlot` である場合、ユーザーからの音声入力を Amazon Lex V2 がどのように解釈するかを決定します。詳細については、「[会話中のスペルスタイルによるスロット値のキャプチャ](spelling-styles.md)」を参照してください。以下の値を指定できます。

  `Default` — Amazon Lex V2 は、音声入力をデフォルトの方法で解釈してスロットに対応します。

  `SpellByLetter` — Amazon Lex V2 は、ユーザーによるスロット値のスペルをリッスンします。

  `SpellByWord` — Amazon Lex V2 は、各文字に関連する単語 (「a as in apple」など) を使用して、ユーザーによるスロット値のスペルをリッスンします。
+  **slotToElicit** — `dialogAction` の `type` が `ElicitSlot` の場合に、ユーザーから誘発するスロットを定義します。
+ **type** — ボットが実行すべきアクションを定義します。以下の値を指定できます。

  `Delegate` - Amazon Lex V2 が次のアクションを決定できるようにします。

  `ElicitIntent` — 顧客にインテントを表現するよう促します。

  `ConfirmIntent` - 顧客のスロット値と、そのインテントフルフィルメントの準備ができているかどうかを確認します。

  `ElicitSlot` — インテントのスロット値を入力するよう顧客に促します。

  `Close` — インテントのフルフィルメントプロセスを終了します。

### intent
<a name="lambda-sessionstate-intent"></a>

`intent` フィールドの構造については、「[Intent](#lambda-intent)」を参照してください。

### originatingRequestId
<a name="lambda-originating-request-id"></a>

リクエストの一意の識別子。Lambda レスポンスの場合、このフィールドはオプションです。

# Amazon Lex V2 ボットの AWS Lambda関数の作成
<a name="lambda-attach"></a>

Amazon Lex V2 ボットの Lambda 関数を作成するには、AWS マネジメントコンソールAWS Lambdaから にアクセスし、新しい関数を作成します。詳細については、 デ[AWS Lambdaベロッパーガイド](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)を参照してくださいAWS Lambda。

1. AWS マネジメントコンソールにサインインし、[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) でAWS Lambdaコンソールを開きます。

1. 左側のサイドバーで **[関数]** を選択します。

1. **[Create Function]** (関数を作成) を選択します。

1. **[一から作成]** を選択して最小限のコードから始めるか、**[ブループリントの使用]** を選択してリストから一般的なユースケースのサンプルコードを選択するか、**[コンテナイメージ]** を選択して関数にデプロイするコンテナイメージを選択できます。**[一から選択]** を選択した場合は、次の手順に進んでください。

   1. 関数には、その機能を説明するわかりやすい**関数名**を付けてください。

   1. **[ランタイム]** の下のドロップダウンメニューから、関数を記述する言語を選択します。

   1. 関数の命令セット **[アーキテクチャ]** を選択します。

   1. デフォルトでは、Lambda は基本的なアクセス許可でロールを作成します。既存のロールを使用するか、AWS ポリシーテンプレートを使用してロールを作成するには、**デフォルトの実行ロールの変更**メニューを展開し、オプションを選択します。

   1. **[詳細設定]** メニューを展開して、その他のオプションを設定します。

1. **[Create Function]** (関数を作成) を選択します。

次の図は、新しい関数を最初から作成したときに表示される内容を示しています。

![\[新しい Lambda 関数。\]](http://docs.aws.amazon.com/ja_jp/lexv2/latest/dg/images/lambda/lambda-new-function.png)


Lambda ハンドラー関数は、使用する言語によって異なります。少なくとも因数として `event` JSON オブジェクトを取ります。フィールドは、Amazon Lex V2 が [AWS LambdaLex V2 の入力イベント形式](lambda-input-format.md) で提供する `event` にあります。「[AWS LambdaLex V2 のレスポンス形式](lambda-response-format.md)」で説明されている形式と一致する `response` JSON オブジェクトが最終的に返されるように、ハンドラー関数を変更します。
+ 関数を記述し終えたら、**[デプロイ]** を選択して関数を使用できるようにします。

各ボットエイリアスは、最大で 1 つの 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**
+ [コンソールを使用して Amazon Lex V2 ボットに AWS Lambda関数をアタッチする](lambda-attach-console.md)
+ [API オペレーションを使用して Amazon Lex V2 ボットに AWS Lambda関数をアタッチする](lambda-attach-api.md)

# コンソールを使用して Amazon Lex V2 ボットに AWS Lambda関数をアタッチする
<a name="lambda-attach-console"></a>

呼び出す前に、まず Lambda 関数を Amazon Lex V2 ボットエイリアスにアタッチする必要があります。1 つのボットエイリアスにアタッチできる Lambda 関数は 1 つだけです。以下の手順を実行して、AWS コンソールを使用して Lambda 関数をアタッチします。

1. AWS マネジメントコンソールにサインインし、[https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/) で Amazon Lex コンソールを開きます。

1. 左側のパネルで **[ボット]** を選択し、ボットのリストから Lambda 関数を割り当てるボットの名前を選択します。

1. 左側のパネルから、**[デプロイ]** メニューの **[エイリアス]** を選択します。

1. エイリアスのリストから、Lambda 関数をアタッチするエイリアスの名前を選択します。

1. **[言語]** パネルで、Lambda 関数に使用する言語を選択します。言語がパネルに表示されていない場合は、**[エイリアスの言語を管理]** を選択して言語を追加します。

1. **[ソース]** ドロップダウンメニューで、アタッチする Lambda 関数の名前を選択します。

1. **[Lambda 関数のバージョンまたはエイリアス]** ドロップダウンメニューで、使用する Lambda 関数のバージョンまたはエイリアスを選択します。次に、[**保存**] を選択します。ボットがサポートする言語のすべてのインテントに同じ Lambda 関数が使用されます。

**コンソールを使用して Lambda 関数を呼び出すための Amazon Lex V2 インテントの設定**

1. ボットを選択したら、左側のメニューで Lambda 関数を呼び出すボットの言語の下にある **[インテント]** を選択します。

1. Lambda 関数を呼び出しインテントを選択し、インテントエディターを開きます。

1. Lambda コードフックを設定するためには 2 つのオプションがあります。

   1. 会話の各ステップ後に Lambda 関数を呼び出すには、以下の画像のように、インテントエディターの下部にある **[コードフック]** セクションまでスクロールし、**[初期化と検証に Lambda 関数を使用する]** チェックボックスを選択します。  
![\[Amazon Lex V2 インテントエディタの [コードフック] セクション\]](http://docs.aws.amazon.com/ja_jp/lexv2/latest/dg/images/lambda/lambda-code-hooks-all.png)

   1. または、会話ステージの **[ダイアログコードフック]** セクションを使用して Lambda 関数を呼び出します。**[ダイアログコードフック]** セクションは次のように表示されます。  
![\[Amazon Lex V2 インテントエディタの [コードフック] セクション\]](http://docs.aws.amazon.com/ja_jp/lexv2/latest/dg/images/lambda/lambda-code-hook-step.png)

      Amazon Lex V2 がレスポンスのコードフックを呼び出す方法を制御する方法は 2 つあります。
      + **[アクティブ]** ボタンを切り替えて、*アクティブ*または*非アクティブ*とマークします。コードフックが*アクティブ*になると、Amazon Lex V2 はコードフックを呼び出します。コードフックが*非アクティブ*の場合、Amazon Lex V2 はコードフックを実行しません。
      + **[Lambda ダイアログのコードフック**] セクションを展開し、**[Lambda 関数を呼び出す]** チェックボックスを選択して、*有効*または*無効*のマークを付けます。コードフックは、アクティブとマークされている場合にのみ有効化または無効化できます。*有効*とマークされると、コードフックは通常どおり実行されます。*無効*にすると、コードフックは呼び出されず、Amazon Lex V2 はコードフックが正常に返されたかのように動作します。ダイアログコードフックが成功、失敗、またはタイムアウトした後のレスポンスを設定するには、**[詳細オプション]** を選択します。

      Lambda コードフックは、以下の会話段階で呼び出すことができます。
      + この関数を**初期レスポンス**として呼び出すには、**[初期応答]** セクションまでスクロールし、**[ユーザーの要求を確認するための応答]** の横にある矢印を展開し、**[詳細オプション]**を選択します。ポップアップメニューの下部にある **[ダイアログコードフック]** セクションを探してください。
      + **スロット誘発**後に関数を呼び出すには、**[スロット]** セクションまでスクロールし、該当する **[スロットのプロンプト]** の横にある矢印を展開して、**[詳細オプション]** を選択します。ポップアップメニューの下部、**[デフォルト値]** のすぐ上にある **[ダイアログコードフック]** セクションを見つけてください。

        また、誘発のたびに関数を呼び出すこともできます。これを行うには、**[スロットプロンプト]** セクションの **[ボット誘発情報]** を展開し、**[その他のプロンプトオプション]** を選択し、**[誘発のたびに Lambda コードフックを呼び出す]** の横にあるチェックボックスを選択します。
      + **インテント確認**用の関数を呼び出すには、**[確認]** セクションまでスクロールし、**[インテントを確認するプロンプトを表示]** の横にある矢印を展開してインテントを確認し、**[詳細オプション]** を選択します。ポップアップメニューの下部にある **[ダイアログコードフック]** セクションを探してください。
      + **インテントフルフィルメント**用の関数を呼び出すには、**[フルフィルメント]** セクションまでスクロールします。**[アクティブ]** ボタンを切り替えて、コードフックを**アクティブに設定します。**[フルフィルメントが成功した場合]** の横にある矢印を展開し、**[詳細オプション]** を選択します。**[フルフィルメント Lambda コードフック]** セクションの下にある **[フルフィルメントに Lambda 関数を使用]** の横にあるチェックボックスを選択して、コードフックを*有効*に設定します。

1. Lambda 関数を呼び出す会話ステージを設定したら、ボットを再度 **[構築]** して関数をテストします。

# API オペレーションを使用して Amazon Lex V2 ボットに AWS Lambda関数をアタッチする
<a name="lambda-attach-api"></a>

呼び出す前に、まず Lambda 関数を Amazon Lex V2 ボットエイリアスにアタッチする必要があります。1 つのボットエイリアスに関連付けることができる Lambda 関数 は 1 つだけです。以下の手順を実行して、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 関数`lambdaARN`の を検索するには、[https://console.aws.amazon.com/lambda/home](https://console.aws.amazon.com/lambda/home) でAWS Lambdaコンソールを開き、左側のサイドバーで**関数**を選択し、ボットエイリアスに関連付ける関数を選択します。**[関数概要]** の右側にある **[関数 ARN]** の下の `lambdaARN` を確認します。リージョン、アカウント ID、関数名が含まれている必要があります。

1. Amazon Lex V2 がエイリアスの Lambda 関数を呼び出せるようにするには、`enabled` フィールドを `true` に設定します。

**API オペレーションを使用して Lambda 関数を呼び出すための Amazon Lex V2 インテントの設定**

インテント中に 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. または、関数を呼び出す会話ステージに対応する構造内の `codeHook` および/または `elicitationCodeHook` フィールドを変更して、会話の特定の時点でのみ実行されるように 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) オペレーションの `fulfillmentCodeHook` フィールドを使用します。これら 3 種類のコードフックの構造と用途は次のとおりです。

## codeHook
<a name="lambda-code-hook"></a>

`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
<a name="lambda-elicitation-code-hook"></a>

`elicitationCodeHook` フィールドは、1 つまたは複数のスロットを再利用する必要がある場合に実行するコードフックの設定を定義します。このシナリオは、スロットの誘発に失敗したり、インテントの確認が拒否されたりした場合に発生する可能性があります。`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
<a name="lambda-fulfillment-code-hook"></a>

`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 コードフックを呼び出すことができます。

## 初期応答中
<a name="lambda-hook-initial-response"></a>

インテントが認識された後の初期応答で 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)
}
```

## スロット誘発後、またはスロット再誘発中
<a name="lambda-hook-elicit-slot"></a>

スロット値を取得した後に Lambda 関数を呼び出すには、[CreateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_CreateSlot.html) または [UpdateSlot](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_UpdateSlot.html) オペレーションの `valueElicitation` フィールド内の `slotCaptureSetting` フィールドを使用します。`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` フィールドを使用します。

## インテントの確認または拒否後
<a name="lambda-hook-confirm-intent"></a>

インテントを確認するときに 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) オペレーションの `intentConfirmationSetting` フィールドを使用します。`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` フィールドを使用します。

## インテントフルフィルメント中
<a name="lambda-hook-fulfill-intent"></a>

インテントを確認するために 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) オペレーションの `fulfillmentCodeHook` フィールドを使用します。`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 Logs のログを使用した Lambda 関数のデバッグ
<a name="lambda-debug"></a>

[Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) は、Lambda 関数のデバッグに役立つ API 呼び出しとメトリクスを追跡するためのツールです。コンソールまたは API 呼び出しでボットをテストすると、CloudWatch は会話の各ステップを記録します。Lambda コードで印刷関数を使用すると、CloudWatch はその関数も表示します。

**Lambda 関数の CloudWatch Logs を表示するには**

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 関数を**デプロイ**し、コンソールを使用している場合は、ボットの動作を再テストする前に**テスト**ウィンドウをリロードしてください。