@alexkroman1/aai 1.4.5 → 1.5.1

package/host/cleanup.test.ts

@@ -7,18 +7,10 @@
  * error, and reset to prevent memory leaks in long-running processes.
  */
 
-import { afterEach, describe, expect, test, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { MockWebSocket } from "./_mock-ws.ts";
-import {
-  makeClient,
-  makeMockHandle,
-  makeSessionOpts,
-  makeStubSession,
-  silentLogger,
-} from "./_test-utils.ts";
-import type { S2sHandle } from "./s2s.ts";
-import type { Session } from "./session.ts";
-import { _internals, createS2sSession, type S2sSessionOptions } from "./session.ts";
+import { makeMockCore, silentLogger } from "./_test-utils.ts";
+import type { SessionCore } from "./session-core.ts";
 import { wireSessionSocket } from "./ws-handler.ts";
 
 const defaultConfig = { audioFormat: "pcm16" as const, sampleRate: 16_000, ttsSampleRate: 24_000 };
@@ -27,13 +19,13 @@ const defaultConfig = { audioFormat: "pcm16" as const, sampleRate: 16_000, ttsSa
 
 describe("wireSessionSocket resource cleanup", () => {
   test("session.stop() is called exactly once on normal close", 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,
     });
@@ -41,21 +33,20 @@ describe("wireSessionSocket resource cleanup", () => {
     ws.close();
 
     await vi.waitFor(() => {
-      expect(session.stop).toHaveBeenCalledOnce();
+      expect(core.stop).toHaveBeenCalledOnce();
     });
   });
 
   test("session is removed from sessions map even when stop() rejects", async () => {
-    const sessions = new Map<string, Session>();
-    const session = makeStubSession();
-    session.stop = vi.fn(() => Promise.reject(new Error("stop failed")));
+    const sessions = new Map<string, SessionCore>();
+    const core = makeMockCore({ stop: vi.fn(() => Promise.reject(new Error("stop failed"))) });
 
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger: silentLogger,
     });
@@ -69,43 +60,42 @@ describe("wireSessionSocket resource cleanup", () => {
   });
 
   test("message buffer is cleared when start() fails", async () => {
-    const session = makeStubSession();
-    session.start = vi.fn(() => Promise.reject(new Error("start failed")));
-    const sessions = new Map<string, Session>();
+    const core = makeMockCore({ start: vi.fn(() => Promise.reject(new Error("start failed"))) });
+    const sessions = new Map<string, SessionCore>();
 
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger: silentLogger,
     });
 
-    // Send messages while start is failing
-    ws.simulateMessage(JSON.stringify({ type: "audio_ready" }));
+    // Send a binary frame while start is failing (string frames are now dropped as non-binary)
+    ws.simulateMessage(new ArrayBuffer(4));
 
     await vi.waitFor(() => {
       expect(sessions.size).toBe(0);
     });
 
     // Session is null, further messages should be silently ignored (no throw)
-    ws.simulateMessage(JSON.stringify({ type: "audio_ready" }));
     ws.simulateMessage(new ArrayBuffer(4));
   });
 
   test("multiple rapid closes don't double-invoke stop()", async () => {
-    const session = makeStubSession();
-    session.stop = vi.fn(() => new Promise<void>((r) => setTimeout(r, 50)));
-    const sessions = new Map<string, Session>();
+    const core = makeMockCore({
+      stop: vi.fn(() => new Promise<void>((r) => setTimeout(r, 50))),
+    });
+    const sessions = new Map<string, SessionCore>();
 
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.OPEN;
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => session,
+      createSession: () => core,
       readyConfig: defaultConfig,
       logger: silentLogger,
     });
@@ -115,18 +105,18 @@ describe("wireSessionSocket resource cleanup", () => {
     // Even if close event fires again, stop should only be called once
     // because the session reference is captured on first close
     await vi.waitFor(() => {
-      expect(session.stop).toHaveBeenCalledOnce();
+      expect(core.stop).toHaveBeenCalledOnce();
     });
   });
 
   test("close before open does not throw or leak", () => {
     const ws = new MockWebSocket("ws://test");
     ws.readyState = MockWebSocket.CONNECTING;
-    const sessions = new Map<string, Session>();
+    const sessions = new Map<string, SessionCore>();
 
     wireSessionSocket(ws, {
       sessions,
-      createSession: () => makeStubSession(),
+      createSession: () => makeMockCore(),
       readyConfig: defaultConfig,
       logger: silentLogger,
     });
@@ -137,286 +127,23 @@ describe("wireSessionSocket resource cleanup", () => {
   });
 
   test("error event after close does not throw", 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,
     });
 
     ws.close();
     await vi.waitFor(() => {
-      expect(session.stop).toHaveBeenCalled();
+      expect(core.stop).toHaveBeenCalled();
     });
 
     // Error after close should not throw
     ws.dispatchEvent(new Event("error"));
   });
 });
-
-// ─── createS2sSession cleanup tests ──────────────────────────────────────────
-
-describe("createS2sSession resource cleanup", () => {
-  let connectSpy: ReturnType<typeof vi.spyOn>;
-  let mockHandle: ReturnType<typeof makeMockHandle>;
-
-  function setup(overrides?: Partial<S2sSessionOptions>) {
-    mockHandle = makeMockHandle();
-    connectSpy = vi.spyOn(_internals, "connectS2s").mockResolvedValue(mockHandle);
-    const client = makeClient();
-    const opts = makeSessionOpts({ client, ...overrides });
-    const session = createS2sSession(opts);
-    return { session, client, opts, mockHandle };
-  }
-
-  afterEach(() => {
-    connectSpy?.mockRestore();
-  });
-
-  test("stop() closes S2S handle and waits for in-flight turn", async () => {
-    let resolveToolCall!: (value: string) => void;
-    const executeTool = vi.fn(
-      () =>
-        new Promise<string>((r) => {
-          resolveToolCall = r;
-        }),
-    );
-    const { session, mockHandle } = setup({ executeTool });
-    await session.start();
-
-    // Start a tool call
-    mockHandle._fire("replyStarted", { replyId: "r1" });
-    mockHandle._fire("event", { type: "tool_call", toolCallId: "c1", toolName: "t1", args: {} });
-    await vi.waitFor(() => expect(executeTool).toHaveBeenCalled());
-
-    // Stop while tool is in-flight
-    const stopPromise = session.stop();
-    resolveToolCall("done");
-    await stopPromise;
-
-    expect(mockHandle.close).toHaveBeenCalled();
-  });
-
-  test("onReset clears pendingTools and conversation messages", async () => {
-    const executeTool = vi.fn(async () => "result");
-    const { session, mockHandle } = setup({ executeTool });
-    await session.start();
-
-    // Accumulate some tool calls
-    mockHandle._fire("replyStarted", { replyId: "r1" });
-    mockHandle._fire("event", { type: "tool_call", toolCallId: "c1", toolName: "t1", args: {} });
-    await session.waitForTurn();
-
-    // Send a user transcript to add conversation messages
-    mockHandle._fire("event", { type: "user_transcript", text: "Hello" });
-
-    // Reset — should clear pending tools and conversation
-    session.onReset();
-
-    // Verify old handle was closed
-    expect(mockHandle.close).toHaveBeenCalled();
-  });
-
-  test("onReset invalidates currentReplyId to discard stale tool results", async () => {
-    let resolveToolCall!: (value: string) => void;
-    const executeTool = vi.fn(
-      () =>
-        new Promise<string>((r) => {
-          resolveToolCall = r;
-        }),
-    );
-    const handles: ReturnType<typeof makeMockHandle>[] = [];
-    const spy = vi.spyOn(_internals, "connectS2s").mockImplementation(async () => {
-      const h = makeMockHandle();
-      handles.push(h);
-      return h;
-    });
-
-    const client = makeClient();
-    const session = createS2sSession(makeSessionOpts({ client, executeTool }));
-    await session.start();
-
-    // biome-ignore lint/style/noNonNullAssertion: test assertions after length check
-    const firstHandle = handles[0]!;
-
-    // Start a tool call on the first handle
-    firstHandle._fire("replyStarted", { replyId: "r1" });
-    firstHandle._fire("event", { type: "tool_call", toolCallId: "c1", toolName: "t1", args: {} });
-    await vi.waitFor(() => expect(executeTool).toHaveBeenCalled());
-
-    // Reset while tool is in-flight
-    session.onReset();
-
-    // Tool finishes late — result should be discarded due to generation mismatch
-    resolveToolCall("stale-result");
-    await session.waitForTurn();
-
-    // New handle should not receive the stale result
-    const newHandle = handles[1];
-    expect(newHandle?.sendToolResult).not.toHaveBeenCalled();
-
-    spy.mockRestore();
-  });
-
-  test("stop() is safe to call without start()", async () => {
-    const client = makeClient();
-    const session = createS2sSession(makeSessionOpts({ client }));
-    // stop() without start() — should not throw
-    await session.stop();
-  });
-
-  test("stop() prevents orphaned S2S connection when called during start()", async () => {
-    let resolveConnect!: (value: S2sHandle) => void;
-    const handle = makeMockHandle();
-    const spy = vi.spyOn(_internals, "connectS2s").mockImplementation(
-      () =>
-        new Promise((r) => {
-          resolveConnect = r as (value: S2sHandle) => void;
-        }),
-    );
-
-    const client = makeClient();
-    const session = createS2sSession(makeSessionOpts({ client }));
-
-    const startPromise = session.start();
-    const stopPromise = session.stop();
-
-    // Connection resolves after stop — handle must be closed immediately
-    resolveConnect(handle);
-    await startPromise;
-    await stopPromise;
-
-    expect(handle.close).toHaveBeenCalled();
-    spy.mockRestore();
-  });
-
-  test("S2S error event closes handle and emits error to client", async () => {
-    const { session, client, mockHandle } = setup();
-    await session.start();
-
-    mockHandle._fire("error", new Error("S2S crashed"));
-
-    expect(mockHandle.close).toHaveBeenCalled();
-    expect(client.events).toContainEqual({
-      type: "error",
-      code: "internal",
-      message: "S2S crashed",
-    });
-  });
-
-  test("S2S close event nullifies the handle reference", async () => {
-    const { session, mockHandle } = setup();
-    await session.start();
-
-    // Simulate S2S WebSocket close
-    mockHandle._fire("close", 1000, "normal");
-
-    // Sending audio after close should not throw (no-ops via ?. on null s2s)
-    session.onAudio(new Uint8Array([1, 2, 3]));
-  });
-
-  test("sessionExpired event closes the S2S handle", async () => {
-    const { session, mockHandle } = setup();
-    await session.start();
-
-    mockHandle._fire("sessionExpired");
-    // The handler calls handle.close() directly
-    expect(mockHandle.close).toHaveBeenCalled();
-  });
-
-  test("rapid resets close all stale connections", async () => {
-    const handles: ReturnType<typeof makeMockHandle>[] = [];
-    const resolvers: ((h: S2sHandle) => void)[] = [];
-
-    const spy = vi.spyOn(_internals, "connectS2s").mockImplementation(
-      () =>
-        new Promise<S2sHandle>((resolve) => {
-          const h = makeMockHandle();
-          handles.push(h);
-          resolvers.push(resolve as (value: S2sHandle) => void);
-        }),
-    );
-
-    const client = makeClient();
-    const session = createS2sSession(makeSessionOpts({ client }));
-
-    const startPromise = session.start();
-    session.onReset();
-    session.onReset();
-
-    expect(resolvers.length).toBe(3);
-
-    // Resolve in order — first two are stale
-    // biome-ignore lint/style/noNonNullAssertion: test assertions after length check
-    resolvers[0]?.(handles[0]!);
-    // biome-ignore lint/style/noNonNullAssertion: test assertions after length check
-    resolvers[1]?.(handles[1]!);
-    // biome-ignore lint/style/noNonNullAssertion: test assertions after length check
-    resolvers[2]?.(handles[2]!);
-
-    await startPromise;
-
-    await vi.waitFor(() => {
-      expect(handles[0]?.close).toHaveBeenCalled();
-      expect(handles[1]?.close).toHaveBeenCalled();
-    });
-    expect(handles[2]?.close).not.toHaveBeenCalled();
-
-    spy.mockRestore();
-  });
-
-  test("concurrent tool calls all complete before stop() resolves", async () => {
-    const resolvers: ((value: string) => void)[] = [];
-    const executeTool = vi.fn(
-      () =>
-        new Promise<string>((r) => {
-          resolvers.push(r);
-        }),
-    );
-    const { session, mockHandle } = setup({ executeTool });
-    await session.start();
-
-    mockHandle._fire("replyStarted", { replyId: "r1" });
-    mockHandle._fire("event", { type: "tool_call", toolCallId: "c1", toolName: "t1", args: {} });
-    mockHandle._fire("event", { type: "tool_call", toolCallId: "c2", toolName: "t2", args: {} });
-
-    await vi.waitFor(() => expect(executeTool).toHaveBeenCalledTimes(2));
-
-    // Stop while both tools are in-flight
-    const stopPromise = session.stop();
-
-    // Resolve both tools
-    resolvers[0]?.("result-1");
-    resolvers[1]?.("result-2");
-
-    await stopPromise;
-    // If we get here, turnPromise was properly awaited
-    expect(mockHandle.close).toHaveBeenCalled();
-  });
-
-  test("connectS2s failure does not leak resources", async () => {
-    const spy = vi.spyOn(_internals, "connectS2s").mockRejectedValue(new Error("network error"));
-    const client = makeClient();
-    const session = createS2sSession(makeSessionOpts({ client }));
-
-    await session.start();
-
-    // Client should get error event
-    expect(client.events).toContainEqual(
-      expect.objectContaining({
-        type: "error",
-        code: "internal",
-        message: "network error",
-      }),
-    );
-
-    // stop() should not throw even after failed start
-    await session.stop();
-
-    spy.mockRestore();
-  });
-});

package/host/integration/pipeline-reference.integration.test.ts

@@ -24,11 +24,10 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { openai } from "@ai-sdk/openai";
 import { describe, expect, test } from "vitest";
-import type { AgentConfig, ExecuteTool } from "../../sdk/_internal-types.ts";
-import type { ClientEvent, ClientSink } from "../../sdk/protocol.ts";
-import { createPipelineSession } from "../pipeline-session.ts";
+import type { ClientSink } from "../../sdk/protocol.ts";
 import { openAssemblyAI } from "../providers/stt/assemblyai.ts";
 import { openCartesia } from "../providers/tts/cartesia.ts";
+import { createRuntime } from "../runtime.ts";
 import { consoleLogger } from "../runtime-config.ts";
 
 const here = dirname(fileURLToPath(import.meta.url));
@@ -59,47 +58,48 @@ describe.skipIf(!envReady)("pipeline integration — reference stack", () => {
       );
     }
     const pcm = await readFile(fixturePath);
-    const events: ClientEvent[] = [];
+    const userTranscripts: string[] = [];
     const audioOut: Uint8Array[] = [];
+    let replyDone = false;
+
     const client: ClientSink = {
       open: true,
       event: (e) => {
-        events.push(e);
+        if (e.type === "user_transcript") userTranscripts.push(e.text);
+        if (e.type === "reply_done") replyDone = true;
       },
       playAudioChunk: (chunk) => {
         audioOut.push(chunk);
       },
-      playAudioDone: () => {
-        /* no-op: test asserts on audioOut chunks directly */
-      },
-    };
-
-    const agentConfig: AgentConfig = {
-      name: "int",
-      systemPrompt: "You reply in one short sentence.",
-      greeting: "",
-      maxSteps: 1,
+      playAudioDone: () => undefined,
     };
 
-    const executeTool: ExecuteTool = async () => "";
-
-    const session = createPipelineSession({
-      id: "int-1",
-      agent: "pipeline-reference",
-      client,
-      agentConfig,
-      toolSchemas: [],
-      executeTool,
+    const runtime = createRuntime({
+      agent: {
+        name: "int",
+        systemPrompt: "You reply in one short sentence.",
+        greeting: "",
+        maxSteps: 1,
+        tools: {},
+      },
+      env: {
+        // biome-ignore lint/style/noNonNullAssertion: envReady guard ensures presence
+        ASSEMBLYAI_API_KEY: process.env.ASSEMBLYAI_API_KEY!,
+        // biome-ignore lint/style/noNonNullAssertion: envReady guard ensures presence
+        CARTESIA_API_KEY: process.env.CARTESIA_API_KEY!,
+      },
       stt: openAssemblyAI({ model: "u3pro-rt" }),
       llm: openai("gpt-4o-mini"),
       tts: openCartesia({ voice: "694f9389-aac1-45b6-b726-9d9369183238" }),
-      // biome-ignore lint/style/noNonNullAssertion: envReady guard ensures presence
-      sttApiKey: process.env.ASSEMBLYAI_API_KEY!,
-      // biome-ignore lint/style/noNonNullAssertion: envReady guard ensures presence
-      ttsApiKey: process.env.CARTESIA_API_KEY!,
       logger: consoleLogger,
     });
 
+    const session = runtime.createSession({
+      id: "int-1",
+      agent: "pipeline-reference",
+      client,
+    });
+
     await session.start();
     session.onAudioReady();
 
@@ -110,15 +110,10 @@ describe.skipIf(!envReady)("pipeline integration — reference stack", () => {
       session.onAudio(new Uint8Array(chunk));
       await new Promise((r) => setTimeout(r, 100));
     }
-    await session.waitForTurn();
     await session.stop();
 
-    const userTranscript = events.find((e) => e.type === "user_transcript");
-    expect(userTranscript).toBeDefined();
-    expect(String((userTranscript as { text: string }).text).toLowerCase()).toContain(
-      "how are you",
-    );
-    expect(events.some((e) => e.type === "reply_done")).toBe(true);
+    expect(userTranscripts.some((t) => t.toLowerCase().includes("how are you"))).toBe(true);
+    expect(replyDone).toBe(true);
     expect(audioOut.length).toBeGreaterThan(0);
   }, 60_000);
 });

package/host/providers/resolve.ts

@@ -17,7 +17,9 @@ import { createAnthropic } from "@ai-sdk/anthropic";
 import type { LanguageModel } from "ai";
 import { ANTHROPIC_KIND, type AnthropicOptions } from "../../sdk/providers/llm/anthropic.ts";
 import { ASSEMBLYAI_KIND, type AssemblyAIOptions } from "../../sdk/providers/stt/assemblyai.ts";
+import { DEEPGRAM_KIND, type DeepgramOptions } from "../../sdk/providers/stt/deepgram.ts";
 import { CARTESIA_KIND, type CartesiaOptions } from "../../sdk/providers/tts/cartesia.ts";
+import { RIME_KIND, type RimeOptions } from "../../sdk/providers/tts/rime.ts";
 import type {
   LlmProvider,
   SttOpener,
@@ -26,7 +28,9 @@ import type {
   TtsProvider,
 } from "../../sdk/providers.ts";
 import { openAssemblyAI } from "./stt/assemblyai.ts";
+import { openDeepgram } from "./stt/deepgram.ts";
 import { openCartesia } from "./tts/cartesia.ts";
+import { openRime } from "./tts/rime.ts";
 
 /**
  * Look up a provider API key: agent env first (set via `aai secret put` or
@@ -42,9 +46,11 @@ export function resolveStt(descriptor: SttProvider): SttOpener {
   switch (descriptor.kind) {
     case ASSEMBLYAI_KIND:
       return openAssemblyAI(descriptor.options as unknown as AssemblyAIOptions);
+    case DEEPGRAM_KIND:
+      return openDeepgram(descriptor.options as unknown as DeepgramOptions);
     default:
       throw new Error(
-        `Unknown STT provider kind: "${descriptor.kind}". Supported: ${ASSEMBLYAI_KIND}.`,
+        `Unknown STT provider kind: "${descriptor.kind}". Supported: ${ASSEMBLYAI_KIND}, ${DEEPGRAM_KIND}.`,
       );
   }
 }
@@ -54,9 +60,11 @@ export function resolveTts(descriptor: TtsProvider): TtsOpener {
   switch (descriptor.kind) {
     case CARTESIA_KIND:
       return openCartesia(descriptor.options as unknown as CartesiaOptions);
+    case RIME_KIND:
+      return openRime(descriptor.options as unknown as RimeOptions);
     default:
       throw new Error(
-        `Unknown TTS provider kind: "${descriptor.kind}". Supported: ${CARTESIA_KIND}.`,
+        `Unknown TTS provider kind: "${descriptor.kind}". Supported: ${CARTESIA_KIND}, ${RIME_KIND}.`,
       );
   }
 }