From 85e812add7c7cc3c28667cad34216b68ff926fa5 Mon Sep 17 00:00:00 2001 From: "vapi-tasker[bot]" <253425205+vapi-tasker[bot]@users.noreply.github.com> Date: Thu, 15 Jan 2026 19:12:27 +0000 Subject: [PATCH 1/5] docs: add variable substitution behavior documentation for sessions and chat Explains how variableValues work when using sessions with the Chat API: - Variables are substituted at session creation and "baked in" - Subsequent chat requests cannot override with new variableValues - Fresh templates must be provided to use different values Includes code examples, quick reference table, and best practices. VAP-11219 Co-Authored-By: Claude --- fern/chat/variable-substitution.mdx | 343 ++++++++++++++++++++++++++++ 1 file changed, 343 insertions(+) create mode 100644 fern/chat/variable-substitution.mdx diff --git a/fern/chat/variable-substitution.mdx b/fern/chat/variable-substitution.mdx new file mode 100644 index 000000000..2f35ba6c6 --- /dev/null +++ b/fern/chat/variable-substitution.mdx @@ -0,0 +1,343 @@ +--- +title: Variable substitution in sessions +subtitle: Learn how template variables behave with sessions and chats +slug: chat/variable-substitution +--- + +## Overview + +When using sessions with the Chat API, understanding how variable substitution works is essential for building dynamic, personalized conversations. + +**Key concept:** Variables are substituted at session creation time and "baked into" the stored assistant configuration. Template placeholders like `{{name}}` are replaced with actual values and no longer exist in the session. + +--- + +## How variable substitution works + +### At session creation + +When you create a session with `assistantOverrides.variableValues`, the system: + +1. Takes your assistant's template variables (e.g., `"Hello {{name}} from {{company}}"`) +2. Substitutes all `{{}}` placeholders with provided values +3. Stores the **pre-substituted assistant** in the session +4. Saves the original variable values in `session.metadata.variableValues` for reference + + +```bash title="cURL" +curl -X POST https://api.vapi.ai/session \ + -H "Authorization: Bearer $VAPI_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "assistantId": "your-assistant-id", + "assistantOverrides": { + "variableValues": { + "name": "John", + "company": "Acme Corp" + } + } + }' +``` +```typescript title="TypeScript" +const session = await vapi.sessions.create({ + assistantId: "your-assistant-id", + assistantOverrides: { + variableValues: { + name: "John", + company: "Acme Corp" + } + } +}); +``` +```python title="Python" +session = vapi.sessions.create( + assistant_id="your-assistant-id", + assistant_overrides={ + "variableValues": { + "name": "John", + "company": "Acme Corp" + } + } +) +``` + + +If your assistant's system prompt was `"You are a helpful assistant for {{name}} at {{company}}"`, the session stores: `"You are a helpful assistant for John at Acme Corp"`. + +### At chat creation + +When you send a chat request with a `sessionId`: + +1. The system loads the session's pre-substituted assistant +2. Any `variableValues` in the chat request are processed, but **there are no `{{}}` placeholders left** to substitute +3. New variable values have **no effect** on already-substituted text + +--- + +## Behavior examples + +### Variables persist across chats + +Once you set variables at session creation, they persist for all chats in that session: + + +```bash title="cURL" +# Chat using the session - variables already applied +curl -X POST https://api.vapi.ai/chat \ + -H "Authorization: Bearer $VAPI_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "sessionId": "session_xyz789", + "input": "What is my name and company?" + }' +``` +```typescript title="TypeScript" +const chat = await vapi.chat.create({ + sessionId: "session_xyz789", + input: "What is my name and company?" +}); +// Response will reference "John" and "Acme Corp" +``` +```python title="Python" +chat = vapi.chat.create( + session_id="session_xyz789", + input="What is my name and company?" +) +# Response will reference "John" and "Acme Corp" +``` + + +The assistant will respond with the values set at session creation (John, Acme Corp). + +### New variableValues don't override session values + + +Passing new `variableValues` in a chat request **will not** change the session's pre-substituted assistant. The template placeholders no longer exist. + + + +```bash title="cURL" +# This will NOT change the assistant's context +curl -X POST https://api.vapi.ai/chat \ + -H "Authorization: Bearer $VAPI_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "sessionId": "session_xyz789", + "input": "What is my name and company?", + "assistantOverrides": { + "variableValues": { + "name": "Jane", + "company": "Wayne Enterprises" + } + } + }' +``` +```typescript title="TypeScript" +// This will NOT change the assistant's context +const chat = await vapi.chat.create({ + sessionId: "session_xyz789", + input: "What is my name and company?", + assistantOverrides: { + variableValues: { + name: "Jane", + company: "Wayne Enterprises" + } + } +}); +// Response will STILL reference "John" and "Acme Corp" +``` +```python title="Python" +# This will NOT change the assistant's context +chat = vapi.chat.create( + session_id="session_xyz789", + input="What is my name and company?", + assistant_overrides={ + "variableValues": { + "name": "Jane", + "company": "Wayne Enterprises" + } + } +) +# Response will STILL reference "John" and "Acme Corp" +``` + + +The assistant still responds with "John" and "Acme Corp" because the original templates were already replaced. + +### Provide fresh templates to use new values + +To use different variable values mid-session, provide a new template with `{{}}` placeholders along with the new values: + + +```bash title="cURL" +curl -X POST https://api.vapi.ai/chat \ + -H "Authorization: Bearer $VAPI_API_KEY" \ + -H "Content-Type: application/json" \ + -d '{ + "sessionId": "session_xyz789", + "input": "What is my name and company?", + "assistantOverrides": { + "model": { + "provider": "openai", + "model": "gpt-4o-mini", + "systemPrompt": "You are a helpful assistant for {{name}} at {{company}}. Be very formal." + }, + "variableValues": { + "name": "Jane", + "company": "Wayne Enterprises" + } + } + }' +``` +```typescript title="TypeScript" +const chat = await vapi.chat.create({ + sessionId: "session_xyz789", + input: "What is my name and company?", + assistantOverrides: { + model: { + provider: "openai", + model: "gpt-4o-mini", + systemPrompt: "You are a helpful assistant for {{name}} at {{company}}. Be very formal." + }, + variableValues: { + name: "Jane", + company: "Wayne Enterprises" + } + } +}); +// Response will now reference "Jane" and "Wayne Enterprises" +``` +```python title="Python" +chat = vapi.chat.create( + session_id="session_xyz789", + input="What is my name and company?", + assistant_overrides={ + "model": { + "provider": "openai", + "model": "gpt-4o-mini", + "systemPrompt": "You are a helpful assistant for {{name}} at {{company}}. Be very formal." + }, + "variableValues": { + "name": "Jane", + "company": "Wayne Enterprises" + } + } +) +# Response will now reference "Jane" and "Wayne Enterprises" +``` + + +Now the assistant responds with "Jane" and "Wayne Enterprises" because fresh template placeholders were provided. + +--- + +## Quick reference + +| Scenario | Variables applied? | Why | +|----------|-------------------|-----| +| Session creation with `variableValues` | ✅ Yes | Templates exist, substitution happens | +| Chat with just `sessionId` | ✅ Session values persist | Pre-substituted assistant is used | +| Chat with `sessionId` + new `variableValues` | ❌ No effect | No `{{}}` placeholders left to substitute | +| Chat with `sessionId` + new template with `{{}}` + new `variableValues` | ✅ New values applied | Fresh templates provided | + +--- + +## Best practices + +### For consistent variables across a session + +Pass `assistantOverrides.variableValues` once when creating the session. Subsequent chat requests only need the `sessionId` and `input`: + +```typescript title="Recommended pattern" +// 1. Create session with variables +const session = await vapi.sessions.create({ + assistantId: "your-assistant-id", + assistantOverrides: { + variableValues: { + customerName: "Sarah", + accountType: "Premium" + } + } +}); + +// 2. All chats use the session - variables persist +await vapi.chat.create({ sessionId: session.id, input: "Hello!" }); +await vapi.chat.create({ sessionId: session.id, input: "What's my account type?" }); +``` + +### For different variables per conversation + +Choose one of these approaches: + + + + Pass the full assistant configuration in each chat request. This gives you complete control over variables per request. + + ```typescript + const chat = await vapi.chat.create({ + assistantId: "your-assistant-id", + assistantOverrides: { + variableValues: { + customerName: "Different Customer", + accountType: "Basic" + } + }, + input: "Hello!" + }); + ``` + + + Include a new system prompt (or other text field) with `{{}}` placeholders plus new `variableValues` in your chat request. + + ```typescript + const chat = await vapi.chat.create({ + sessionId: "existing-session-id", + assistantOverrides: { + model: { + provider: "openai", + model: "gpt-4o-mini", + systemPrompt: "You assist {{customerName}} with their {{accountType}} account." + }, + variableValues: { + customerName: "New Customer", + accountType: "Enterprise" + } + }, + input: "Hello!" + }); + ``` + + + Create a new session for each unique variable context. This keeps conversations cleanly separated. + + ```typescript + // Session for Customer A + const sessionA = await vapi.sessions.create({ + assistantId: "your-assistant-id", + assistantOverrides: { + variableValues: { customerName: "Customer A" } + } + }); + + // Session for Customer B + const sessionB = await vapi.sessions.create({ + assistantId: "your-assistant-id", + assistantOverrides: { + variableValues: { customerName: "Customer B" } + } + }); + ``` + + + +--- + +## Next steps + +- **[Session management](/chat/session-management)** - Learn about `previousChatId` vs `sessionId` approaches +- **[Variables](/assistants/dynamic-variables)** - Configure dynamic variables in your assistant +- **[Streaming responses](/chat/streaming)** - Add real-time responses to your chats + + +Need help? Chat with the team on our [Discord](https://discord.com/invite/pUFNcf2WmH) or mention us on [X/Twitter](https://x.com/Vapi_AI). + From 16190281e9f582a100a012a8df7b1ce98a9c2f65 Mon Sep 17 00:00:00 2001 From: "vapi-tasker[bot]" <253425205+vapi-tasker[bot]@users.noreply.github.com> Date: Thu, 15 Jan 2026 19:14:47 +0000 Subject: [PATCH 2/5] docs: add variable substitution page to Chat navigation VAP-11219 Co-Authored-By: Claude --- fern/docs.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/fern/docs.yml b/fern/docs.yml index 97e195f56..161594823 100644 --- a/fern/docs.yml +++ b/fern/docs.yml @@ -479,6 +479,9 @@ navigation: - page: Session management path: chat/session-management.mdx icon: fa-light fa-layer-group + - page: Variable substitution + path: chat/variable-substitution.mdx + icon: fa-light fa-brackets-curly - page: SMS chat path: chat/sms-chat.mdx icon: fa-light fa-comment-sms From a71c951f7ab19b4dbe834707baeb61619f998147 Mon Sep 17 00:00:00 2001 From: "vapi-tasker[bot]" <253425205+vapi-tasker[bot]@users.noreply.github.com> Date: Thu, 15 Jan 2026 19:20:25 +0000 Subject: [PATCH 3/5] docs: update model to gpt-4.1 and add LiquidJS reference - Changed all examples from gpt-4o-mini to gpt-4.1 - Added note explaining that Vapi uses LiquidJS for variable substitution - Clarified that {{ }} syntax follows Liquid template language conventions VAP-11219 Co-Authored-By: Claude --- fern/chat/variable-substitution.mdx | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/fern/chat/variable-substitution.mdx b/fern/chat/variable-substitution.mdx index 2f35ba6c6..4dd705e53 100644 --- a/fern/chat/variable-substitution.mdx +++ b/fern/chat/variable-substitution.mdx @@ -10,6 +10,10 @@ When using sessions with the Chat API, understanding how variable substitution w **Key concept:** Variables are substituted at session creation time and "baked into" the stored assistant configuration. Template placeholders like `{{name}}` are replaced with actual values and no longer exist in the session. + +Vapi uses [LiquidJS](https://liquidjs.com/) for variable substitution. The `{{ }}` syntax follows Liquid template language conventions, giving you access to filters, conditionals, and other Liquid features beyond simple variable replacement. + + --- ## How variable substitution works @@ -19,7 +23,7 @@ When using sessions with the Chat API, understanding how variable substitution w When you create a session with `assistantOverrides.variableValues`, the system: 1. Takes your assistant's template variables (e.g., `"Hello {{name}} from {{company}}"`) -2. Substitutes all `{{}}` placeholders with provided values +2. Substitutes all `{{ }}` placeholders using LiquidJS 3. Stores the **pre-substituted assistant** in the session 4. Saves the original variable values in `session.metadata.variableValues` for reference @@ -69,7 +73,7 @@ If your assistant's system prompt was `"You are a helpful assistant for {{name}} When you send a chat request with a `sessionId`: 1. The system loads the session's pre-substituted assistant -2. Any `variableValues` in the chat request are processed, but **there are no `{{}}` placeholders left** to substitute +2. Any `variableValues` in the chat request are processed, but **there are no `{{ }}` placeholders left** to substitute 3. New variable values have **no effect** on already-substituted text --- @@ -166,7 +170,7 @@ The assistant still responds with "John" and "Acme Corp" because the original te ### Provide fresh templates to use new values -To use different variable values mid-session, provide a new template with `{{}}` placeholders along with the new values: +To use different variable values mid-session, provide a new template with `{{ }}` placeholders along with the new values: ```bash title="cURL" @@ -179,7 +183,7 @@ curl -X POST https://api.vapi.ai/chat \ "assistantOverrides": { "model": { "provider": "openai", - "model": "gpt-4o-mini", + "model": "gpt-4.1", "systemPrompt": "You are a helpful assistant for {{name}} at {{company}}. Be very formal." }, "variableValues": { @@ -196,7 +200,7 @@ const chat = await vapi.chat.create({ assistantOverrides: { model: { provider: "openai", - model: "gpt-4o-mini", + model: "gpt-4.1", systemPrompt: "You are a helpful assistant for {{name}} at {{company}}. Be very formal." }, variableValues: { @@ -214,7 +218,7 @@ chat = vapi.chat.create( assistant_overrides={ "model": { "provider": "openai", - "model": "gpt-4o-mini", + "model": "gpt-4.1", "systemPrompt": "You are a helpful assistant for {{name}} at {{company}}. Be very formal." }, "variableValues": { @@ -237,8 +241,8 @@ Now the assistant responds with "Jane" and "Wayne Enterprises" because fresh tem |----------|-------------------|-----| | Session creation with `variableValues` | ✅ Yes | Templates exist, substitution happens | | Chat with just `sessionId` | ✅ Session values persist | Pre-substituted assistant is used | -| Chat with `sessionId` + new `variableValues` | ❌ No effect | No `{{}}` placeholders left to substitute | -| Chat with `sessionId` + new template with `{{}}` + new `variableValues` | ✅ New values applied | Fresh templates provided | +| Chat with `sessionId` + new `variableValues` | ❌ No effect | No `{{ }}` placeholders left to substitute | +| Chat with `sessionId` + new template with `{{ }}` + new `variableValues` | ✅ New values applied | Fresh templates provided | --- @@ -287,7 +291,7 @@ Choose one of these approaches: ``` - Include a new system prompt (or other text field) with `{{}}` placeholders plus new `variableValues` in your chat request. + Include a new system prompt (or other text field) with `{{ }}` placeholders plus new `variableValues` in your chat request. ```typescript const chat = await vapi.chat.create({ @@ -295,7 +299,7 @@ Choose one of these approaches: assistantOverrides: { model: { provider: "openai", - model: "gpt-4o-mini", + model: "gpt-4.1", systemPrompt: "You assist {{customerName}} with their {{accountType}} account." }, variableValues: { From 03eca9294fb201a578c38dc132ab505e64055bbb Mon Sep 17 00:00:00 2001 From: "vapi-tasker[bot]" <253425205+vapi-tasker[bot]@users.noreply.github.com> Date: Thu, 15 Jan 2026 19:23:00 +0000 Subject: [PATCH 4/5] docs: simplify examples to cURL only Remove TypeScript and Python code examples, keeping only cURL for cleaner documentation. VAP-11219 Co-Authored-By: Claude --- fern/chat/variable-substitution.mdx | 186 +--------------------------- 1 file changed, 5 insertions(+), 181 deletions(-) diff --git a/fern/chat/variable-substitution.mdx b/fern/chat/variable-substitution.mdx index 4dd705e53..b162d7cfe 100644 --- a/fern/chat/variable-substitution.mdx +++ b/fern/chat/variable-substitution.mdx @@ -27,8 +27,7 @@ When you create a session with `assistantOverrides.variableValues`, the system: 3. Stores the **pre-substituted assistant** in the session 4. Saves the original variable values in `session.metadata.variableValues` for reference - -```bash title="cURL" +```bash title="Create session with variables" curl -X POST https://api.vapi.ai/session \ -H "Authorization: Bearer $VAPI_API_KEY" \ -H "Content-Type: application/json" \ @@ -42,29 +41,6 @@ curl -X POST https://api.vapi.ai/session \ } }' ``` -```typescript title="TypeScript" -const session = await vapi.sessions.create({ - assistantId: "your-assistant-id", - assistantOverrides: { - variableValues: { - name: "John", - company: "Acme Corp" - } - } -}); -``` -```python title="Python" -session = vapi.sessions.create( - assistant_id="your-assistant-id", - assistant_overrides={ - "variableValues": { - "name": "John", - "company": "Acme Corp" - } - } -) -``` - If your assistant's system prompt was `"You are a helpful assistant for {{name}} at {{company}}"`, the session stores: `"You are a helpful assistant for John at Acme Corp"`. @@ -84,9 +60,7 @@ When you send a chat request with a `sessionId`: Once you set variables at session creation, they persist for all chats in that session: - -```bash title="cURL" -# Chat using the session - variables already applied +```bash title="Chat using the session" curl -X POST https://api.vapi.ai/chat \ -H "Authorization: Bearer $VAPI_API_KEY" \ -H "Content-Type: application/json" \ @@ -95,21 +69,6 @@ curl -X POST https://api.vapi.ai/chat \ "input": "What is my name and company?" }' ``` -```typescript title="TypeScript" -const chat = await vapi.chat.create({ - sessionId: "session_xyz789", - input: "What is my name and company?" -}); -// Response will reference "John" and "Acme Corp" -``` -```python title="Python" -chat = vapi.chat.create( - session_id="session_xyz789", - input="What is my name and company?" -) -# Response will reference "John" and "Acme Corp" -``` - The assistant will respond with the values set at session creation (John, Acme Corp). @@ -119,9 +78,7 @@ The assistant will respond with the values set at session creation (John, Acme C Passing new `variableValues` in a chat request **will not** change the session's pre-substituted assistant. The template placeholders no longer exist. - -```bash title="cURL" -# This will NOT change the assistant's context +```bash title="This will NOT change the assistant's context" curl -X POST https://api.vapi.ai/chat \ -H "Authorization: Bearer $VAPI_API_KEY" \ -H "Content-Type: application/json" \ @@ -136,35 +93,6 @@ curl -X POST https://api.vapi.ai/chat \ } }' ``` -```typescript title="TypeScript" -// This will NOT change the assistant's context -const chat = await vapi.chat.create({ - sessionId: "session_xyz789", - input: "What is my name and company?", - assistantOverrides: { - variableValues: { - name: "Jane", - company: "Wayne Enterprises" - } - } -}); -// Response will STILL reference "John" and "Acme Corp" -``` -```python title="Python" -# This will NOT change the assistant's context -chat = vapi.chat.create( - session_id="session_xyz789", - input="What is my name and company?", - assistant_overrides={ - "variableValues": { - "name": "Jane", - "company": "Wayne Enterprises" - } - } -) -# Response will STILL reference "John" and "Acme Corp" -``` - The assistant still responds with "John" and "Acme Corp" because the original templates were already replaced. @@ -172,8 +100,7 @@ The assistant still responds with "John" and "Acme Corp" because the original te To use different variable values mid-session, provide a new template with `{{ }}` placeholders along with the new values: - -```bash title="cURL" +```bash title="Override with fresh template" curl -X POST https://api.vapi.ai/chat \ -H "Authorization: Bearer $VAPI_API_KEY" \ -H "Content-Type: application/json" \ @@ -193,43 +120,6 @@ curl -X POST https://api.vapi.ai/chat \ } }' ``` -```typescript title="TypeScript" -const chat = await vapi.chat.create({ - sessionId: "session_xyz789", - input: "What is my name and company?", - assistantOverrides: { - model: { - provider: "openai", - model: "gpt-4.1", - systemPrompt: "You are a helpful assistant for {{name}} at {{company}}. Be very formal." - }, - variableValues: { - name: "Jane", - company: "Wayne Enterprises" - } - } -}); -// Response will now reference "Jane" and "Wayne Enterprises" -``` -```python title="Python" -chat = vapi.chat.create( - session_id="session_xyz789", - input="What is my name and company?", - assistant_overrides={ - "model": { - "provider": "openai", - "model": "gpt-4.1", - "systemPrompt": "You are a helpful assistant for {{name}} at {{company}}. Be very formal." - }, - "variableValues": { - "name": "Jane", - "company": "Wayne Enterprises" - } - } -) -# Response will now reference "Jane" and "Wayne Enterprises" -``` - Now the assistant responds with "Jane" and "Wayne Enterprises" because fresh template placeholders were provided. @@ -250,24 +140,7 @@ Now the assistant responds with "Jane" and "Wayne Enterprises" because fresh tem ### For consistent variables across a session -Pass `assistantOverrides.variableValues` once when creating the session. Subsequent chat requests only need the `sessionId` and `input`: - -```typescript title="Recommended pattern" -// 1. Create session with variables -const session = await vapi.sessions.create({ - assistantId: "your-assistant-id", - assistantOverrides: { - variableValues: { - customerName: "Sarah", - accountType: "Premium" - } - } -}); - -// 2. All chats use the session - variables persist -await vapi.chat.create({ sessionId: session.id, input: "Hello!" }); -await vapi.chat.create({ sessionId: session.id, input: "What's my account type?" }); -``` +Pass `assistantOverrides.variableValues` once when creating the session. Subsequent chat requests only need the `sessionId` and `input`. ### For different variables per conversation @@ -276,61 +149,12 @@ Choose one of these approaches: Pass the full assistant configuration in each chat request. This gives you complete control over variables per request. - - ```typescript - const chat = await vapi.chat.create({ - assistantId: "your-assistant-id", - assistantOverrides: { - variableValues: { - customerName: "Different Customer", - accountType: "Basic" - } - }, - input: "Hello!" - }); - ``` Include a new system prompt (or other text field) with `{{ }}` placeholders plus new `variableValues` in your chat request. - - ```typescript - const chat = await vapi.chat.create({ - sessionId: "existing-session-id", - assistantOverrides: { - model: { - provider: "openai", - model: "gpt-4.1", - systemPrompt: "You assist {{customerName}} with their {{accountType}} account." - }, - variableValues: { - customerName: "New Customer", - accountType: "Enterprise" - } - }, - input: "Hello!" - }); - ``` Create a new session for each unique variable context. This keeps conversations cleanly separated. - - ```typescript - // Session for Customer A - const sessionA = await vapi.sessions.create({ - assistantId: "your-assistant-id", - assistantOverrides: { - variableValues: { customerName: "Customer A" } - } - }); - - // Session for Customer B - const sessionB = await vapi.sessions.create({ - assistantId: "your-assistant-id", - assistantOverrides: { - variableValues: { customerName: "Customer B" } - } - }); - ``` From 6264de4687b7d1a201c953cf4fcc3ec198bbd63a Mon Sep 17 00:00:00 2001 From: "vapi-tasker[bot]" <253425205+vapi-tasker[bot]@users.noreply.github.com> Date: Thu, 15 Jan 2026 19:30:34 +0000 Subject: [PATCH 5/5] docs: use UUID format for example IDs Replace placeholder IDs with proper UUID format examples. VAP-11219 Co-Authored-By: Claude --- fern/chat/variable-substitution.mdx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/fern/chat/variable-substitution.mdx b/fern/chat/variable-substitution.mdx index b162d7cfe..980114349 100644 --- a/fern/chat/variable-substitution.mdx +++ b/fern/chat/variable-substitution.mdx @@ -32,7 +32,7 @@ curl -X POST https://api.vapi.ai/session \ -H "Authorization: Bearer $VAPI_API_KEY" \ -H "Content-Type: application/json" \ -d '{ - "assistantId": "your-assistant-id", + "assistantId": "79f3cae3-5e47-4d8c-a1b2-9f8e7d6c5b4a", "assistantOverrides": { "variableValues": { "name": "John", @@ -65,7 +65,7 @@ curl -X POST https://api.vapi.ai/chat \ -H "Authorization: Bearer $VAPI_API_KEY" \ -H "Content-Type: application/json" \ -d '{ - "sessionId": "session_xyz789", + "sessionId": "6b4c494f-c22c-4bce-84fa-a7a86942c7d3", "input": "What is my name and company?" }' ``` @@ -83,7 +83,7 @@ curl -X POST https://api.vapi.ai/chat \ -H "Authorization: Bearer $VAPI_API_KEY" \ -H "Content-Type: application/json" \ -d '{ - "sessionId": "session_xyz789", + "sessionId": "6b4c494f-c22c-4bce-84fa-a7a86942c7d3", "input": "What is my name and company?", "assistantOverrides": { "variableValues": { @@ -105,7 +105,7 @@ curl -X POST https://api.vapi.ai/chat \ -H "Authorization: Bearer $VAPI_API_KEY" \ -H "Content-Type: application/json" \ -d '{ - "sessionId": "session_xyz789", + "sessionId": "6b4c494f-c22c-4bce-84fa-a7a86942c7d3", "input": "What is my name and company?", "assistantOverrides": { "model": {