@alexkroman1/aai 1.7.1 → 1.8.1

package/host/providers/tts/cartesia.ts

@@ -92,41 +92,32 @@ export function openCartesia(opts: CartesiaOptions): TtsOpener {
       const emitter: Emitter<TtsEvents> = createNanoEvents<TtsEvents>();
       let closed = false;
 
-      /** Mint a fresh context bound to the shared TTSWS connection. */
+      const audioConfig = {
+        model_id: model,
+        voice: { mode: "id" as const, id: voice },
+        output_format: {
+          container: "raw" as const,
+          encoding: "pcm_s16le" as const,
+          sample_rate: sampleRate,
+        },
+      };
+      const baseRequest = { ...audioConfig, language };
+
       const mintContext = (): TTSWSContext =>
-        ws.context({
-          model_id: model,
-          voice: { mode: "id", id: voice },
-          output_format: {
-            container: "raw",
-            encoding: "pcm_s16le",
-            sample_rate: sampleRate,
-          },
-          contextId: randomUUID(),
-        });
+        ws.context({ ...audioConfig, contextId: randomUUID() });
 
       let context = mintContext();
-      /**
-       * `doneEmitted` guards against emitting `done` more than once per turn.
-       * Reset whenever a fresh context is minted (i.e. at turn boundaries).
-       */
       let doneEmitted = false;
-      /**
-       * After `flush()` or `cancel()`, the current context is done accepting
-       * input. We defer minting a fresh one until the next `sendText()` so
-       * that late audio chunks + Cartesia's real `done` event (both tagged
-       * with the flushed context's id) still pass the filter below. Rotating
-       * eagerly would silently drop all audio still in flight.
-       */
+      // Defer minting after flush/cancel until next sendText so late audio
+      // chunks + Cartesia's real `done` (tagged with the flushed context's id)
+      // still pass the filter. Rotating eagerly would drop in-flight audio.
       let rotatePending = false;
-      const rotateContext = () => {
+      const rotateIfPending = () => {
+        if (!rotatePending) return;
         context = mintContext();
         doneEmitted = false;
         rotatePending = false;
       };
-      const rotateIfPending = () => {
-        if (rotatePending) rotateContext();
-      };
       const emitDoneOnce = () => {
         if (doneEmitted || closed) return;
         doneEmitted = true;
@@ -136,12 +127,11 @@ export function openCartesia(opts: CartesiaOptions): TtsOpener {
       // TTSWS fires events globally across all contexts on the shared
       // socket; filter by the currently-active context_id.
       ws.on("chunk", (event) => {
-        if (closed) return;
-        if (event.context_id !== context.contextId) return;
+        if (closed || event.context_id !== context.contextId) return;
         const buf = event.audio;
         if (!buf || buf.byteLength === 0) return;
-        // Cartesia sends PCM16 LE; be defensive about odd byte counts
-        // so `new Int16Array` never throws on a misaligned length.
+        // Defensive: trim odd byte counts so `new Int16Array` never throws
+        // on a misaligned length.
         const evenBytes = buf.byteLength - (buf.byteLength % 2);
         if (evenBytes === 0) return;
         const pcm = new Int16Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + evenBytes));
@@ -149,8 +139,7 @@ export function openCartesia(opts: CartesiaOptions): TtsOpener {
       });
 
       ws.on("done", (event) => {
-        if (closed) return;
-        if (event.context_id !== context.contextId) return;
+        if (closed || event.context_id !== context.contextId) return;
         emitDoneOnce();
       });
 
@@ -165,38 +154,25 @@ export function openCartesia(opts: CartesiaOptions): TtsOpener {
         try {
           ws.close({ code: 1000, reason: "client close" });
         } catch {
-          // Swallow: caller has already decided to tear down.
+          // Caller has already decided to tear down.
         }
       };
 
       if (openOpts.signal.aborted) {
         void close();
       } else {
-        openOpts.signal.addEventListener("abort", () => void close(), {
-          once: true,
-        });
+        openOpts.signal.addEventListener("abort", () => void close(), { once: true });
       }
 
-      const baseRequest = {
-        model_id: model,
-        voice: { mode: "id" as const, id: voice },
-        output_format: {
-          container: "raw" as const,
-          encoding: "pcm_s16le" as const,
-          sample_rate: sampleRate,
-        },
-        language,
-      };
-
       const ignoreRejection = (_err: unknown): void => {
-        // intentionally empty
+        /* no-op */
       };
 
       const session: CartesiaSession = {
         sendText(text: string) {
           if (closed || text.length === 0) return;
-          // First sendText after a flush/cancel starts a fresh context so
-          // we don't append to one that's already been finalized.
+          // First sendText after flush/cancel starts a fresh context so we
+          // don't append to one that's already been finalized.
           rotateIfPending();
           void context
             .send({ ...baseRequest, transcript: text, continue: true })
@@ -204,12 +180,10 @@ export function openCartesia(opts: CartesiaOptions): TtsOpener {
         },
         flush() {
           if (closed || rotatePending) return;
-          // Empty transcript with `continue: false` is the canonical
-          // end-of-turn signal. Cartesia finishes synthesizing whatever
-          // is queued and then emits a `done` tagged with the same
-          // context_id — at that point `emitDoneOnce` fires for real.
-          // Defer rotation so the filter below still accepts in-flight
-          // audio chunks and the real `done` event.
+          // Empty transcript + `continue: false` is the canonical end-of-turn
+          // signal. Cartesia finishes synthesizing what's queued and emits
+          // `done` tagged with the same context_id; rotation is deferred so
+          // in-flight audio chunks and the real `done` still pass the filter.
           void context
             .send({ ...baseRequest, transcript: "", continue: false })
             .catch(ignoreRejection);
@@ -218,18 +192,15 @@ export function openCartesia(opts: CartesiaOptions): TtsOpener {
         cancel() {
           if (closed) return;
           // Skip the wire cancel if the context is already final on
-          // Cartesia's side (natural `done` after flush, or a prior
-          // cancel). Cartesia responds to cancel on a retired context
-          // with a 400 "context ID does not exist", which our error
-          // listener surfaces as `tts_stream_error` and the pipeline
-          // treats as fatal — killing the session for a benign race.
+          // Cartesia's side: cancelling a retired context returns a 400
+          // ("context ID does not exist") which surfaces as a fatal
+          // tts_stream_error for a benign race.
           if (!doneEmitted) {
             void context.cancel().catch(ignoreRejection);
           }
-          // Emit synchronously: barge-in advances the orchestrator's
-          // state machine on `done`, and delaying it would audibly
-          // stall subsequent turns. Cartesia stops producing audio
-          // after cancel, so dropping any late chunks is fine.
+          // Emit synchronously: barge-in advances the orchestrator on `done`;
+          // delaying would audibly stall subsequent turns. Cartesia stops
+          // producing audio after cancel, so dropping late chunks is fine.
           emitDoneOnce();
           rotatePending = true;
         },
@@ -240,7 +211,6 @@ export function openCartesia(opts: CartesiaOptions): TtsOpener {
         _ws: ws,
         _currentContextId: () => context.contextId,
       };
-
       return session;
     },
   };

package/host/providers/tts/rime.test.ts

@@ -1,13 +1,8 @@
 // Copyright 2026 the AAI authors. MIT license.
-/** Unit test for the Rime TTS adapter. Mocks the `ws` package. */
 
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { openRime, type RimeSession } from "./rime.ts";
 
-// ──────────────────────────────────────────────────────────────────────────────
-// Fake WebSocket — hoisted so `vi.mock` factory can reference it
-// ──────────────────────────────────────────────────────────────────────────────
-
 type WsEvent = "open" | "message" | "error" | "close";
 type WsListener = (...args: unknown[]) => void;
 
@@ -15,19 +10,17 @@ const { FakeWebSocket } = vi.hoisted(() => {
   class FakeWebSocket {
     static OPEN = 1;
     static CLOSED = 3;
+    static instances: FakeWebSocket[] = [];
 
     readyState = FakeWebSocket.OPEN;
     sent: string[] = [];
-    private readonly listeners = new Map<string, WsListener[]>();
-
-    static instances: FakeWebSocket[] = [];
-
     readonly url: string;
+    private readonly listeners = new Map<string, WsListener[]>();
 
     constructor(url: string, _opts?: unknown) {
       this.url = url;
       FakeWebSocket.instances.push(this);
-      // Simulate async open on next microtask (matches real ws behaviour).
+      // Real `ws` fires "open" asynchronously; match that timing.
       queueMicrotask(() => this._fire("open"));
     }
 
@@ -39,17 +32,13 @@ const { FakeWebSocket } = vi.hoisted(() => {
 
     once(event: string, fn: WsListener) {
       const wrapper = (...args: unknown[]) => {
-        this.off(event, wrapper);
+        this.removeListener(event, wrapper);
         fn(...args);
       };
       this.on(event, wrapper);
     }
 
     removeListener(event: string, fn: WsListener) {
-      this.off(event, fn);
-    }
-
-    private off(event: string, fn: WsListener) {
       const arr = this.listeners.get(event) ?? [];
       this.listeners.set(
         event,
@@ -66,12 +55,10 @@ const { FakeWebSocket } = vi.hoisted(() => {
       this._fire("close");
     }
 
-    /** Test helper: fire an event on this socket. */
     _fire(event: WsEvent, ...args: unknown[]) {
       for (const fn of this.listeners.get(event) ?? []) fn(...args);
     }
 
-    /** Test helper: simulate a JSON message from the server. */
     _msg(payload: unknown) {
       this._fire("message", JSON.stringify(payload));
     }
@@ -85,10 +72,6 @@ vi.mock("ws", () => ({
   WebSocket: FakeWebSocket,
 }));
 
-// ──────────────────────────────────────────────────────────────────────────────
-// Helpers
-// ──────────────────────────────────────────────────────────────────────────────
-
 beforeEach(() => {
   FakeWebSocket.instances.length = 0;
   vi.useFakeTimers();
@@ -112,7 +95,7 @@ async function openSession(apiKey = "test-key"): Promise<{
     signal: controller.signal,
   }) as Promise<RimeSession>;
 
-  // Let the microtask that fires FakeWebSocket "open" run.
+  // Let the queued microtask that fires "open" run.
   await Promise.resolve();
 
   const session = await openPromise;
@@ -121,10 +104,6 @@ async function openSession(apiKey = "test-key"): Promise<{
   return { session, ws, controller };
 }
 
-// ──────────────────────────────────────────────────────────────────────────────
-// Tests
-// ──────────────────────────────────────────────────────────────────────────────
-
 describe("rime TTS adapter", () => {
   test("openRime returns an opener with name 'rime'", () => {
     const opener = openRime({ voice: "cove" });
@@ -150,18 +129,15 @@ describe("rime TTS adapter", () => {
     const audioEvents: Int16Array[] = [];
     session.on("audio", (pcm) => audioEvents.push(pcm));
 
-    // Encode 4 PCM16 samples (8 bytes) as base64.
     const samples = new Int16Array([100, 200, 300, 400]);
     const base64 = Buffer.from(samples.buffer).toString("base64");
 
     ws._msg({ type: "chunk", data: base64, contextId: null });
 
     expect(audioEvents.length).toBe(1);
-    const firstChunk = audioEvents[0];
-    expect(firstChunk).toBeInstanceOf(Int16Array);
-    // Each sample pair decodes correctly.
-    // biome-ignore lint/style/noNonNullAssertion: length was asserted to be 1 on the line above
-    const pcm = firstChunk!;
+    // biome-ignore lint/style/noNonNullAssertion: length was asserted to be 1 above
+    const pcm = audioEvents[0]!;
+    expect(pcm).toBeInstanceOf(Int16Array);
     expect(pcm.length).toBe(4);
     expect(pcm[0]).toBe(100);
     expect(pcm[3]).toBe(400);
@@ -188,11 +164,11 @@ describe("rime TTS adapter", () => {
     // closing the WS (which `eos` would do).
     expect(ws.sent).toContain(JSON.stringify({ text: "." }));
 
-    // First-audio timer is 5 s — short window must not fire `done` yet.
+    // First-audio timer is 5s — short window must not fire `done` yet.
     vi.advanceTimersByTime(500);
     expect(doneEvents.length).toBe(0);
 
-    // First chunk arrives → switch to short quiescence window.
+    // First chunk arrives, switching to the short quiescence window.
     const samples = new Int16Array([100, 200, 300, 400]);
     ws._msg({
       type: "chunk",
@@ -215,7 +191,7 @@ describe("rime TTS adapter", () => {
     session.sendText("Hi there");
     session.flush();
 
-    // No chunk arrives — done must wait the full FIRST_AUDIO_TIMEOUT_MS (5 s).
+    // No chunk arrives — must wait the full FIRST_AUDIO_TIMEOUT_MS (5s).
     vi.advanceTimersByTime(4999);
     expect(doneEvents.length).toBe(0);
     vi.advanceTimersByTime(1);
@@ -229,11 +205,10 @@ describe("rime TTS adapter", () => {
     session.on("done", () => doneEvents.push(Date.now()));
 
     session.sendText("Hello");
-    // cancel() must emit `done` synchronously — barge-in cannot be deferred.
+    // Barge-in cannot be deferred — `done` must fire synchronously.
     session.cancel();
 
     expect(ws.sent).toContain(JSON.stringify({ operation: "clear" }));
-    // done was emitted synchronously (before any await / timer).
     expect(doneEvents.length).toBe(1);
   });
 
@@ -245,7 +220,6 @@ describe("rime TTS adapter", () => {
     await session.close();
     expect(ws.readyState).toBe(FakeWebSocket.CLOSED);
 
-    // Second close should not throw.
     await expect(session.close()).resolves.toBeUndefined();
   });
 });

package/host/providers/tts/rime.ts

@@ -2,36 +2,17 @@
 /**
  * Rime TTS opener (host-only).
  *
- * The user-facing descriptor factory (`rime(...)`) lives in
- * `sdk/providers/tts/rime.ts`. This module is the host-side
- * counterpart: it takes the descriptor options + an API key and
- * returns a {@link TtsOpener} that the pipeline session drives.
+ * Connects to Rime's `ws2` JSON WebSocket endpoint with one long-lived
+ * connection per session. Client → server: `{ text }` appends to the
+ * synthesis buffer, `{ operation: "clear" }` drops it (barge-in). We never
+ * send `eos` since it tears down the WS — `flush()` instead sends a
+ * trailing `"."` to force synthesis of any text buffered behind missing
+ * terminal punctuation while keeping the connection reusable.
  *
- * **Protocol.** Connects to Rime's `ws2` JSON WebSocket endpoint
- * (`wss://users-ws.rime.ai/ws2`). Client-to-server messages are JSON:
- *   - `{ "text": "..." }` — append text to the synthesis buffer
- *   - `{ "operation": "clear" }` — drop buffered text (barge-in)
- *   - `{ "operation": "eos" }` — drain buffer, close connection (NOT used
- *     during a session: it would tear down the WS, forcing reconnect per
- *     turn). We force end-of-turn synthesis with a trailing `"."` instead.
- * The server responds with JSON frames:
- *   - `{ type: "chunk", data: <base64 PCM16 LE>, contextId: string | null }`
- *   - `{ type: "timestamps", ... }` (ignored)
- *   - `{ type: "error", message: string }` (surfaced as `tts_stream_error`)
- *
- * **Single long-lived connection per session.** Rime buffers text until it
- * sees terminal punctuation (`.`, `?`, `!`), so we use one WebSocket per
- * `open()` call and reuse it across turns. `clear` resets the buffer
- * between cancellations.
- *
- * **Done detection.** After `flush()` sends a trailing `"."` to force the
- * server to synthesize any half-buffered text, we arm a quiescence timer
- * that fires 500 ms after the last received audio chunk. When it fires,
- * `done` is emitted.
- *
- * **Audio format.** The URL requests `audioFormat=pcm` at the negotiated
- * `sampleRate`, which returns raw PCM16 little-endian. We decode the base64
- * payload and construct a zero-copy `Int16Array` view over the decoded bytes.
+ * Server → client: `{ type: "chunk", data: <base64 PCM16 LE> }` carries
+ * audio; `timestamps` is ignored; `error` surfaces as `tts_stream_error`.
+ * The `audioFormat=pcm` query param at the negotiated `sampleRate` returns
+ * raw PCM16 LE that we view as a zero-copy `Int16Array`.
  */
 
 import { createNanoEvents, type Emitter } from "nanoevents";
@@ -45,13 +26,11 @@ import {
   type TtsSession,
 } from "../../../sdk/providers.ts";
 
-/** Internal: TtsSession with a test-only handle to the raw WebSocket. */
 export interface RimeSession extends TtsSession {
   /** @internal Test-only: exposes the underlying raw WebSocket. */
   readonly _ws: WebSocket;
 }
 
-/** PCM16 sample rates accepted by the Rime `ws2` endpoint. */
 const RIME_PCM16_RATES = [
   8000, 16_000, 22_050, 24_000, 44_100, 48_000,
 ] as const satisfies readonly number[];
@@ -64,51 +43,28 @@ function assertSupportedSampleRate(rate: number): number {
   );
 }
 
-/**
- * Decode a base64 string from Rime into a zero-copy `Int16Array`.
- *
- * Rime's `ws2` endpoint returns base64-encoded PCM16 LE in each chunk.
- * `Buffer.from(base64, "base64")` gives us a Node.js Buffer (which is a
- * Uint8Array subclass) with `byteOffset === 0`. PCM16 bytes always come in
- * pairs so the length is guaranteed to be even.
- */
 function base64ToPcm(data: string): Int16Array {
   const bytes = Buffer.from(data, "base64");
-  // Defensive: drop a trailing odd byte rather than throwing on misalignment.
+  // Defensive: drop a trailing odd byte rather than throw on misalignment.
   const evenLen = bytes.byteLength - (bytes.byteLength % 2);
   if (evenLen === 0) return new Int16Array(0);
   return new Int16Array(bytes.buffer, bytes.byteOffset, evenLen / 2);
 }
 
-/**
- * Shape of JSON messages received from Rime's `ws2` endpoint.
- *
- * Only `chunk` messages carry audio; `timestamps` messages are informational
- * and can be ignored for the current use case.
- */
 interface RimeMessage {
   type: "chunk" | "timestamps" | "error" | string;
-  /** Base64-encoded PCM16 LE audio. Present on `type === "chunk"`. */
   data?: string;
-  /** Context discriminator for the in-flight utterance. May be null. */
   contextId?: string | null;
-  /** Error description. Present on `type === "error"`. */
   message?: string;
 }
 
-/** Quiescence timeout in ms — how long to wait after the last audio chunk before emitting `done`. */
 const QUIESCENCE_MS = 500;
 
-/**
- * After `flush()`, how long to wait for the FIRST audio chunk before
- * giving up and emitting `done`. Greeting and short replies hit this
- * path: `flush()` runs immediately after `sendText()`, so audio TTFB
- * exceeds the 500 ms quiescence window. Once the first chunk arrives,
- * we transition to the shorter quiescence timeout.
- */
+// Greetings and short replies emit `flush()` immediately after `sendText()`,
+// so audio TTFB easily exceeds QUIESCENCE_MS. Wait longer for the FIRST
+// chunk; subsequent chunks revert to the shorter quiescence window.
 const FIRST_AUDIO_TIMEOUT_MS = 5000;
 
-/** Wait for the WebSocket `open` event; reject on first `error`. */
 function waitForOpen(ws: WebSocket): Promise<void> {
   return new Promise<void>((resolve, reject) => {
     const onOpen = () => {
@@ -129,12 +85,8 @@ function waitForOpen(ws: WebSocket): Promise<void> {
   });
 }
 
-/**
- * Handle one incoming WebSocket message frame.
- *
- * Extracted into a top-level function to keep `open()` under the cognitive
- * complexity limit while retaining full access to the session state via refs.
- */
+// Extracted to a top-level function to keep `open()` under the cognitive
+// complexity limit; session state is threaded through via the ref callbacks.
 function handleRimeMessage(
   raw: WebSocket.Data,
   emitter: Emitter<TtsEvents>,
@@ -145,7 +97,6 @@ function handleRimeMessage(
   try {
     msg = JSON.parse(typeof raw === "string" ? raw : raw.toString()) as RimeMessage;
   } catch {
-    // Unparseable frame — ignore.
     return;
   }
 
@@ -153,9 +104,8 @@ function handleRimeMessage(
     const pcm = base64ToPcm(msg.data);
     if (pcm.length > 0) {
       emitter.emit("audio", pcm);
-      // While we're waiting on a flush (long timer for first audio, or
-      // short timer between chunks), each chunk resets to the short
-      // quiescence window — so `done` fires only after audio stops.
+      // Each chunk resets the quiescence window so `done` fires only after
+      // audio stops — applies to both the first-audio and post-chunk timers.
       if (isActiveTimer()) armQuiescence();
     }
     return;
@@ -166,10 +116,8 @@ function handleRimeMessage(
       makeTtsError("tts_stream_error", `Rime TTS: ${msg.message ?? "unknown error"}`),
     );
   }
-  // Ignore `type === "timestamps"` and unknown message types.
 }
 
-/** Build a {@link TtsOpener} from resolved Rime descriptor options. */
 export function openRime(opts: RimeOptions): TtsOpener {
   return {
     name: "rime",
@@ -187,7 +135,6 @@ export function openRime(opts: RimeOptions): TtsOpener {
       const lang = opts.language ?? "eng";
       const voice = opts.voice ?? RIME_DEFAULT_VOICE;
 
-      // Construct the ws2 URL with query parameters.
       const url = `wss://users-ws.rime.ai/ws2?speaker=${encodeURIComponent(voice)}&modelId=${encodeURIComponent(model)}&audioFormat=pcm&samplingRate=${sampleRate}&lang=${encodeURIComponent(lang)}`;
 
       let ws: WebSocket;
@@ -205,12 +152,6 @@ export function openRime(opts: RimeOptions): TtsOpener {
       const emitter: Emitter<TtsEvents> = createNanoEvents<TtsEvents>();
       let closed = false;
       let doneEmitted = false;
-      /**
-       * After `flush()`, we arm a timer that fires `done`. Initial timeout is
-       * `FIRST_AUDIO_TIMEOUT_MS` to give Rime headroom on TTFB; the first
-       * chunk swaps it for a shorter `QUIESCENCE_MS` window that resets on
-       * each subsequent chunk. `cancel()` emits `done` synchronously.
-       */
       let quiescenceTimer: ReturnType<typeof setTimeout> | null = null;
 
       const clearQuiescence = () => {
@@ -264,7 +205,7 @@ export function openRime(opts: RimeOptions): TtsOpener {
         try {
           ws.close();
         } catch {
-          // Swallow: caller has already decided to tear down.
+          // Caller has already decided to tear down.
         }
       };
 
@@ -278,7 +219,6 @@ export function openRime(opts: RimeOptions): TtsOpener {
         sendText(text: string) {
           if (closed || text.length === 0) return;
           if (ws.readyState !== WebSocket.OPEN) return;
-          // Reset done state at the start of a new turn.
           doneEmitted = false;
           ws.send(JSON.stringify({ text }));
         },
@@ -286,19 +226,16 @@ export function openRime(opts: RimeOptions): TtsOpener {
         flush() {
           if (closed) return;
           if (ws.readyState !== WebSocket.OPEN) return;
-          // Force synthesis of any text buffered behind a missing terminal
-          // punctuation: append a trailing `"."`. Sending the JSON `eos`
-          // operation would close the connection, requiring a reconnect on
-          // every turn — `"."` keeps the WS reusable. Use the longer
-          // first-audio timer until the initial chunk arrives; the chunk
-          // handler swaps it for short quiescence on each subsequent chunk.
+          // Force synthesis of any text buffered behind missing terminal
+          // punctuation: a trailing `"."` keeps the WS reusable, whereas
+          // the JSON `eos` operation would close it and require a
+          // reconnect every turn.
           ws.send(JSON.stringify({ text: "." }));
           armFirstAudioTimer();
         },
 
         cancel() {
           if (closed) return;
-          // Drop Rime's server-side buffer for barge-in.
           if (ws.readyState === WebSocket.OPEN) {
             ws.send(JSON.stringify({ operation: "clear" }));
           }

package/host/runtime-config.test.ts

@@ -3,13 +3,19 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { jsonLogger } from "./runtime-config.ts";
 
-/** Parse the JSON line at `index` from `chunks`, failing if missing. */
 function parseEntry(chunks: string[], index: number): Record<string, unknown> {
   const raw = chunks[index];
   if (raw === undefined) throw new Error(`No chunk at index ${index}`);
   return JSON.parse(raw) as Record<string, unknown>;
 }
 
+function spyWriteInto(stream: NodeJS.WriteStream, sink: string[]): void {
+  vi.spyOn(stream, "write").mockImplementation((chunk: string | Uint8Array) => {
+    sink.push(String(chunk));
+    return true;
+  });
+}
+
 describe("jsonLogger", () => {
   let stdoutChunks: string[];
   let stderrChunks: string[];
@@ -17,14 +23,8 @@ describe("jsonLogger", () => {
   beforeEach(() => {
     stdoutChunks = [];
     stderrChunks = [];
-    vi.spyOn(process.stdout, "write").mockImplementation((chunk: string | Uint8Array) => {
-      stdoutChunks.push(String(chunk));
-      return true;
-    });
-    vi.spyOn(process.stderr, "write").mockImplementation((chunk: string | Uint8Array) => {
-      stderrChunks.push(String(chunk));
-      return true;
-    });
+    spyWriteInto(process.stdout, stdoutChunks);
+    spyWriteInto(process.stderr, stderrChunks);
   });
 
   afterEach(() => {