@alexkroman1/aai 1.4.5 → 1.5.0

package/host/ws-handler.test.ts

@@ -1,12 +1,22 @@
 import { describe, expect, test, vi } from "vitest";
 import type { ClientSink } from "../sdk/protocol.ts";
 import { MockWebSocket } from "./_mock-ws.ts";
-import { makeStubSession, silentLogger } from "./_test-utils.ts";
-import type { Session } from "./session.ts";
+import { makeLogger, makeMockCore, silentLogger } from "./_test-utils.ts";
+import type { SessionCore } from "./session-core.ts";
 import { wireSessionSocket } from "./ws-handler.ts";
 
-function makeLogger() {
-  return { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+// ─── Test helpers ────────────────────────────────────────────────────────────
+
+const defaultConfig = { audioFormat: "pcm16" as const, sampleRate: 16_000, ttsSampleRate: 24_000 };
+
+/** Simulate a binary frame arriving on the WebSocket. */
+function simulateBinaryFrame(ws: MockWebSocket, frame: Uint8Array): void {
+  ws.dispatchEvent(new MessageEvent("message", { data: frame }));
+}
+
+/** Simulate a string (text) frame arriving on the WebSocket. */
+function simulateTextFrame(ws: MockWebSocket, text: string): void {
+  ws.dispatchEvent(new MessageEvent("message", { data: text }));
 }
 
 /** Wait until wireSessionSocket has fully initialized (sessionReady = true). */
@@ -17,9 +27,11 @@ async function waitForSessionReady(logger: { info: ReturnType<typeof vi.fn> }):
   });
 }
 
-const defaultConfig = { audioFormat: "pcm16" as const, sampleRate: 16_000, ttsSampleRate: 24_000 };
+// ─── Tests ───────────────────────────────────────────────────────────────────
 
 describe("wireSessionSocket", () => {
+  // ─── Lifecycle: startup ──────────────────────────────────────────────────
+
   test("'Session ready' is not logged until session.start() resolves", async () => {
     const logs: string[] = [];
     const logger = {
@@ -30,25 +42,26 @@ describe("wireSessionSocket", () => {
     };
 
     let resolveStart!: () => void;
-    const session = makeStubSession();
-    session.start = vi.fn(
-      () =>
-        new Promise<void>((r) => {
-          resolveStart = r;
-        }),
-    );
+    const core = makeMockCore({
+      start: vi.fn(
+        () =>
+          new Promise<void>((r) => {
+            resolveStart = r;
+          }),
+      ),
+    });
 
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger,
     });
 
-    expect(session.start).toHaveBeenCalled();
+    expect(core.start).toHaveBeenCalled();
     expect(logs).toContain("Session connected");
     expect(logs).not.toContain("Session ready");
 
@@ -67,15 +80,14 @@ describe("wireSessionSocket", () => {
       debug: (msg: string, meta?: Record<string, unknown>) => logs.push({ msg, meta }),
     };
 
-    const session = makeStubSession();
-    session.start = vi.fn(() => Promise.reject(new Error("boom")));
+    const core = makeMockCore({ start: vi.fn(() => Promise.reject(new Error("boom"))) });
 
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger,
     });
@@ -87,32 +99,31 @@ describe("wireSessionSocket", () => {
   });
 
   test("session is added to sessions map on open", () => {
-    const sessions = new Map<string, Session>();
-    const session = makeStubSession();
+    const sessions = new Map<string, SessionCore>();
+    const core = makeMockCore();
 
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
     });
 
     expect(sessions.size).toBe(1);
-    expect([...sessions.values()][0]).toBe(session);
+    expect([...sessions.values()][0]).toBe(core);
   });
 
   test("session is removed from sessions map on close", async () => {
-    const sessions = new Map<string, Session>();
-    const session = makeStubSession();
+    const sessions = new Map<string, SessionCore>();
 
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => session,
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
     });
 
@@ -124,134 +135,156 @@ describe("wireSessionSocket", () => {
     });
   });
 
-  test("sends config as first message on open", () => {
+  // ─── CONFIG frame on open ────────────────────────────────────────────────
+
+  test("sends CONFIG JSON frame as first message on open", () => {
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => makeStubSession(),
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
+      logger: silentLogger,
     });
 
-    const sent = ws.sentJson();
-    expect(sent[0]).toMatchObject({ type: "config", ...defaultConfig });
+    expect(ws.sent.length).toBeGreaterThanOrEqual(1);
+    const firstFrame = ws.sent[0];
+    expect(typeof firstFrame).toBe("string");
+    const msg = JSON.parse(firstFrame as string);
+    expect(msg.type).toBe("config");
   });
 
-  // ─── Binary audio handling ──────────────────────────────────────────────
-
-  test("Uint8Array binary data is forwarded to session.onAudio", async () => {
-    const session = makeStubSession();
+  test("CONFIG frame contains correct sampleRate and ttsSampleRate", () => {
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
-    const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
-      logger,
+      logger: silentLogger,
     });
 
-    await waitForSessionReady(logger);
+    const firstFrame = ws.sent[0];
+    const msg = JSON.parse(firstFrame as string);
+    expect(msg.type).toBe("config");
+    expect(msg.audioFormat).toBe("pcm16");
+    expect(msg.sampleRate).toBe(16_000);
+    expect(msg.ttsSampleRate).toBe(24_000);
+  });
 
-    const audio = new Uint8Array([1, 2, 3, 4]);
-    ws.simulateMessage(audio.buffer);
+  test("CONFIG frame includes the session ID as sessionId", () => {
+    const ws = new MockWebSocket("ws://test");
+    ws.readyState = MockWebSocket.OPEN;
+    const sessions = new Map<string, SessionCore>();
+    let capturedId: string | undefined;
 
-    expect(session.onAudio).toHaveBeenCalledOnce();
-    const passed = (session.onAudio as ReturnType<typeof vi.fn>).mock.calls[0]?.[0];
-    expect(passed).toBeInstanceOf(Uint8Array);
+    wireSessionSocket(ws, {
+      sessions,
+      createSession: (sid) => {
+        capturedId = sid;
+        return makeMockCore();
+      },
+      readyConfig: defaultConfig,
+      logger: silentLogger,
+    });
+
+    const firstFrame = ws.sent[0];
+    const msg = JSON.parse(firstFrame as string);
+    expect(msg.type).toBe("config");
+    expect(msg.sessionId).toBeTruthy();
+    expect(msg.sessionId).toBe(capturedId);
   });
 
-  test("ArrayBuffer data is forwarded to session.onAudio", async () => {
-    const session = makeStubSession();
+  // ─── Inbound C2S frame routing ───────────────────────────────────────────
+
+  test("raw binary Uint8Array routes to session.onAudio", async () => {
+    const core = makeMockCore();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
     const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger,
     });
 
     await waitForSessionReady(logger);
 
-    const buf = new ArrayBuffer(4);
-    ws.simulateMessage(buf);
+    const pcm = new Uint8Array([1, 2, 3, 4]);
+    simulateBinaryFrame(ws, pcm);
 
-    expect(session.onAudio).toHaveBeenCalledOnce();
+    expect(core.onAudio).toHaveBeenCalledOnce();
+    const passed = (core.onAudio as ReturnType<typeof vi.fn>).mock.calls[0]?.[0];
+    expect(passed).toBeInstanceOf(Uint8Array);
   });
 
-  // ─── Text message handling ──────────────────────────────────────────────
-
-  test("audio_ready message calls session.onAudioReady", async () => {
-    const session = makeStubSession();
+  test("audio_ready JSON text frame routes to session.onAudioReady", async () => {
+    const core = makeMockCore();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
     const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger,
     });
 
     await waitForSessionReady(logger);
-
-    ws.simulateMessage(JSON.stringify({ type: "audio_ready" }));
-    expect(session.onAudioReady).toHaveBeenCalledOnce();
+    simulateTextFrame(ws, JSON.stringify({ type: "audio_ready" }));
+    expect(core.onAudioReady).toHaveBeenCalledOnce();
   });
 
-  test("cancel message calls session.onCancel", async () => {
-    const session = makeStubSession();
+  test("cancel JSON text frame routes to session.onCancel", async () => {
+    const core = makeMockCore();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
     const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger,
     });
 
     await waitForSessionReady(logger);
-
-    ws.simulateMessage(JSON.stringify({ type: "cancel" }));
-    expect(session.onCancel).toHaveBeenCalledOnce();
+    simulateTextFrame(ws, JSON.stringify({ type: "cancel" }));
+    expect(core.onCancel).toHaveBeenCalledOnce();
   });
 
-  test("reset message calls session.onReset", async () => {
-    const session = makeStubSession();
+  test("reset JSON text frame routes to session.onReset", async () => {
+    const core = makeMockCore();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
     const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger,
     });
 
     await waitForSessionReady(logger);
-
-    ws.simulateMessage(JSON.stringify({ type: "reset" }));
-    expect(session.onReset).toHaveBeenCalledOnce();
+    simulateTextFrame(ws, JSON.stringify({ type: "reset" }));
+    expect(core.onReset).toHaveBeenCalledOnce();
   });
 
-  test("history message calls session.onHistory", async () => {
-    const session = makeStubSession();
+  test("history JSON text frame routes to session.onHistory with decoded messages", async () => {
+    const core = makeMockCore();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
     const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger,
     });
@@ -260,169 +293,123 @@ describe("wireSessionSocket", () => {
 
     const messages = [
       { role: "user" as const, content: "Hello" },
-      { role: "assistant" as const, content: "Hi" },
+      { role: "assistant" as const, content: "Hi there" },
     ];
-    ws.simulateMessage(JSON.stringify({ type: "history", messages }));
-    expect(session.onHistory).toHaveBeenCalledWith(messages);
+    simulateTextFrame(ws, JSON.stringify({ type: "history", messages }));
+    expect(core.onHistory).toHaveBeenCalledOnce();
+    const passed = (core.onHistory as ReturnType<typeof vi.fn>).mock.calls[0]?.[0];
+    expect(passed).toEqual(messages);
   });
 
-  test("invalid JSON is logged and ignored", async () => {
-    const session = makeStubSession();
+  // ─── Text message error handling ─────────────────────────────────────────
+
+  test("invalid JSON text frame is dropped with warning, session not closed", async () => {
+    const core = makeMockCore();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
-    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+    const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger,
     });
 
     await waitForSessionReady(logger);
 
-    ws.simulateMessage("not-json{{{");
-    expect(logger.warn).toHaveBeenCalledWith("Invalid JSON from client", expect.any(Object));
+    simulateTextFrame(ws, "this is not json{{{");
+    expect(logger.warn).toHaveBeenCalledWith("ws: invalid JSON; dropping", expect.any(Object));
+    // Session methods must not be called
+    expect(core.onAudioReady).not.toHaveBeenCalled();
+    // Socket must still be open (not closed)
+    expect(ws.readyState).toBe(MockWebSocket.OPEN);
   });
 
-  test("invalid message schema is logged and ignored", async () => {
-    const session = makeStubSession();
+  test("unknown client message type is silently dropped", async () => {
+    const core = makeMockCore();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
-    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+    const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger,
     });
 
     await waitForSessionReady(logger);
 
-    // Unknown but well-formed message types are silently ignored (two-phase
-    // parsing: additive protocol changes should not produce warnings).
-    ws.simulateMessage(JSON.stringify({ type: "unknown_type" }));
+    // Valid JSON with a valid { type } envelope but unknown type — lenientParse returns ok:false, malformed:false
+    simulateTextFrame(ws, JSON.stringify({ type: "some_future_message_type" }));
+    // Must NOT warn — rolling-upgrade tolerance
     expect(logger.warn).not.toHaveBeenCalled();
+    expect(core.onAudioReady).not.toHaveBeenCalled();
+    expect(ws.readyState).toBe(MockWebSocket.OPEN);
   });
 
-  // ─── ClientSink (indirect testing via createSession capture) ────────────
-
-  test("ClientSink.event sends JSON text via ws.send", () => {
-    let capturedClient!: ClientSink;
-    const ws = new MockWebSocket("ws://test");
-    ws.readyState = MockWebSocket.OPEN;
-
-    wireSessionSocket(ws, {
-      sessions: new Map(),
-      createSession: (_sid, client) => {
-        capturedClient = client;
-        return makeStubSession();
-      },
-      readyConfig: defaultConfig,
-      logger: silentLogger,
-    });
-
-    capturedClient.event({ type: "speech_started" });
-    const sentStrings = ws.sent.filter((d): d is string => typeof d === "string");
-    expect(sentStrings).toContainEqual(expect.stringContaining('"speech_started"'));
-  });
-
-  test("ClientSink.playAudioChunk sends binary data", () => {
-    let capturedClient!: ClientSink;
-    const ws = new MockWebSocket("ws://test");
-    ws.readyState = MockWebSocket.OPEN;
+  // ─── Message buffering ───────────────────────────────────────────────────
 
-    wireSessionSocket(ws, {
-      sessions: new Map(),
-      createSession: (_sid, client) => {
-        capturedClient = client;
-        return makeStubSession();
-      },
-      readyConfig: defaultConfig,
-      logger: silentLogger,
+  test("frames before session is ready are buffered and replayed after start()", async () => {
+    let resolveStart!: () => void;
+    const core = makeMockCore({
+      start: vi.fn(
+        () =>
+          new Promise<void>((r) => {
+            resolveStart = r;
+          }),
+      ),
     });
 
-    const chunk = new Uint8Array([10, 20, 30]);
-    capturedClient.playAudioChunk(chunk);
-    expect(ws.sent).toContain(chunk);
-  });
-
-  test("ClientSink.playAudioDone sends audio_done JSON", () => {
-    let capturedClient!: ClientSink;
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
+    const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: (_sid, client) => {
-        capturedClient = client;
-        return makeStubSession();
-      },
+      createSession: () => core,
       readyConfig: defaultConfig,
-      logger: silentLogger,
+      logger,
     });
 
-    capturedClient.playAudioDone();
-    const sentStrings = ws.sent.filter((d): d is string => typeof d === "string");
-    expect(sentStrings).toContainEqual(expect.stringContaining('"audio_done"'));
-  });
-
-  test("ClientSink.open reflects ws.readyState", () => {
-    let capturedClient!: ClientSink;
-    const ws = new MockWebSocket("ws://test");
-    ws.readyState = MockWebSocket.OPEN;
+    // Session not ready yet — send a cancel text frame
+    simulateTextFrame(ws, JSON.stringify({ type: "cancel" }));
+    expect(core.onCancel).not.toHaveBeenCalled();
 
-    wireSessionSocket(ws, {
-      sessions: new Map(),
-      createSession: (_sid, client) => {
-        capturedClient = client;
-        return makeStubSession();
-      },
-      readyConfig: defaultConfig,
-      logger: silentLogger,
-    });
+    // Now let start() resolve
+    resolveStart();
+    await waitForSessionReady(logger);
 
-    expect(capturedClient.open).toBe(true);
-    ws.readyState = MockWebSocket.CLOSED;
-    expect(capturedClient.open).toBe(false);
+    expect(core.onCancel).toHaveBeenCalledOnce();
   });
 
-  test("ClientSink tolerates ws.send throwing (closed socket)", () => {
-    let capturedClient!: ClientSink;
+  test("messages before session is created (no open yet) are ignored", () => {
     const ws = new MockWebSocket("ws://test");
-    ws.readyState = MockWebSocket.OPEN;
+    ws.readyState = MockWebSocket.CONNECTING;
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: (_sid, client) => {
-        capturedClient = client;
-        return makeStubSession();
-      },
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
       logger: silentLogger,
     });
 
-    // Override send to throw
-    ws.send = () => {
-      throw new Error("socket closed");
-    };
-    // Should not throw
-    capturedClient.event({ type: "speech_started" });
-    capturedClient.playAudioChunk(new Uint8Array([1]));
-    capturedClient.playAudioDone();
+    // No open yet — session is null, should be silently ignored
+    simulateTextFrame(ws, JSON.stringify({ type: "audio_ready" }));
+    // No error thrown
   });
 
-  // ─── Close handler ──────────────────────────────────────────────────────
+  // ─── Close handler ───────────────────────────────────────────────────────
 
   test("close handler calls session.stop", async () => {
-    const session = makeStubSession();
+    const core = makeMockCore();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger: silentLogger,
     });
@@ -430,20 +417,20 @@ describe("wireSessionSocket", () => {
     ws.close();
 
     await vi.waitFor(() => {
-      expect(session.stop).toHaveBeenCalledOnce();
+      expect(core.stop).toHaveBeenCalledOnce();
     });
   });
 
-  // ─── Error handler ──────────────────────────────────────────────────────
+  // ─── Error handler ───────────────────────────────────────────────────────
 
   test("error event is logged", () => {
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
-    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+    const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => makeStubSession(),
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
       logger,
     });
@@ -461,11 +448,11 @@ describe("wireSessionSocket", () => {
   test("generic error event logs default message", () => {
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
-    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+    const logger = makeLogger();
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => makeStubSession(),
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
       logger,
     });
@@ -478,7 +465,7 @@ describe("wireSessionSocket", () => {
     );
   });
 
-  // ─── Callbacks ──────────────────────────────────────────────────────────
+  // ─── Callbacks ───────────────────────────────────────────────────────────
 
   test("onOpen callback is invoked when socket opens", () => {
     const onOpen = vi.fn();
@@ -487,7 +474,7 @@ describe("wireSessionSocket", () => {
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => makeStubSession(),
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
       onOpen,
       logger: silentLogger,
@@ -503,7 +490,7 @@ describe("wireSessionSocket", () => {
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => makeStubSession(),
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
       onClose,
       logger: silentLogger,
@@ -517,17 +504,16 @@ describe("wireSessionSocket", () => {
     const onSessionEnd = vi.fn();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
-    const sessions = new Map<string, Session>();
+    const sessions = new Map<string, SessionCore>();
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => makeStubSession(),
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
       onSessionEnd,
       logger: silentLogger,
     });
 
-    // Session is now in the map
     expect(sessions.size).toBe(1);
     const sessionId = [...sessions.keys()][0] ?? "";
 
@@ -540,24 +526,138 @@ describe("wireSessionSocket", () => {
     expect(sessions.size).toBe(0);
   });
 
-  // ─── Concurrency regression tests ─────────────────────────────────────
+  test("onSinkCreated callback is invoked with sessionId and ClientSink", () => {
+    const onSinkCreated = vi.fn();
+    const ws = new MockWebSocket("ws://test");
+    ws.readyState = MockWebSocket.OPEN;
+
+    wireSessionSocket(ws, {
+      sessions: new Map(),
+      createSession: () => makeMockCore(),
+      readyConfig: defaultConfig,
+      onSinkCreated,
+      logger: silentLogger,
+    });
+
+    expect(onSinkCreated).toHaveBeenCalledOnce();
+    expect(typeof onSinkCreated.mock.calls[0]?.[0]).toBe("string");
+  });
+
+  // ─── ClientSink (indirect testing via createSession capture) ─────────────
+
+  test("ClientSink.open reflects ws.readyState", () => {
+    let capturedClient!: ClientSink;
+    const ws = new MockWebSocket("ws://test");
+    ws.readyState = MockWebSocket.OPEN;
+
+    wireSessionSocket(ws, {
+      sessions: new Map(),
+      createSession: (_sid, client) => {
+        capturedClient = client;
+        return makeMockCore();
+      },
+      readyConfig: defaultConfig,
+      logger: silentLogger,
+    });
+
+    expect(capturedClient.open).toBe(true);
+    ws.readyState = MockWebSocket.CLOSED;
+    expect(capturedClient.open).toBe(false);
+  });
+
+  test("ClientSink.playAudioChunk sends raw binary Uint8Array", () => {
+    let capturedClient!: ClientSink;
+    const ws = new MockWebSocket("ws://test");
+    ws.readyState = MockWebSocket.OPEN;
+
+    wireSessionSocket(ws, {
+      sessions: new Map(),
+      createSession: (_sid, client) => {
+        capturedClient = client;
+        return makeMockCore();
+      },
+      readyConfig: defaultConfig,
+      logger: silentLogger,
+    });
+
+    const chunk = new Uint8Array([10, 20, 30]);
+    capturedClient.playAudioChunk(chunk);
+
+    // Find binary frames in sent (skip the initial config JSON string)
+    const binaryFrames = (ws.sent as unknown[]).filter((d) => d instanceof Uint8Array);
+    expect(binaryFrames.length).toBeGreaterThanOrEqual(1);
+    expect(binaryFrames[0]).toBe(chunk);
+  });
+
+  test("ClientSink.playAudioDone sends audio_done JSON text frame", () => {
+    let capturedClient!: ClientSink;
+    const ws = new MockWebSocket("ws://test");
+    ws.readyState = MockWebSocket.OPEN;
+
+    wireSessionSocket(ws, {
+      sessions: new Map(),
+      createSession: (_sid, client) => {
+        capturedClient = client;
+        return makeMockCore();
+      },
+      readyConfig: defaultConfig,
+      logger: silentLogger,
+    });
+
+    capturedClient.playAudioDone();
+
+    // Find JSON string frames after the initial config
+    const textFrames = (ws.sent as unknown[])
+      .filter((d): d is string => typeof d === "string")
+      .map((s) => JSON.parse(s));
+    const audioDoneFrame = textFrames.find((m) => m.type === "audio_done");
+    expect(audioDoneFrame).toBeDefined();
+  });
+
+  test("ClientSink tolerates ws.send throwing (closed socket)", () => {
+    let capturedClient!: ClientSink;
+    const ws = new MockWebSocket("ws://test");
+    ws.readyState = MockWebSocket.OPEN;
+
+    wireSessionSocket(ws, {
+      sessions: new Map(),
+      createSession: (_sid, client) => {
+        capturedClient = client;
+        return makeMockCore();
+      },
+      readyConfig: defaultConfig,
+      logger: silentLogger,
+    });
+
+    // Override send to throw
+    ws.send = () => {
+      throw new Error("socket closed");
+    };
+    // Should not throw
+    capturedClient.event({ type: "speech_started" });
+    capturedClient.playAudioChunk(new Uint8Array([1]));
+    capturedClient.playAudioDone();
+  });
+
+  // ─── Concurrency regression tests ────────────────────────────────────────
 
   test("close during start() does not double-stop or throw", async () => {
     let resolveStart!: () => void;
-    const session = makeStubSession();
-    session.start = vi.fn(
-      () =>
-        new Promise<void>((r) => {
-          resolveStart = r;
-        }),
-    );
+    const core = makeMockCore({
+      start: vi.fn(
+        () =>
+          new Promise<void>((r) => {
+            resolveStart = r;
+          }),
+      ),
+    });
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
-    const sessions = new Map<string, Session>();
+    const sessions = new Map<string, SessionCore>();
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger: silentLogger,
     });
@@ -568,25 +668,23 @@ describe("wireSessionSocket", () => {
     // Now start() resolves
     resolveStart();
     await vi.waitFor(() => {
-      expect(session.stop).toHaveBeenCalledOnce();
+      expect(core.stop).toHaveBeenCalledOnce();
     });
   });
 
   test("start() failure removes session from map before close", async () => {
-    const session = makeStubSession();
-    session.start = vi.fn(() => Promise.reject(new Error("boom")));
+    const core = makeMockCore({ start: vi.fn(() => Promise.reject(new Error("boom"))) });
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
-    const sessions = new Map<string, Session>();
+    const sessions = new Map<string, SessionCore>();
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger: silentLogger,
     });
 
-    // Wait for start() rejection to propagate
     await vi.waitFor(() => {
       expect(sessions.size).toBe(0);
     });
@@ -595,25 +693,25 @@ describe("wireSessionSocket", () => {
     ws.close();
   });
 
-  // ─── Session start timeout ─────────────────────────────────────────────
+  // ─── Session start timeout ────────────────────────────────────────────────
 
   test("session.start() timeout triggers 'Session start failed'", async () => {
-    const session = makeStubSession();
-    // start() never resolves — simulates a hanging S2S connection
-    session.start = vi.fn(
-      () =>
-        new Promise<void>(() => {
-          /* intentionally never resolves */
-        }),
-    );
+    const core = makeMockCore({
+      start: vi.fn(
+        () =>
+          new Promise<void>(() => {
+            /* intentionally never resolves */
+          }),
+      ),
+    });
 
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
-    const sessions = new Map<string, Session>();
+    const sessions = new Map<string, SessionCore>();
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger: silentLogger,
       sessionStartTimeoutMs: 50,
@@ -634,52 +732,34 @@ describe("wireSessionSocket", () => {
     );
   });
 
-  // ─── Socket not yet open ───────────────────────────────────────────────
+  // ─── Socket not yet open ──────────────────────────────────────────────────
 
   test("waits for open event when readyState is not OPEN", async () => {
-    const session = makeStubSession();
+    const core = makeMockCore();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.CONNECTING;
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger: silentLogger,
     });
 
     // Session not started yet — waiting for open
-    expect(session.start).not.toHaveBeenCalled();
+    expect(core.start).not.toHaveBeenCalled();
 
     // Simulate open
     ws.readyState = MockWebSocket.OPEN;
     ws.dispatchEvent(new Event("open"));
 
-    expect(session.start).toHaveBeenCalledOnce();
-  });
-
-  // ─── No session ignores messages ───────────────────────────────────────
-
-  test("messages before session is created are ignored", () => {
-    const ws = new MockWebSocket("ws://test");
-    ws.readyState = MockWebSocket.CONNECTING;
-
-    wireSessionSocket(ws, {
-      sessions: new Map(),
-      createSession: () => makeStubSession(),
-      readyConfig: defaultConfig,
-      logger: silentLogger,
-    });
-
-    // Send message before open — session is null, should be ignored
-    ws.simulateMessage(JSON.stringify({ type: "audio_ready" }));
-    // No error thrown
+    expect(core.start).toHaveBeenCalledOnce();
   });
 
-  // ─── Session resume ────────────────────────────────────────────────────
+  // ─── Session resume ───────────────────────────────────────────────────────
 
   test("resumeFrom reuses old session ID instead of generating new UUID", () => {
-    const sessions = new Map<string, Session>();
+    const sessions = new Map<string, SessionCore>();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
     let capturedId: string | undefined;
@@ -688,7 +768,7 @@ describe("wireSessionSocket", () => {
       sessions,
       createSession: (sid) => {
         capturedId = sid;
-        return makeStubSession();
+        return makeMockCore();
       },
       readyConfig: defaultConfig,
       logger: silentLogger,
@@ -699,24 +779,26 @@ describe("wireSessionSocket", () => {
     expect(sessions.has("old-session-abc")).toBeTruthy();
   });
 
-  test("config message includes resumed session ID", () => {
+  test("CONFIG frame contains resumed session ID as sessionId", () => {
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions: new Map(),
-      createSession: () => makeStubSession(),
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
       logger: silentLogger,
       resumeFrom: "resume-id-123",
     });
 
-    const config = ws.sentJson()[0];
-    expect(config).toMatchObject({ type: "config", sessionId: "resume-id-123" });
+    const firstFrame = ws.sent[0];
+    const msg = JSON.parse(firstFrame as string);
+    expect(msg.type).toBe("config");
+    expect(msg.sessionId).toBe("resume-id-123");
   });
 
   test("without resumeFrom, generates a new UUID session ID", () => {
-    const sessions = new Map<string, Session>();
+    const sessions = new Map<string, SessionCore>();
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
     let capturedId: string | undefined;
@@ -725,7 +807,7 @@ describe("wireSessionSocket", () => {
       sessions,
       createSession: (sid) => {
         capturedId = sid;
-        return makeStubSession();
+        return makeMockCore();
       },
       readyConfig: defaultConfig,
       logger: silentLogger,