@alexkroman1/aai 0.12.3 → 1.0.2

package/host/fixture-replay.test.ts

@@ -0,0 +1,463 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * Fixture replay tests with a REAL Runtime.
+ *
+ * Replays recorded AssemblyAI S2S messages (from Kokoro TTS audio) through
+ * a real agent session — real tool execution, real Zod arg validation, real
+ * hook invocation.
+ *
+ * This exercises: AgentDef → toAgentConfig → tool schemas → Zod validation
+ * → executeToolCall → session orchestration (reply guards, tool buffering,
+ * turnPromise chaining, conversation history).
+ */
+
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { z } from "zod";
+import type { AgentDef } from "../sdk/types.ts";
+import { createFixtureSession, flush } from "./_test-utils.ts";
+
+// ─── Test agents with deterministic tools ────────────────────────────────────
+
+const weatherAgent: AgentDef = {
+  name: "weather-agent",
+  systemPrompt: "You are a weather assistant.",
+  greeting: "Ask me about the weather!",
+  maxSteps: 5,
+  tools: {
+    get_weather: {
+      description: "Get the current weather for a city",
+      parameters: z.object({
+        city: z.string().describe("City name"),
+      }),
+      execute: ({ city }: { city: string }) => ({
+        city,
+        temperature: "72°F",
+        condition: "sunny",
+        humidity: "45%",
+      }),
+    },
+  },
+};
+
+const simpleAgent: AgentDef = {
+  name: "simple-agent",
+  systemPrompt: "You are a helpful assistant.",
+  greeting: "Hi!",
+  maxSteps: 5,
+  tools: {},
+};
+
+const statefulAgent: AgentDef<{ callCount: number }> = {
+  name: "stateful-agent",
+  systemPrompt: "You are helpful.",
+  greeting: "Hi!",
+  maxSteps: 5,
+  state: () => ({ callCount: 0 }),
+  tools: {
+    get_weather: {
+      description: "Get weather",
+      parameters: z.object({ city: z.string() }),
+      execute: ({ city }: { city: string }, ctx) => {
+        ctx.state.callCount++;
+        return { city, calls: ctx.state.callCount };
+      },
+    },
+  },
+};
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("fixture replay with real executor", () => {
+  let cleanup: () => void;
+
+  afterEach(() => {
+    cleanup?.();
+  });
+
+  // ── Tool call: real Zod validation + real tool execution ───────────────
+
+  test("tool call fixture: Zod validates args, real tool executes, result sent to S2S", async () => {
+    const ctx = createFixtureSession(weatherAgent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("tool-call-sequence.json");
+
+    // Wait for the async tool execution pipeline to complete
+    await vi.waitFor(() => expect(ctx.mockHandle.sendToolResult).toHaveBeenCalled());
+
+    // Verify the real tool was called and produced correct output
+    const [callId, resultStr] = vi.mocked(ctx.mockHandle.sendToolResult).mock.calls[0] as [
+      string,
+      string,
+    ];
+    expect(callId).toBeTruthy();
+    const result = JSON.parse(resultStr);
+    expect(result.city).toBe("San Francisco");
+    expect(result.temperature).toBe("72°F");
+    expect(result.condition).toBe("sunny");
+  });
+
+  test("tool call fixture: client receives tool_call with validated args", async () => {
+    const ctx = createFixtureSession(weatherAgent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("tool-call-sequence.json");
+    await vi.waitFor(() => expect(ctx.mockHandle.sendToolResult).toHaveBeenCalled());
+
+    const toolStart = ctx.client.events.find((e) => (e as { type: string }).type === "tool_call") as
+      | { toolName: string; args: Record<string, unknown> }
+      | undefined;
+    expect(toolStart?.toolName).toBe("get_weather");
+    expect(toolStart?.args).toEqual({ city: "San Francisco" });
+  });
+
+  test("tool call fixture: conversation history accumulates user + assistant messages", async () => {
+    const ctx = createFixtureSession(weatherAgent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("tool-call-sequence.json");
+    await vi.waitFor(() => expect(ctx.mockHandle.sendToolResult).toHaveBeenCalled());
+    await flush();
+
+    // Client received user transcript
+    const turns = ctx.client.events.filter(
+      (e) => (e as { type: string }).type === "user_transcript",
+    );
+    expect(turns.length).toBeGreaterThan(0);
+    const userText = (turns.at(-1) as { text: string }).text;
+    expect(userText.toLowerCase()).toContain("weather");
+  });
+
+  // ── Simple question: no tools, just session lifecycle ──────────────────
+
+  test("simple question fixture: greeting + agent response reach client", async () => {
+    const ctx = createFixtureSession(simpleAgent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("simple-question-sequence.json");
+    await flush();
+
+    const chats = ctx.client.events.filter(
+      (e) => (e as { type: string }).type === "agent_transcript",
+    );
+    expect(chats.length).toBeGreaterThanOrEqual(2); // greeting + answer
+  });
+
+  test("simple question fixture: user speech events forwarded to client", async () => {
+    const ctx = createFixtureSession(simpleAgent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("simple-question-sequence.json");
+    await flush();
+
+    const types = ctx.client.events.map((e) => (e as { type: string }).type);
+    expect(types).toContain("speech_started");
+    expect(types).toContain("speech_stopped");
+    expect(types).toContain("user_transcript");
+  });
+
+  // ── Stateful agent: session state persists across tool calls ───────────
+
+  test("stateful agent: tool accesses and mutates session state", async () => {
+    const ctx = createFixtureSession(statefulAgent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("tool-call-sequence.json");
+    await vi.waitFor(() => expect(ctx.mockHandle.sendToolResult).toHaveBeenCalled());
+
+    const [, resultStr] = vi.mocked(ctx.mockHandle.sendToolResult).mock.calls[0] as [
+      string,
+      string,
+    ];
+    const result = JSON.parse(resultStr);
+    expect(result.calls).toBe(1); // state.callCount was incremented
+  });
+
+  // ── Greeting only: session lifecycle without user audio ────────────────
+
+  test("greeting fixture: session setup completes with tts_done", async () => {
+    const ctx = createFixtureSession(simpleAgent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("greeting-session-sequence.json");
+    await flush();
+
+    const types = ctx.client.events.map((e) => (e as { type: string }).type);
+    expect(types).toContain("agent_transcript");
+    expect(types).toContain("reply_done");
+  });
+
+  // ── Tool schemas: real agent produces correct S2S tool schemas ─────────
+
+  test("real executor builds correct tool schemas from AgentDef", () => {
+    const ctx = createFixtureSession(weatherAgent);
+    cleanup = ctx.cleanup;
+
+    const schema = ctx.executor.toolSchemas.find((s) => s.name === "get_weather");
+    expect(schema).toBeDefined();
+    expect(schema?.description).toBe("Get the current weather for a city");
+    expect(schema?.parameters).toMatchObject({
+      type: "object",
+      properties: { city: { type: "string" } },
+      required: ["city"],
+    });
+  });
+
+  // ── Tool errors are surfaced as tool results ───────────────────────────
+
+  test("tool throw is surfaced as error result", async () => {
+    const agent: AgentDef = {
+      name: "error-agent",
+      systemPrompt: "Weather assistant.",
+      greeting: "Ask about weather!",
+      maxSteps: 5,
+      tools: {
+        get_weather: {
+          description: "Get weather",
+          parameters: z.object({ city: z.string() }),
+          execute: () => {
+            throw new Error("API key expired");
+          },
+        },
+      },
+    };
+
+    const ctx = createFixtureSession(agent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("tool-call-sequence.json");
+    await vi.waitFor(() => expect(ctx.mockHandle.sendToolResult).toHaveBeenCalled());
+
+    // Tool result should contain the error
+    const [, resultStr] = vi.mocked(ctx.mockHandle.sendToolResult).mock.calls[0] as [
+      string,
+      string,
+    ];
+    expect(resultStr).toContain("API key expired");
+  });
+
+  // ── Zod validation: bad args rejected ──────────────────────────────────
+
+  test("Zod validation rejects malformed tool args", async () => {
+    const agent: AgentDef = {
+      name: "strict-agent",
+      systemPrompt: "Weather assistant.",
+      greeting: "Ask about weather!",
+      maxSteps: 5,
+      tools: {
+        get_weather: {
+          description: "Get weather",
+          parameters: z.object({
+            city: z.string(),
+            country: z.string(), // required but not in fixture
+          }),
+          execute: () => "should not run",
+        },
+      },
+    };
+
+    const ctx = createFixtureSession(agent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("tool-call-sequence.json");
+    await vi.waitFor(() => expect(ctx.mockHandle.sendToolResult).toHaveBeenCalled());
+
+    // The result should contain a Zod validation error
+    const [, resultStr] = vi.mocked(ctx.mockHandle.sendToolResult).mock.calls[0] as [
+      string,
+      string,
+    ];
+    expect(resultStr).toContain("Invalid arguments");
+    expect(resultStr).toContain("country");
+  });
+
+  // ── Interrupted transcript NOT added to conversation history ────────────
+
+  test("interrupted agent transcript is not pushed to conversation history", async () => {
+    // Use a tool that captures messages to inspect conversation history
+    let capturedMessages: readonly { role: string; content: string }[] = [];
+    const agent: AgentDef = {
+      name: "interrupt-history-agent",
+      systemPrompt: "You are helpful.",
+      greeting: "Hi!",
+      maxSteps: 5,
+      tools: {
+        check_history: {
+          description: "Check history",
+          parameters: z.object({ q: z.string() }),
+          execute: (_args: unknown, ctx) => {
+            capturedMessages = [...ctx.messages];
+            return "ok";
+          },
+        },
+      },
+    };
+
+    const ctx = createFixtureSession(agent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    const h = ctx.mockHandle;
+
+    // Fire an interrupted transcript — should NOT go into conversation history
+    h._fire("replyStarted", { replyId: "r1" });
+    h._fire("event", {
+      type: "agent_transcript",
+      text: "This was interrupted",
+      _interrupted: true,
+    });
+    h._fire("event", { type: "cancelled" });
+    await flush();
+
+    // Client sees both agent_transcript and cancelled events
+    const types = ctx.client.events.map((e) => (e as { type: string }).type);
+    expect(types).toContain("agent_transcript");
+    expect(types).toContain("cancelled");
+
+    // Fire a non-interrupted transcript — SHOULD go into conversation history
+    h._fire("replyStarted", { replyId: "r2" });
+    h._fire("event", {
+      type: "agent_transcript",
+      text: "This was completed",
+      _interrupted: false,
+    });
+    h._fire("event", { type: "reply_done" });
+    await flush();
+
+    // Trigger a tool call to inspect conversation history.
+    h._fire("event", { type: "user_transcript", text: "check" });
+    await flush();
+    h._fire("replyStarted", { replyId: "r3" });
+    h._fire("event", {
+      type: "tool_call",
+      toolCallId: "c1",
+      toolName: "check_history",
+      args: { q: "test" },
+    });
+    // Wait for tool to execute (captures messages)
+    await vi.waitFor(() => expect(capturedMessages.length).toBeGreaterThan(0));
+
+    // Conversation history should contain the completed text but NOT the interrupted text
+    const assistantMsgs = capturedMessages.filter((m) => m.role === "assistant");
+    expect(assistantMsgs.some((m) => m.content === "This was completed")).toBe(true);
+    expect(assistantMsgs.every((m) => m.content !== "This was interrupted")).toBe(true);
+  });
+
+  // ── Conversation history correctness after full tool-call flow ──────────
+
+  test("conversation history has user + assistant messages after tool-call flow", async () => {
+    // Use a tool that captures the messages it receives
+    let capturedMessages: readonly { role: string; content: string }[] = [];
+    const agent: AgentDef = {
+      name: "history-agent",
+      systemPrompt: "Weather assistant.",
+      greeting: "Ask about weather!",
+      maxSteps: 5,
+      tools: {
+        get_weather: {
+          description: "Get weather",
+          parameters: z.object({ city: z.string() }),
+          execute: ({ city }: { city: string }, ctx) => {
+            capturedMessages = [...ctx.messages];
+            return { city, temp: "72°F" };
+          },
+        },
+      },
+    };
+
+    const ctx = createFixtureSession(agent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    ctx.replay("tool-call-sequence.json");
+    await vi.waitFor(() => expect(ctx.mockHandle.sendToolResult).toHaveBeenCalled());
+
+    // The tool should have seen the user's weather question in messages
+    const userMsgs = capturedMessages.filter((m) => m.role === "user");
+    expect(userMsgs.some((m) => m.content.toLowerCase().includes("weather"))).toBe(true);
+  });
+
+  // ── Audio chunks forwarded to client.playAudioChunk ────────────────────
+
+  test("reply.audio events forwarded to client.playAudioChunk", async () => {
+    const ctx = createFixtureSession(simpleAgent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    // Manually fire audio events (replay skips them, so fire directly)
+    const audioBytes = new Uint8Array([10, 20, 30, 40]);
+    ctx.mockHandle._fire("audio", { audio: audioBytes });
+    ctx.mockHandle._fire("audio", { audio: new Uint8Array([50, 60]) });
+
+    expect(ctx.client.audioChunks.length).toBe(2);
+    expect(Array.from(ctx.client.audioChunks[0] ?? [])).toEqual([10, 20, 30, 40]);
+    expect(Array.from(ctx.client.audioChunks[1] ?? [])).toEqual([50, 60]);
+  });
+
+  // ── Multiple tool calls in one reply: results buffered and sent together ─
+
+  test("multiple tool calls in one reply: all results buffered and sent after replyDone", async () => {
+    const agent: AgentDef = {
+      name: "multi-tool-agent",
+      systemPrompt: "Weather assistant.",
+      greeting: "Hi!",
+      maxSteps: 5,
+      tools: {
+        get_weather: {
+          description: "Get weather",
+          parameters: z.object({ city: z.string() }),
+          execute: ({ city }: { city: string }) => ({ city, temp: "72°F" }),
+        },
+      },
+    };
+
+    const ctx = createFixtureSession(agent);
+    cleanup = ctx.cleanup;
+    await ctx.session.start();
+
+    const h = ctx.mockHandle;
+    h._fire("replyStarted", { replyId: "r1" });
+    h._fire("event", {
+      type: "tool_call",
+      toolCallId: "c1",
+      toolName: "get_weather",
+      args: { city: "NYC" },
+    });
+    h._fire("event", {
+      type: "tool_call",
+      toolCallId: "c2",
+      toolName: "get_weather",
+      args: { city: "LA" },
+    });
+
+    // Wait for both tool calls to execute
+    await vi.waitFor(() => {
+      const starts = ctx.client.events.filter((e) => (e as { type: string }).type === "tool_call");
+      expect(starts.length).toBe(2);
+    });
+
+    // Results NOT sent yet — reply_done hasn't fired
+    expect(ctx.mockHandle.sendToolResult).not.toHaveBeenCalled();
+
+    // Fire reply_done — should flush both results
+    h._fire("event", { type: "reply_done" });
+    await vi.waitFor(() => {
+      expect(ctx.mockHandle.sendToolResult).toHaveBeenCalledTimes(2);
+    });
+
+    // Verify both results are correct
+    const calls = vi.mocked(ctx.mockHandle.sendToolResult).mock.calls as [string, string][];
+    const results = calls.map(([, r]) => JSON.parse(r));
+    expect(results.some((r) => r.city === "NYC")).toBe(true);
+    expect(results.some((r) => r.city === "LA")).toBe(true);
+  });
+});

package/host/fixtures/README.md

@@ -0,0 +1,40 @@
+# API Response Fixtures
+
+Real AssemblyAI S2S WebSocket messages recorded from the live API.
+User audio was generated with Kokoro TTS (24kHz resampled to 16kHz
+PCM16).
+
+## Files
+
+**Session lifecycle:**
+
+- `session-ready.json` — `session.ready` messages (config echo-back)
+- `session-updated.json` — `session.updated` acknowledgements
+
+**Greeting (no user audio):**
+
+- `greeting-session-sequence.json` — Complete greeting session
+- `reply-lifecycle.json` — Reply: started, deltas, transcript, done
+- `reply-audio-samples.json` — `reply.audio` chunks (base64 truncated)
+
+**Simple question (Kokoro: "Tell me a fun fact about space"):**
+
+- `simple-question-sequence.json` — Greeting, STT, agent response
+- `user-speech-recognition.json` — Speech start/stop, transcript.user
+
+**Tool call (Kokoro: "What is the weather in San Francisco?"):**
+
+- `tool-call-sequence.json` — Greeting, STT, tool.call, response
+- `tool-calls.json` — Just the tool.call messages with parsed args
+
+**Builtin tool call (Kokoro: "Search for Mars rover findings"):**
+
+- `web-search-sequence.json` — Greeting, STT, web_search, response
+
+## Notes
+
+- Audio data is truncated (`_truncated`, `_originalBase64Length`).
+- Real messages include extra fields (`timestamp`, `config`,
+  `start_ms`, `end_ms`) that the parser must tolerate.
+- Session IDs and timestamps are from the recording — tests should
+  not depend on specific values.

package/host/fixtures/greeting-session-sequence.json

@@ -0,0 +1,40 @@
+[
+  {
+    "type": "session.updated",
+    "timestamp": 1774669383.6972675,
+    "config": {
+      "system_prompt": "You are a helpful assistant. Keep responses very short, under 10 words.",
+      "tools": [],
+      "greeting": "Hello! How can I help you today?"
+    }
+  },
+  {
+    "type": "session.ready",
+    "timestamp": 1774669383.7014148,
+    "session_id": "sess_2575293792fe47c790905010a6bb4a5e",
+    "config": {
+      "system_prompt": "You are a helpful assistant. Keep responses very short, under 10 words.",
+      "tools": [],
+      "greeting": "Hello! How can I help you today?"
+    }
+  },
+  {
+    "type": "reply.started",
+    "timestamp": 1774669383.702049,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a"
+  },
+  {
+    "type": "transcript.agent",
+    "timestamp": 1774669386.8797214,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a",
+    "item_id": "msg_5a2edc3add16401ca99c81eb8fda72e3",
+    "text": "Hello! How can I help you today?",
+    "interrupted": false
+  },
+  {
+    "type": "reply.done",
+    "timestamp": 1774669387.1929219,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a",
+    "status": "completed"
+  }
+]

package/host/fixtures/reply-audio-samples.json

@@ -0,0 +1,42 @@
+[
+  {
+    "type": "reply.audio",
+    "timestamp": 1774669383.7329695,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a",
+    "data": "AAAAAAAA//8AAAAAAAAAAAAAAAD//wAAAAAAAAAAAAD/////AAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAP//AQD/////AAAAAAAAAAD//wAAAAAAAAAAAAAAAAAAAAAAAAAA//8AAAEAAAABAAAAAAAAAAAAAAAAAAAAAAD//wEAAAAAAAAA",
+    "_truncated": true,
+    "_originalBase64Length": 2312
+  },
+  {
+    "type": "reply.audio",
+    "timestamp": 1774669383.7631137,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a",
+    "data": "AAAAAP//AAAAAAAAAAD//wAAAAAAAP////8AAP//AAAAAAAAAAAAAAAA//8AAAAAAAD//wAA//8AAP7/AAAAAAAAAAAAAAAAAQAAAP//AAABAAAAAAABAAEAAAAAAAEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAP//AAAAAAAA//8AAAAAAQAAAAAAAAAAAAEAAQAAAAAA",
+    "_truncated": true,
+    "_originalBase64Length": 2312
+  },
+  {
+    "type": "reply.audio",
+    "timestamp": 1774669383.803568,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a",
+    "data": "//8AAAAAAAAAAAAAAAAAAAAA//8AAAAAAAAAAAAAAAD//wAAAAABAAAAAAD//wAAAQAAAAAAAAABAAAAAQAAAAAAAAAAAP//AAAAAAAAAAAAAP//AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAA//8AAAAA",
+    "_truncated": true,
+    "_originalBase64Length": 2312
+  },
+  {
+    "type": "reply.audio",
+    "timestamp": 1774669383.8428738,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a",
+    "data": "//8AAAAAAAAAAAAAAAAAAP////8AAP//AAAAAP//AAAAAAAAAAAAAAAAAAAAAAAAAAABAAEAAAAAAAEAAAAAAAAAAQAAAAAAAQAAAAAAAAAAAAAAAAD/////AAAAAAAAAAAAAAAAAAAAAAAAAAD//wAAAQAAAAEA//8AAAAAAAAAAAAA//8AAAAAAAAAAAAAAQAAAAAA",
+    "_truncated": true,
+    "_originalBase64Length": 2312
+  },
+  {
+    "type": "reply.audio",
+    "timestamp": 1774669383.8731623,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a",
+    "data": "AAABAAAA//8AAAEAAAABAP//AAAAAAEAAQABAAAAAAAAAP//AAAAAAEAAAABAAAAAAAAAAAAAAD//wAAAAAAAAAAAAD//wEAAAAAAP////8AAAAA/////wAAAAAAAAEAAAAAAAEAAAAAAAAAAAABAAAA//8AAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAA",
+    "_truncated": true,
+    "_originalBase64Length": 2312
+  }
+]

package/host/fixtures/reply-lifecycle.json

@@ -0,0 +1,21 @@
+[
+  {
+    "type": "reply.started",
+    "timestamp": 1774669383.702049,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a"
+  },
+  {
+    "type": "transcript.agent",
+    "timestamp": 1774669386.8797214,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a",
+    "item_id": "msg_5a2edc3add16401ca99c81eb8fda72e3",
+    "text": "Hello! How can I help you today?",
+    "interrupted": false
+  },
+  {
+    "type": "reply.done",
+    "timestamp": 1774669387.1929219,
+    "reply_id": "resp_02ca83aad786449cadc7aab6c4e2737a",
+    "status": "completed"
+  }
+]

package/host/fixtures/session-ready.json

@@ -0,0 +1,48 @@
+[
+  {
+    "type": "session.ready",
+    "timestamp": 1774669383.7014148,
+    "session_id": "sess_2575293792fe47c790905010a6bb4a5e",
+    "config": {
+      "system_prompt": "You are a helpful assistant. Keep responses very short, under 10 words.",
+      "tools": [],
+      "greeting": "Hello! How can I help you today?"
+    }
+  },
+  {
+    "type": "session.ready",
+    "timestamp": 1774669390.5586526,
+    "session_id": "sess_2246ce7e2eb146e08e62c9476278fbef",
+    "config": {
+      "system_prompt": "You are a helpful assistant. Keep responses to one short sentence.",
+      "tools": [],
+      "greeting": "Hi!"
+    }
+  },
+  {
+    "type": "session.ready",
+    "timestamp": 1774669401.5069516,
+    "session_id": "sess_b01d5d5f1865418b955dc30b00b3d52b",
+    "config": {
+      "system_prompt": "You are a weather assistant. Always use the get_weather tool for weather questions. After getting the result, tell the user the weather in one sentence.",
+      "tools": [
+        {
+          "type": "function",
+          "name": "get_weather",
+          "description": "Get the current weather for a city",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "city": {
+                "type": "string",
+                "description": "City name"
+              }
+            },
+            "required": ["city"]
+          }
+        }
+      ],
+      "greeting": "Ask me about the weather!"
+    }
+  }
+]