@kuralle-syrinx/realtime 4.2.0 → 4.4.0

package/src/gemini-translate.test.ts

@@ -1,82 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { createGeminiTranslateSession } from "./gemini-translate.js";
-
-const sendRealtimeInput = vi.fn();
-const closeSession = vi.fn();
-
-const liveConnect = vi.fn().mockImplementation(async () => ({
-  sendRealtimeInput,
-  close: closeSession,
-}));
-
-vi.mock("@google/genai", () => ({
-  GoogleGenAI: vi.fn().mockImplementation(() => ({
-    live: { connect: liveConnect },
-  })),
-  Modality: { AUDIO: "AUDIO" },
-}));
-
-const FRAME_BYTES = 640;
-
-function frame(byte: number): Uint8Array {
-  return new Uint8Array(FRAME_BYTES).fill(byte);
-}
-
-afterEach(() => {
-  sendRealtimeInput.mockClear();
-  closeSession.mockClear();
-  liveConnect.mockClear();
-});
-
-describe("createGeminiTranslateSession", () => {
-  it("coalesces 20ms frames into 100ms chunks before sendRealtimeInput", async () => {
-    const session = await createGeminiTranslateSession({
-      apiKey: "test-key",
-      targetLanguageCode: "es",
-      onAudio: () => {},
-    });
-
-    for (let i = 0; i < 5; i += 1) {
-      session.sendAudio(frame(i));
-    }
-
-    expect(sendRealtimeInput).toHaveBeenCalledTimes(1);
-    const arg = sendRealtimeInput.mock.calls[0]![0] as { audio: { data: string } };
-    const chunk = Buffer.from(arg.audio.data, "base64");
-    expect(chunk.byteLength).toBe(3200);
-    expect(chunk[0]).toBe(0);
-    expect(chunk[639]).toBe(0);
-    expect(chunk[640]).toBe(1);
-    expect(chunk[3199]).toBe(4);
-  });
-
-  it("flushes remainder on signalAudioStreamEnd and close", async () => {
-    const session = await createGeminiTranslateSession({
-      apiKey: "test-key",
-      targetLanguageCode: "es",
-      onAudio: () => {},
-    });
-
-    session.sendAudio(frame(9));
-    session.sendAudio(frame(9));
-    session.sendAudio(frame(9));
-    expect(sendRealtimeInput).toHaveBeenCalledTimes(0);
-
-    session.signalAudioStreamEnd();
-    expect(sendRealtimeInput).toHaveBeenCalledTimes(2);
-    const streamEndArg = sendRealtimeInput.mock.calls[0]![0] as { audio: { data: string } };
-    expect(Buffer.from(streamEndArg.audio.data, "base64").byteLength).toBe(1920);
-    expect(sendRealtimeInput.mock.calls[1]![0]).toEqual({ audioStreamEnd: true });
-
-    sendRealtimeInput.mockClear();
-    session.sendAudio(frame(7));
-    await session.close();
-    expect(sendRealtimeInput).toHaveBeenCalledTimes(1);
-    const closeArg = sendRealtimeInput.mock.calls[0]![0] as { audio: { data: string } };
-    expect(Buffer.from(closeArg.audio.data, "base64").byteLength).toBe(640);
-    expect(closeSession).toHaveBeenCalledTimes(1);
-  });
-});

package/src/openai-compatible-realtime.test.ts

@@ -1,188 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-
-import type { ManagedSocket, SocketData, SocketFactory } from "@kuralle-syrinx/ws";
-
-import { createOpenAiCompatibleRealtimeAdapter } from "./openai-compatible-realtime.js";
-import type { RealtimeEvent } from "./realtime-adapter.js";
-
-interface MockSocketHarness {
-  readonly factory: SocketFactory;
-  readonly sent: string[];
-  inject(msg: Record<string, unknown>): void;
-}
-
-function createMockSocketHarness(): MockSocketHarness {
-  const sent: string[] = [];
-  let messageHandler: ((data: SocketData, isBinary: boolean) => void) | null = null;
-
-  const socket: ManagedSocket = {
-    get isOpen() {
-      return true;
-    },
-    send: (data: SocketData) => {
-      sent.push(typeof data === "string" ? data : "");
-    },
-    keepAlivePing: () => {},
-    verify: async () => true,
-    dispose: () => {},
-    onOpen: (handler) => {
-      queueMicrotask(() => handler());
-    },
-    onMessage: (handler) => {
-      messageHandler = handler;
-    },
-    onClose: () => {},
-    onError: () => {},
-  };
-
-  return {
-    factory: () => socket,
-    sent,
-    inject: (msg) => messageHandler?.(JSON.stringify(msg), false),
-  };
-}
-
-async function collectEvents(
-  events: AsyncIterable<RealtimeEvent>,
-  max = 8,
-): Promise<RealtimeEvent[]> {
-  const out: RealtimeEvent[] = [];
-  for await (const event of events) {
-    out.push(event);
-    if (out.length >= max) break;
-  }
-  return out;
-}
-
-async function waitFor(predicate: () => boolean, timeoutMs = 2000): Promise<void> {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    if (predicate()) return;
-    await new Promise((resolve) => setTimeout(resolve, 5));
-  }
-  throw new Error("Timed out waiting for condition");
-}
-
-function createAdapter(mock: MockSocketHarness) {
-  return createOpenAiCompatibleRealtimeAdapter({
-    apiKey: "test-key",
-    socketFactory: mock.factory,
-    defaultModel: "gpt-realtime-2",
-    url: () => "wss://example.test/realtime?model=gpt-realtime-2",
-    caps: {
-      inputSampleRateHz: 24_000,
-      outputSampleRateHz: 24_000,
-      supportsConcurrentToolAudio: true,
-      supportsTruncate: true,
-      emitsServerSpeechStarted: true,
-      supportsTextOnlyModality: true,
-    },
-    buildSessionUpdate: () => ({
-      type: "realtime",
-      model: "gpt-realtime-2",
-      output_modalities: ["text"],
-    }),
-    supportsTruncate: true,
-    defaultErrorMessage: "OpenAI Realtime error",
-  });
-}
-
-describe("createOpenAiCompatibleRealtimeAdapter text-only output", () => {
-  it("surfaces response.output_text.delta as assistant transcript (final=false)", async () => {
-    const mock = createMockSocketHarness();
-    const adapter = createAdapter(mock);
-
-    const eventsTask = collectEvents(adapter.events, 2);
-    const openTask = adapter.open(new AbortController().signal);
-    await waitFor(() => mock.sent.length > 0);
-    mock.inject({ type: "session.updated" });
-    await openTask;
-
-    mock.inject({ type: "response.created" });
-    mock.inject({
-      type: "response.output_text.delta",
-      delta: "Let me ",
-    });
-
-    const events = await eventsTask;
-    expect(events).toEqual([
-      { type: "response_started" },
-      { type: "transcript", role: "assistant", text: "Let me ", final: false },
-    ]);
-  });
-
-  it("surfaces response.output_text.done as final assistant transcript with accumulated text", async () => {
-    const mock = createMockSocketHarness();
-    const adapter = createAdapter(mock);
-
-    const eventsTask = collectEvents(adapter.events, 3);
-    const openTask = adapter.open(new AbortController().signal);
-    await waitFor(() => mock.sent.length > 0);
-    mock.inject({ type: "session.updated" });
-    await openTask;
-
-    mock.inject({ type: "response.created" });
-    mock.inject({
-      type: "response.output_text.delta",
-      delta: "Let me ",
-    });
-    mock.inject({
-      type: "response.output_text.done",
-      text: "Let me check that.",
-    });
-
-    const events = await eventsTask;
-    expect(events).toEqual([
-      { type: "response_started" },
-      { type: "transcript", role: "assistant", text: "Let me ", final: false },
-      { type: "transcript", role: "assistant", text: "Let me check that.", final: true },
-    ]);
-  });
-
-  it("uses assistantTranscript when response.output_text.done omits text", async () => {
-    const mock = createMockSocketHarness();
-    const adapter = createAdapter(mock);
-
-    const eventsTask = collectEvents(adapter.events, 3);
-    const openTask = adapter.open(new AbortController().signal);
-    await waitFor(() => mock.sent.length > 0);
-    mock.inject({ type: "session.updated" });
-    await openTask;
-
-    mock.inject({ type: "response.created" });
-    mock.inject({
-      type: "response.output_text.delta",
-      delta: "Hello",
-    });
-    mock.inject({
-      type: "response.output_text.done",
-    });
-
-    const events = await eventsTask;
-    expect(events).toEqual([
-      { type: "response_started" },
-      { type: "transcript", role: "assistant", text: "Hello", final: false },
-      { type: "transcript", role: "assistant", text: "Hello", final: true },
-    ]);
-  });
-});
-
-describe("createOpenAiCompatibleRealtimeAdapter requestResponse (Syrinx-owned turns)", () => {
-  it("sends input_audio_buffer.commit then response.create", async () => {
-    const mock = createMockSocketHarness();
-    const adapter = createAdapter(mock);
-
-    const openTask = adapter.open(new AbortController().signal);
-    await waitFor(() => mock.sent.length > 0);
-    mock.inject({ type: "session.updated" });
-    await openTask;
-
-    const baseline = mock.sent.length;
-    adapter.requestResponse!();
-
-    expect(JSON.parse(mock.sent[baseline]!)).toEqual({ type: "input_audio_buffer.commit" });
-    expect(JSON.parse(mock.sent[baseline + 1]!)).toEqual({ type: "response.create" });
-  });
-});