@alexkroman1/aai 1.7.1 → 1.8.0

package/host/providers/resolve.ts

@@ -56,17 +56,21 @@ export function resolveApiKey(envVar: string, env: Record<string, string>): stri
   return env[envVar] ?? process.env[envVar] ?? "";
 }
 
+function options<T>(descriptor: { options: Record<string, unknown> }): T {
+  return descriptor.options as unknown as T;
+}
+
 /** Resolve an {@link SttProvider} descriptor into a host-side opener. */
 export function resolveStt(descriptor: SttProvider): SttOpener {
   switch (descriptor.kind) {
     case ASSEMBLYAI_KIND:
-      return openAssemblyAI(descriptor.options as unknown as AssemblyAIOptions);
+      return openAssemblyAI(options<AssemblyAIOptions>(descriptor));
     case DEEPGRAM_KIND:
-      return openDeepgram(descriptor.options as unknown as DeepgramOptions);
+      return openDeepgram(options<DeepgramOptions>(descriptor));
     case ELEVENLABS_KIND:
-      return openElevenLabs(descriptor.options as unknown as ElevenLabsOptions);
+      return openElevenLabs(options<ElevenLabsOptions>(descriptor));
     case SONIOX_KIND:
-      return openSoniox(descriptor.options as unknown as SonioxOptions);
+      return openSoniox(options<SonioxOptions>(descriptor));
     default:
       throw new Error(
         `Unknown STT provider kind: "${descriptor.kind}". ` +
@@ -79,9 +83,9 @@ export function resolveStt(descriptor: SttProvider): SttOpener {
 export function resolveTts(descriptor: TtsProvider): TtsOpener {
   switch (descriptor.kind) {
     case CARTESIA_KIND:
-      return openCartesia(descriptor.options as unknown as CartesiaOptions);
+      return openCartesia(options<CartesiaOptions>(descriptor));
     case RIME_KIND:
-      return openRime(descriptor.options as unknown as RimeOptions);
+      return openRime(options<RimeOptions>(descriptor));
     default:
       throw new Error(
         `Unknown TTS provider kind: "${descriptor.kind}". Supported: ${CARTESIA_KIND}, ${RIME_KIND}.`,
@@ -105,30 +109,28 @@ export function resolveLlm(descriptor: LlmProvider, env: Record<string, string>)
       // before reading process.env["ANTHROPIC_BASE_URL"]. Without this,
       // the Deno platform server needs --allow-env to start a session.
       return createAnthropic({ apiKey, baseURL: "https://api.anthropic.com/v1" })(
-        (descriptor.options as unknown as AnthropicOptions).model,
+        options<AnthropicOptions>(descriptor).model,
       );
     }
     case OPENAI_KIND: {
       const apiKey = requireKey(env, "OPENAI_API_KEY", "OpenAI");
-      return createOpenAI({ apiKey })((descriptor.options as unknown as OpenAIOptions).model);
+      return createOpenAI({ apiKey })(options<OpenAIOptions>(descriptor).model);
     }
     case GOOGLE_KIND: {
       const apiKey = requireKey(env, "GOOGLE_GENERATIVE_AI_API_KEY", "Google");
-      return createGoogleGenerativeAI({ apiKey })(
-        (descriptor.options as unknown as GoogleOptions).model,
-      );
+      return createGoogleGenerativeAI({ apiKey })(options<GoogleOptions>(descriptor).model);
     }
     case MISTRAL_KIND: {
       const apiKey = requireKey(env, "MISTRAL_API_KEY", "Mistral");
-      return createMistral({ apiKey })((descriptor.options as unknown as MistralOptions).model);
+      return createMistral({ apiKey })(options<MistralOptions>(descriptor).model);
     }
     case XAI_KIND: {
       const apiKey = requireKey(env, "XAI_API_KEY", "xAI");
-      return createXai({ apiKey })((descriptor.options as unknown as XaiOptions).model);
+      return createXai({ apiKey })(options<XaiOptions>(descriptor).model);
     }
     case GROQ_KIND: {
       const apiKey = requireKey(env, "GROQ_API_KEY", "Groq");
-      return createGroq({ apiKey })((descriptor.options as unknown as GroqOptions).model);
+      return createGroq({ apiKey })(options<GroqOptions>(descriptor).model);
     }
     default:
       throw new Error(
@@ -151,17 +153,15 @@ export function loadProviderPackage<T>(name: string, label: string): T {
   try {
     return requireFromHere(name) as T;
   } catch (err) {
-    if (
+    const code = (err as NodeJS.ErrnoException | undefined)?.code;
+    const isMissing =
       err instanceof Error &&
-      ((err as NodeJS.ErrnoException).code === "MODULE_NOT_FOUND" ||
-        (err as NodeJS.ErrnoException).code === "ERR_MODULE_NOT_FOUND") &&
-      err.message.includes(name)
-    ) {
-      throw new Error(`${label}: package \`${name}\` is not installed. Run \`pnpm add ${name}\`.`, {
-        cause: err,
-      });
-    }
-    throw err;
+      (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") &&
+      err.message.includes(name);
+    if (!isMissing) throw err;
+    throw new Error(`${label}: package \`${name}\` is not installed. Run \`pnpm add ${name}\`.`, {
+      cause: err,
+    });
   }
 }
 

package/host/providers/stt/assemblyai.test.ts

@@ -11,15 +11,6 @@ import { type AssemblyAISession, openAssemblyAI } from "./assemblyai.ts";
 
 const here = dirname(fileURLToPath(import.meta.url));
 
-// ---------------------------------------------------------------------------
-// Mock the `assemblyai` SDK so no real sockets are opened.
-//
-// Each fake `StreamingTranscriber` keeps its own listener map and exposes
-// `_fire(event, payload)` for tests to inject events. The adapter's
-// `open()` returns an `AssemblyAISession` with a `_transcriber` pointer,
-// which in the test is the fake — giving the test a handle to `_fire`.
-// ---------------------------------------------------------------------------
-
 interface FakeTranscriber {
   on(ev: string, fn: (...args: unknown[]) => void): void;
   connect(): Promise<void>;
@@ -29,7 +20,7 @@ interface FakeTranscriber {
 }
 
 vi.mock("assemblyai", () => {
-  const makeFakeTranscriber = (): FakeTranscriber => {
+  function makeFakeTranscriber(): FakeTranscriber {
     const listeners = new Map<string, Array<(...args: unknown[]) => void>>();
     return {
       on(ev, fn) {
@@ -50,7 +41,7 @@ vi.mock("assemblyai", () => {
         for (const fn of listeners.get(ev) ?? []) fn(...args);
       },
     };
-  };
+  }
   return {
     AssemblyAI: class {
       streaming = {
@@ -81,9 +72,6 @@ describe("assemblyAI STT adapter — fixture replay", () => {
     session.on("final", (t) => finals.push(t));
     session.on("error", (e) => errors.push(e.message));
 
-    // Replay fixture through the fake transcriber. The JSON's "type" field
-    // distinguishes Begin from Turn; we only dispatch turn messages since
-    // Begin is consumed inside `connect()` by the real SDK.
     const fake = session._transcriber as unknown as FakeTranscriber;
     for (const msg of fixture) {
       if (msg.type === "Turn") fake._fire("turn", msg as TurnEvent);

package/host/providers/stt/assemblyai.ts

@@ -1,16 +1,4 @@
 // Copyright 2025 the AAI authors. MIT license.
-/**
- * AssemblyAI Universal-Streaming STT opener (host-only).
- *
- * The user-facing descriptor factory (`assemblyAI(...)`) lives in
- * `sdk/providers/stt/assemblyai.ts`. This module is the host-side
- * counterpart: it takes the descriptor options + an API key and
- * returns an {@link SttOpener} that the pipeline session drives.
- *
- * Default model: `"u3pro-rt"` (Universal-3 Pro Real-Time). The adapter
- * maps that to the SDK's `"u3-rt-pro"` `speechModel` value; any other
- * string is forwarded verbatim.
- */
 
 import { AssemblyAI, type StreamingTranscriber } from "assemblyai";
 import { createNanoEvents, type Emitter } from "nanoevents";
@@ -23,20 +11,16 @@ import {
   type SttSession,
 } from "../../../sdk/providers.ts";
 
-/** Internal: SttSession with a test-only handle to the raw SDK transcriber. */
 export interface AssemblyAISession extends SttSession {
   /** @internal Test-only: exposes the underlying SDK transcriber for fixture replay. */
   readonly _transcriber: StreamingTranscriber;
 }
 
-/** Translate the descriptor's model alias to the SDK's `speechModel` value. */
 function resolveSpeechModel(model: string): string {
   // Plan's public name is "u3pro-rt"; the SDK's enum uses "u3-rt-pro".
-  if (model === "u3pro-rt") return "u3-rt-pro";
-  return model;
+  return model === "u3pro-rt" ? "u3-rt-pro" : model;
 }
 
-/** Build an {@link SttOpener} from resolved AssemblyAI descriptor options. */
 export function openAssemblyAI(opts: AssemblyAIOptions = {}): SttOpener {
   return {
     name: "assemblyai",
@@ -53,8 +37,7 @@ export function openAssemblyAI(opts: AssemblyAIOptions = {}): SttOpener {
       const speechModel = resolveSpeechModel(opts.model ?? "u3pro-rt");
       const transcriber = client.streaming.transcriber({
         sampleRate: openOpts.sampleRate,
-        // The SDK types `speechModel` as a string-literal union; the adapter
-        // accepts `string` as an escape hatch, so cast at the boundary.
+        // SDK types `speechModel` as a string-literal union; accept `string` here.
         speechModel: speechModel as never,
         ...(openOpts.sttPrompt ? { prompt: openOpts.sttPrompt } : {}),
       });
@@ -65,11 +48,8 @@ export function openAssemblyAI(opts: AssemblyAIOptions = {}): SttOpener {
       transcriber.on("turn", (event) => {
         if (closed) return;
         const text = event.transcript ?? "";
-        if (event.end_of_turn) {
-          if (text.length > 0) emitter.emit("final", text);
-        } else if (text.length > 0) {
-          emitter.emit("partial", text);
-        }
+        if (text.length === 0) return;
+        emitter.emit(event.end_of_turn ? "final" : "partial", text);
       });
 
       transcriber.on("error", (err) => {
@@ -78,11 +58,8 @@ export function openAssemblyAI(opts: AssemblyAIOptions = {}): SttOpener {
       });
 
       transcriber.on("close", (code) => {
-        if (closed) return;
-        // 1000 = normal closure.
-        if (code !== 1000) {
-          emitter.emit("error", makeSttError("stt_stream_error", `socket closed ${code}`));
-        }
+        if (closed || code === 1000) return;
+        emitter.emit("error", makeSttError("stt_stream_error", `socket closed ${code}`));
       });
 
       try {
@@ -100,23 +77,23 @@ export function openAssemblyAI(opts: AssemblyAIOptions = {}): SttOpener {
         try {
           await transcriber.close();
         } catch {
-          // Swallow: the caller has already decided to tear down.
+          // Caller is tearing down; nothing to do on close failure.
         }
       };
 
       if (openOpts.signal.aborted) {
         void close();
       } else {
-        openOpts.signal.addEventListener("abort", () => void close(), {
-          once: true,
-        });
+        openOpts.signal.addEventListener("abort", () => void close(), { once: true });
       }
 
       const session: AssemblyAISession = {
         sendAudio(pcm: Int16Array) {
           if (closed) return;
-          const copy = new Uint8Array(pcm.byteLength);
-          copy.set(new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+          // Copy: caller may reuse `pcm`'s backing buffer for the next chunk.
+          const copy = new Uint8Array(
+            pcm.buffer.slice(pcm.byteOffset, pcm.byteOffset + pcm.byteLength),
+          );
           transcriber.sendAudio(copy.buffer);
         },
         on(event, fn) {

package/host/providers/stt/deepgram.test.ts

@@ -1,20 +1,9 @@
 // Copyright 2026 the AAI authors. MIT license.
-/** Unit test for the Deepgram STT adapter (mocked SDK). */
 
 import { describe, expect, test, vi } from "vitest";
 import { flush } from "../../_test-utils.ts";
 import { type DeepgramSession, openDeepgram } from "./deepgram.ts";
 
-// ---------------------------------------------------------------------------
-// Mock the `@deepgram/sdk` so no real sockets are opened.
-//
-// Each fake `V1Socket` keeps one listener per event (matching the real SDK's
-// `on()` which replaces rather than appends) and exposes `_fire(event, data)`
-// for tests to inject events. The adapter's `open()` returns a
-// `DeepgramSession` with a `_connection` pointer (which in tests is the fake)
-// giving the test a handle to `_fire`.
-// ---------------------------------------------------------------------------
-
 interface FakeSocket {
   on(ev: string, fn: (...args: unknown[]) => void): void;
   connect(): FakeSocket;
@@ -26,17 +15,17 @@ interface FakeSocket {
 
 vi.mock("@deepgram/sdk", () => {
   const makeFakeSocket = (): FakeSocket => {
+    // V1Socket replaces — not appends — the listener per event.
     const listeners = new Map<string, (...args: unknown[]) => void>();
     const fake: FakeSocket = {
       on(ev, fn) {
-        // V1Socket replaces — not appends — the listener per event.
         listeners.set(ev, fn);
       },
       connect() {
         return fake;
       },
       async waitForOpen() {
-        // Immediately resolves in tests.
+        /* no-op */
       },
       close() {
         /* no-op */
@@ -45,8 +34,7 @@ vi.mock("@deepgram/sdk", () => {
         /* no-op */
       },
       _fire(ev, ...args) {
-        const fn = listeners.get(ev);
-        if (fn) fn(...args);
+        listeners.get(ev)?.(...args);
       },
     };
     return fake;
@@ -63,10 +51,6 @@ vi.mock("@deepgram/sdk", () => {
   };
 });
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
 function makeResult(transcript: string, isFinal: boolean) {
   return {
     type: "Results" as const,
@@ -79,44 +63,40 @@ function makeResult(transcript: string, isFinal: boolean) {
   };
 }
 
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
+async function openSession(
+  args: Parameters<typeof openDeepgram>[0] = {},
+): Promise<{ session: DeepgramSession; fake: FakeSocket }> {
+  const opener = openDeepgram(args);
+  const session = (await opener.open({
+    sampleRate: 16_000,
+    apiKey: "test-key",
+    signal: new AbortController().signal,
+  })) as DeepgramSession;
+  return { session, fake: session._connection as unknown as FakeSocket };
+}
 
 describe("Deepgram STT adapter", () => {
   test("openDeepgram({}) returns an opener with name 'deepgram'", () => {
-    const opener = openDeepgram({});
-    expect(opener.name).toBe("deepgram");
+    expect(openDeepgram({}).name).toBe("deepgram");
   });
 
   test("throws stt_auth_failed when API key is missing", async () => {
-    // Clear env var for this test.
     const saved = process.env.DEEPGRAM_API_KEY;
     delete process.env.DEEPGRAM_API_KEY;
 
     const opener = openDeepgram({});
-    const controller = new AbortController();
-
     await expect(
-      opener.open({ sampleRate: 16_000, apiKey: "", signal: controller.signal }),
+      opener.open({ sampleRate: 16_000, apiKey: "", signal: new AbortController().signal }),
     ).rejects.toMatchObject({ code: "stt_auth_failed" });
 
     process.env.DEEPGRAM_API_KEY = saved;
   });
 
   test("final transcript fires 'final' event with text", async () => {
-    const opener = openDeepgram({ model: "nova-3" });
-    const controller = new AbortController();
-    const session = (await opener.open({
-      sampleRate: 16_000,
-      apiKey: "test-key",
-      signal: controller.signal,
-    })) as DeepgramSession;
-
+    const { session, fake } = await openSession({ model: "nova-3" });
     const finals: string[] = [];
     session.on("final", (t) => finals.push(t));
 
-    const fake = session._connection as unknown as FakeSocket;
     fake._fire("message", makeResult("hello world", true));
 
     await flush();
@@ -126,18 +106,10 @@ describe("Deepgram STT adapter", () => {
   });
 
   test("interim transcript fires 'partial' event with text", async () => {
-    const opener = openDeepgram({ model: "nova-3" });
-    const controller = new AbortController();
-    const session = (await opener.open({
-      sampleRate: 16_000,
-      apiKey: "test-key",
-      signal: controller.signal,
-    })) as DeepgramSession;
-
+    const { session, fake } = await openSession({ model: "nova-3" });
     const partials: string[] = [];
     session.on("partial", (t) => partials.push(t));
 
-    const fake = session._connection as unknown as FakeSocket;
     fake._fire("message", makeResult("hel", false));
     fake._fire("message", makeResult("hello", false));
 
@@ -148,21 +120,12 @@ describe("Deepgram STT adapter", () => {
   });
 
   test("empty transcript is NOT emitted (neither partial nor final)", async () => {
-    const opener = openDeepgram({});
-    const controller = new AbortController();
-    const session = (await opener.open({
-      sampleRate: 16_000,
-      apiKey: "test-key",
-      signal: controller.signal,
-    })) as DeepgramSession;
-
+    const { session, fake } = await openSession();
     const partials: string[] = [];
     const finals: string[] = [];
     session.on("partial", (t) => partials.push(t));
     session.on("final", (t) => finals.push(t));
 
-    const fake = session._connection as unknown as FakeSocket;
-    // Fire results with empty transcript — neither should be emitted.
     fake._fire("message", makeResult("", false));
     fake._fire("message", makeResult("", true));
 
@@ -174,24 +137,13 @@ describe("Deepgram STT adapter", () => {
   });
 
   test("close fires close() and subsequent events are ignored (no double-close crash)", async () => {
-    const opener = openDeepgram({});
-    const controller = new AbortController();
-    const session = (await opener.open({
-      sampleRate: 16_000,
-      apiKey: "test-key",
-      signal: controller.signal,
-    })) as DeepgramSession;
-
+    const { session, fake } = await openSession();
     const finals: string[] = [];
     session.on("final", (t) => finals.push(t));
 
     await session.close();
-
-    // Subsequent close should not throw.
     await session.close();
 
-    // Events after close should be dropped.
-    const fake = session._connection as unknown as FakeSocket;
     fake._fire("message", makeResult("should be ignored", true));
 
     await flush();
@@ -199,15 +151,7 @@ describe("Deepgram STT adapter", () => {
   });
 
   test("sendAudio(Int16Array) forwards PCM bytes to the connection", async () => {
-    const opener = openDeepgram({});
-    const controller = new AbortController();
-    const session = (await opener.open({
-      sampleRate: 16_000,
-      apiKey: "test-key",
-      signal: controller.signal,
-    })) as DeepgramSession;
-
-    const fake = session._connection as unknown as FakeSocket;
+    const { session, fake } = await openSession();
     const sent: ArrayBufferView[] = [];
     fake.sendMedia = (data: ArrayBufferView) => sent.push(data);
 
@@ -215,12 +159,8 @@ describe("Deepgram STT adapter", () => {
     session.sendAudio(pcm);
 
     expect(sent).toHaveLength(1);
-    // The sent buffer should contain the same bytes as the Int16Array.
-    const sentBytes = new Uint8Array(
-      (sent[0] as Uint8Array).buffer,
-      (sent[0] as Uint8Array).byteOffset,
-      (sent[0] as Uint8Array).byteLength,
-    );
+    const sentView = sent[0] as Uint8Array;
+    const sentBytes = new Uint8Array(sentView.buffer, sentView.byteOffset, sentView.byteLength);
     const expectedBytes = new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength);
     expect(sentBytes).toEqual(expectedBytes);
 

package/host/providers/stt/deepgram.ts

@@ -2,18 +2,8 @@
 /**
  * Deepgram Nova streaming STT opener (host-only).
  *
- * The user-facing descriptor factory (`deepgram(...)`) lives in
- * `sdk/providers/stt/deepgram.ts`. This module is the host-side
- * counterpart: it takes the descriptor options + an API key and
- * returns an {@link SttOpener} that the pipeline session drives.
- *
- * Default model: `"nova-3"`. Any string is forwarded verbatim to the SDK.
- *
- * This adapter targets the Deepgram SDK v5 (`@deepgram/sdk@^5`). The v5
- * streaming API is:
- *   `client.listen.v1.connect(args)` → `Promise<V1Socket>`
- * followed by:
- *   `socket.connect()` + `socket.waitForOpen()` to establish the connection.
+ * Targets Deepgram SDK v5: `client.listen.v1.connect(args)` returns a
+ * socket; `socket.connect()` + `socket.waitForOpen()` establish it.
  */
 
 import { DeepgramClient, type listen } from "@deepgram/sdk";
@@ -27,10 +17,8 @@ import {
   type SttSession,
 } from "../../../sdk/providers.ts";
 
-// V1Socket type from the Deepgram SDK (accessed through the listen namespace).
 type V1Socket = Awaited<ReturnType<InstanceType<typeof DeepgramClient>["listen"]["v1"]["connect"]>>;
 
-/** Internal: SttSession with a test-only handle to the raw SDK socket. */
 export interface DeepgramSession extends SttSession {
   /** @internal Test-only: exposes the underlying SDK socket for fixture replay. */
   readonly _connection: V1Socket;
@@ -42,23 +30,17 @@ type MessagePayload =
   | listen.ListenV1UtteranceEnd
   | listen.ListenV1SpeechStarted;
 
-/**
- * Handle an incoming Deepgram transcript message, emitting `partial` or
- * `final` events on the emitter. Empty transcripts are silently dropped.
- */
+function errMsg(cause: unknown): string {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+
 function handleMessage(data: MessagePayload, closed: boolean, emitter: Emitter<SttEvents>): void {
-  if (closed) return;
-  if (data.type !== "Results") return;
-  const result = data as listen.ListenV1Results;
-  const text = result.channel?.alternatives?.[0]?.transcript ?? "";
-  if (result.is_final) {
-    if (text.length > 0) emitter.emit("final", text);
-  } else if (text.length > 0) {
-    emitter.emit("partial", text);
-  }
+  if (closed || data.type !== "Results") return;
+  const text = data.channel?.alternatives?.[0]?.transcript ?? "";
+  if (text.length === 0) return;
+  emitter.emit(data.is_final ? "final" : "partial", text);
 }
 
-/** Wire Deepgram socket events onto the nanoevents emitter. */
 function wireSocketEvents(
   connection: V1Socket,
   emitter: Emitter<SttEvents>,
@@ -79,16 +61,14 @@ function wireSocketEvents(
   });
 }
 
-/** Wire the AbortSignal to the close function. */
 function wireAbortSignal(signal: AbortSignal, close: () => Promise<void>): void {
   if (signal.aborted) {
     void close();
-  } else {
-    signal.addEventListener("abort", () => void close(), { once: true });
+    return;
   }
+  signal.addEventListener("abort", () => void close(), { once: true });
 }
 
-/** Build an {@link SttOpener} from resolved Deepgram descriptor options. */
 export function openDeepgram(opts: DeepgramOptions = {}): SttOpener {
   return {
     name: "deepgram",
@@ -119,10 +99,7 @@ export function openDeepgram(opts: DeepgramOptions = {}): SttOpener {
           Authorization: apiKey,
         });
       } catch (cause) {
-        throw makeSttError(
-          "stt_connect_failed",
-          `Deepgram STT: connect failed: ${cause instanceof Error ? cause.message : String(cause)}`,
-        );
+        throw makeSttError("stt_connect_failed", `Deepgram STT: connect failed: ${errMsg(cause)}`);
       }
 
       const emitter: Emitter<SttEvents> = createNanoEvents<SttEvents>();
@@ -130,15 +107,13 @@ export function openDeepgram(opts: DeepgramOptions = {}): SttOpener {
 
       wireSocketEvents(connection, emitter, () => closed);
 
-      // Actually open the WebSocket connection (registers internal handlers
-      // and initiates the TCP/TLS handshake).
       connection.connect();
       try {
         await connection.waitForOpen();
       } catch (cause) {
         throw makeSttError(
           "stt_connect_failed",
-          `Deepgram STT: WebSocket open failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+          `Deepgram STT: WebSocket open failed: ${errMsg(cause)}`,
         );
       }
 
@@ -148,7 +123,7 @@ export function openDeepgram(opts: DeepgramOptions = {}): SttOpener {
         try {
           connection.close();
         } catch {
-          // Swallow: the caller has already decided to tear down.
+          // Caller already decided to tear down.
         }
       };
 

package/host/providers/stt/elevenlabs.test.ts

@@ -5,14 +5,6 @@ import { describe, expect, test, vi } from "vitest";
 import { flush } from "../../_test-utils.ts";
 import { openElevenLabs } from "./elevenlabs.ts";
 
-// ---------------------------------------------------------------------------
-// Mock the @elevenlabs/elevenlabs-js realtime client so no real sockets open.
-//
-// The fake connection keeps one listener per RealtimeEvents value (the SDK's
-// EventEmitter API allows multiple, but for simple unit tests one is enough)
-// and exposes `_fire` for tests to inject events.
-// ---------------------------------------------------------------------------
-
 interface FakeConnection {
   on(ev: string, fn: (data: unknown) => void): void;
   send(_: { audioBase64: string }): void;
@@ -22,36 +14,33 @@ interface FakeConnection {
 
 const captured: { connections: FakeConnection[] } = { connections: [] };
 
-vi.mock("@elevenlabs/elevenlabs-js", () => {
-  return {
-    ElevenLabsClient: class {
-      speechToText = {
-        realtime: {
-          connect: async (_opts: unknown): Promise<FakeConnection> => {
-            const listeners = new Map<string, (data: unknown) => void>();
-            const conn: FakeConnection = {
-              on(ev, fn) {
-                listeners.set(ev, fn);
-              },
-              send() {
-                /* no-op */
-              },
-              close() {
-                /* no-op */
-              },
-              _fire(ev, data) {
-                const fn = listeners.get(ev);
-                if (fn) fn(data);
-              },
-            };
-            captured.connections.push(conn);
-            return conn;
-          },
+vi.mock("@elevenlabs/elevenlabs-js", () => ({
+  ElevenLabsClient: class {
+    speechToText = {
+      realtime: {
+        connect: async (_opts: unknown): Promise<FakeConnection> => {
+          const listeners = new Map<string, (data: unknown) => void>();
+          const conn: FakeConnection = {
+            on(ev, fn) {
+              listeners.set(ev, fn);
+            },
+            send() {
+              /* no-op */
+            },
+            close() {
+              /* no-op */
+            },
+            _fire(ev, data) {
+              listeners.get(ev)?.(data);
+            },
+          };
+          captured.connections.push(conn);
+          return conn;
         },
-      };
-    },
-  };
-});
+      },
+    };
+  },
+}));
 
 vi.mock("@elevenlabs/elevenlabs-js/wrapper/realtime", () => ({
   AudioFormat: {
@@ -72,7 +61,6 @@ vi.mock("@elevenlabs/elevenlabs-js/wrapper/realtime", () => ({
   },
 }));
 
-// Helper: open a session backed by a captured fake connection.
 async function openSession(sampleRate = 16_000) {
   captured.connections.length = 0;
   const opener = openElevenLabs({});