@kuralle-syrinx/core 4.2.0 → 4.4.0

package/src/pipeline-bus.test.ts

@@ -1,211 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, it, expect, vi } from "vitest";
-import { PipelineBusImpl, Route, type PipelineBusConfig } from "../src/pipeline-bus.js";
-import type { VoicePacket } from "../src/packets.js";
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-function pkt(kind: string, contextId = "ctx-1"): VoicePacket {
-  return { kind, contextId, timestampMs: Date.now() };
-}
-
-function createBus(config?: PipelineBusConfig): PipelineBusImpl {
-  return new PipelineBusImpl(config);
-}
-
-/** Start bus, run fn, stop bus, await drain completion. */
-async function withBus(
-  config: PipelineBusConfig | undefined,
-  fn: (bus: PipelineBusImpl) => void | Promise<void>,
-): Promise<void> {
-  const bus = createBus(config);
-  const startP = bus.start();
-  // Give the start loop a tick to begin
-  await new Promise((r) => setTimeout(r, 5));
-  await fn(bus);
-  // Allow pending dispatches to complete
-  await new Promise((r) => setTimeout(r, 20));
-  bus.stop();
-  await startP;
-}
-
-// =============================================================================
-// Tests
-// =============================================================================
-
-describe("PipelineBusImpl", () => {
-  describe("push and drain order", () => {
-    it("drains Critical before Main", async () => {
-      const processed: string[] = [];
-      await withBus(undefined, (bus) => {
-        bus.on("critical.event", () => { processed.push("critical"); });
-        bus.on("main.event", () => { processed.push("main"); });
-        bus.push(Route.Main, pkt("main.event"));
-        bus.push(Route.Critical, pkt("critical.event"));
-      });
-      expect(processed).toEqual(["critical", "main"]);
-    });
-
-    it("drains Main before Background", async () => {
-      const processed: string[] = [];
-      await withBus(undefined, (bus) => {
-        bus.on("main.event", () => { processed.push("main"); });
-        bus.on("bg.event", () => { processed.push("bg"); });
-        bus.push(Route.Background, pkt("bg.event"));
-        bus.push(Route.Main, pkt("main.event"));
-      });
-      expect(processed).toEqual(["main", "bg"]);
-    });
-
-    it("batches Critical up to criticalBatchSize before yielding", async () => {
-      const processed: string[] = [];
-      await withBus({ criticalBatchSize: 3 }, (bus) => {
-        bus.on("critical.event", () => { processed.push("c"); });
-        for (let i = 0; i < 5; i++) {
-          bus.push(Route.Critical, pkt("critical.event"));
-        }
-      });
-      expect(processed.length).toBeGreaterThanOrEqual(5);
-    });
-  });
-
-  describe("capacity and overflow", () => {
-    it("drops oldest Background on overflow", async () => {
-      const dropped: VoicePacket[] = [];
-      const metrics: string[] = [];
-      await withBus(
-        { bgCapacity: 2, onBackgroundDrop: (d: VoicePacket) => { dropped.push(d); } },
-        (bus) => {
-          bus.on("metric.conversation", (pkt: any) => {
-            metrics.push(pkt.name);
-          });
-          bus.push(Route.Background, pkt("bg.1", "id-1"));
-          bus.push(Route.Background, pkt("bg.2", "id-2"));
-          bus.push(Route.Background, pkt("bg.3", "id-3"));
-        },
-      );
-      expect(dropped.length).toBeGreaterThanOrEqual(1);
-      if (dropped.length > 0) {
-        expect(dropped[0]!.contextId).toBe("id-1");
-      }
-      expect(metrics).toContain("pipeline.bus.background.dropped");
-    });
-
-    it("throws on Main overflow", () => {
-      const bus = createBus({ mainCapacity: 1 });
-      bus.push(Route.Main, pkt("main.1"));
-      expect(() => bus.push(Route.Main, pkt("main.2"))).toThrow("Main queue full");
-    });
-
-    it("Critical never overflows", () => {
-      const bus = createBus();
-      for (let i = 0; i < 10000; i++) {
-        bus.push(Route.Critical, pkt("critical.event"));
-      }
-      expect(true).toBe(true);
-    });
-  });
-
-  describe("handler registration", () => {
-    it("calls matching handler for packet kind", async () => {
-      const fn = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", fn);
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-
-    it("does not call handler for different kind", async () => {
-      const fn = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", fn);
-        bus.push(Route.Main, pkt("other.event"));
-      });
-      expect(fn).not.toHaveBeenCalled();
-    });
-
-    it("unsubscribe removes handler", async () => {
-      const fn = vi.fn();
-      await withBus(undefined, (bus) => {
-        const unsub = bus.on("test.event", fn);
-        unsub();
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(fn).not.toHaveBeenCalled();
-    });
-
-    it("multiple handlers for same kind all fire", async () => {
-      const fn1 = vi.fn();
-      const fn2 = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", fn1);
-        bus.on("test.event", fn2);
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(fn1).toHaveBeenCalledTimes(1);
-      expect(fn2).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("allPackets", () => {
-    it("publishes every pushed packet with its route", async () => {
-      const bus = createBus();
-      const reader = bus.allPackets.getReader();
-      bus.push(Route.Main, pkt("main.event", "main-1"));
-      bus.push(Route.Critical, pkt("critical.event", "critical-1"));
-
-      const first = await reader.read();
-      const second = await reader.read();
-      reader.releaseLock();
-
-      expect(first.value).toMatchObject({
-        route: Route.Main,
-        packet: { kind: "main.event", contextId: "main-1" },
-      });
-      expect(second.value).toMatchObject({
-        route: Route.Critical,
-        packet: { kind: "critical.event", contextId: "critical-1" },
-      });
-    });
-
-    it("does not retain packets when no reader is attached (drop-on-unread)", async () => {
-      const bus = createBus();
-      // No getReader() → stream unlocked → nothing retained (else a call with no
-      // recorder would buffer every audio packet and OOM).
-      for (let i = 0; i < 1000; i++) bus.push(Route.Main, pkt("main.event", `n-${i}`));
-
-      // A reader that attaches later sees only packets pushed AFTER it attaches.
-      const reader = bus.allPackets.getReader();
-      bus.push(Route.Main, pkt("main.event", "after-reader"));
-      const next = await reader.read();
-      reader.releaseLock();
-      expect(next.value).toMatchObject({ packet: { contextId: "after-reader" } });
-    });
-  });
-
-  describe("error handling", () => {
-    it("handler error pushes VoiceErrorPacket to Critical", async () => {
-      const errorHandler = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", () => { throw new Error("boom"); });
-        bus.on("pipeline.error", errorHandler);
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(errorHandler).toHaveBeenCalled();
-    });
-
-    it("handler error does not stop other handlers", async () => {
-      const fn2 = vi.fn();
-      await withBus(undefined, (bus) => {
-        bus.on("test.event", () => { throw new Error("boom"); });
-        bus.on("test.event", fn2);
-        bus.push(Route.Main, pkt("test.event"));
-      });
-      expect(fn2).toHaveBeenCalledTimes(1);
-    });
-  });
-});

package/src/policies/defer.test.ts

@@ -1,86 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, it, expect } from "vitest";
-import type { InteractionObservation, InteractionPolicy } from "../interaction-policy.js";
-import { DeferInteractionPolicy } from "./defer.js";
-
-const OBSERVATIONS: InteractionObservation[] = [
-  {
-    kind: "vad_speech_started",
-    contextId: "user",
-    timestampMs: 1000,
-    confidence: 0.99,
-    interruptedContextId: "assistant-turn",
-  },
-  {
-    kind: "vad_speech_activity",
-    contextId: "user",
-    timestampMs: 1300,
-  },
-  {
-    kind: "vad_speech_ended",
-    contextId: "user",
-    timestampMs: 2000,
-    hasActiveTts: true,
-  },
-  {
-    kind: "vad_barge_in_audio",
-    contextId: "user",
-    timestampMs: 1500,
-    audio: new Uint8Array([1, 2, 3]),
-  },
-  {
-    kind: "stt_partial",
-    contextId: "user",
-    timestampMs: 1600,
-    text: "hello",
-    confidence: 0.9,
-    interruptedContextId: "assistant-turn",
-  },
-  {
-    kind: "stt_final",
-    contextId: "user",
-    timestampMs: 2000,
-    text: "hello there",
-    confidence: 0.95,
-    interruptedContextId: "assistant-turn",
-  },
-  {
-    kind: "audio_frame",
-    contextId: "user",
-    timestampMs: 1700,
-    audio: new Int16Array([1, 2, 3]),
-  },
-  {
-    kind: "playout_tick",
-    contextId: "assistant-turn",
-    timestampMs: 1800,
-    playedOutMs: 500,
-    ttsActive: true,
-  },
-  {
-    kind: "delegate_state",
-    contextId: "turn-1",
-    timestampMs: 1900,
-    delegateInFlight: true,
-  },
-];
-
-describe("DeferInteractionPolicy", () => {
-  it("implements InteractionPolicy", () => {
-    const policy: InteractionPolicy = new DeferInteractionPolicy();
-    expect(policy).toBeInstanceOf(DeferInteractionPolicy);
-  });
-
-  it("observe returns [] for every observation kind", () => {
-    const policy = new DeferInteractionPolicy();
-    for (const obs of OBSERVATIONS) {
-      expect(policy.observe(obs)).toEqual([]);
-    }
-  });
-
-  it("reset is a no-op", () => {
-    const policy = new DeferInteractionPolicy();
-    expect(() => policy.reset("any-context")).not.toThrow();
-  });
-});

package/src/policies/rule-based.test.ts

@@ -1,269 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, it, expect } from "vitest";
-import { PipelineBusImpl } from "../pipeline-bus.js";
-import { RuleBasedInteractionPolicy } from "./rule-based.js";
-import { PrimarySpeakerGate } from "../primary-speaker-gate.js";
-import { TtsPlayoutClock } from "../tts-playout-clock.js";
-
-async function createPolicy(minInterruptionMs = 280) {
-  const bus = new PipelineBusImpl();
-  void bus.start();
-  const ttsPlayout = new TtsPlayoutClock();
-  const policy = new RuleBasedInteractionPolicy({
-    bus,
-    primarySpeakerGate: new PrimarySpeakerGate(),
-    ttsPlayout,
-    minInterruptionMs,
-  });
-  return { bus, ttsPlayout, policy };
-}
-
-function metricNames(bus: PipelineBusImpl): string[] {
-  const names: string[] = [];
-  bus.on("metric.conversation", (pkt) => {
-    names.push((pkt as unknown as { name: string }).name);
-  });
-  return names;
-}
-
-async function drainBus(): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-describe("RuleBasedInteractionPolicy", () => {
-  it("parity vector: sustained speech commits interrupt at activity frame", async () => {
-    const { ttsPlayout, policy } = await createPolicy(280);
-    ttsPlayout.noteAudio("assistant-turn", 100, 1000);
-
-    const t0 = 2000;
-    expect(
-      policy.observe({
-        kind: "vad_speech_started",
-        contextId: "user",
-        timestampMs: t0,
-        confidence: 0.99,
-        interruptedContextId: "assistant-turn",
-      }),
-    ).toEqual([]);
-
-    expect(
-      policy.observe({
-        kind: "vad_speech_activity",
-        contextId: "user",
-        timestampMs: t0 + 300,
-      }),
-    ).toEqual([{ kind: "interrupt", interruptedContextId: "assistant-turn" }]);
-  });
-
-  it("suppresses short speech blip without interrupt decision", async () => {
-    const { bus, ttsPlayout, policy } = await createPolicy(280);
-    const metrics = metricNames(bus);
-    ttsPlayout.noteAudio("assistant-turn", 100, 1000);
-
-    const t0 = 3000;
-    policy.observe({
-      kind: "vad_speech_started",
-      contextId: "user",
-      timestampMs: t0,
-      confidence: 0.99,
-      interruptedContextId: "assistant-turn",
-    });
-    policy.observe({
-      kind: "vad_speech_activity",
-      contextId: "user",
-      timestampMs: t0 + 90,
-    });
-    const decisions = policy.observe({
-      kind: "vad_speech_ended",
-      contextId: "user",
-      timestampMs: t0 + 130,
-      hasActiveTts: true,
-    });
-    await drainBus();
-
-    expect(decisions).toEqual([]);
-    expect(metrics).toContain("interrupt.suppressed_short_speech");
-  });
-
-  it("suppresses backchannel interim without interrupt decision", async () => {
-    const { bus, ttsPlayout, policy } = await createPolicy(280);
-    const metrics = metricNames(bus);
-    ttsPlayout.noteAudio("assistant-turn", 100, 1000);
-
-    policy.observe({
-      kind: "vad_speech_started",
-      contextId: "user",
-      timestampMs: 2000,
-      confidence: 0.99,
-      interruptedContextId: "assistant-turn",
-    });
-    policy.observe({
-      kind: "stt_partial",
-      contextId: "user",
-      timestampMs: 2050,
-      text: "uh huh",
-    });
-    const decisions = policy.observe({
-      kind: "vad_speech_activity",
-      contextId: "user",
-      timestampMs: 2300,
-    });
-    await drainBus();
-
-    expect(decisions).toEqual([]);
-    expect(metrics).toContain("interrupt.suppressed_backchannel");
-  });
-
-  it("IP-C3: emits no backchannel on VAD/user-pause observations", async () => {
-    const { policy } = await createPolicy();
-
-    expect(
-      policy.observe({
-        kind: "vad_speech_ended",
-        contextId: "user",
-        timestampMs: 5000,
-        hasActiveTts: false,
-      }),
-    ).toEqual([]);
-    expect(
-      policy.observe({
-        kind: "vad_speech_activity",
-        contextId: "user",
-        timestampMs: 5100,
-      }),
-    ).toEqual([]);
-  });
-
-  it("IP-C3: emits exactly one cue on started → delayed and clears on complete", async () => {
-    const { policy } = await createPolicy();
-
-    policy.observe({
-      kind: "delegate_state",
-      contextId: "turn-1",
-      timestampMs: 1000,
-      toolCallPhase: "started",
-    });
-    expect(
-      policy.observe({
-        kind: "delegate_state",
-        contextId: "turn-1",
-        timestampMs: 3000,
-        toolCallPhase: "delayed",
-      }),
-    ).toEqual([{ kind: "backchannel", cue: "mm_hmm" }]);
-    expect(
-      policy.observe({
-        kind: "delegate_state",
-        contextId: "turn-1",
-        timestampMs: 3200,
-        toolCallPhase: "delayed",
-      }),
-    ).toEqual([]);
-    policy.observe({
-      kind: "delegate_state",
-      contextId: "turn-1",
-      timestampMs: 4000,
-      toolCallPhase: "complete",
-    });
-    policy.observe({
-      kind: "delegate_state",
-      contextId: "turn-1",
-      timestampMs: 5000,
-      toolCallPhase: "started",
-    });
-    expect(
-      policy.observe({
-        kind: "delegate_state",
-        contextId: "turn-1",
-        timestampMs: 7000,
-        toolCallPhase: "delayed",
-      }),
-    ).toEqual([{ kind: "backchannel", cue: "mm_hmm" }]);
-  });
-
-  it("IP-C3: suppresses backchannel when TTS is active or the user is speaking", async () => {
-    const { ttsPlayout, policy } = await createPolicy();
-    ttsPlayout.noteAudio("assistant-turn", 500, 1000);
-
-    policy.observe({
-      kind: "delegate_state",
-      contextId: "turn-1",
-      timestampMs: 1000,
-      toolCallPhase: "started",
-    });
-    expect(
-      policy.observe({
-        kind: "delegate_state",
-        contextId: "turn-1",
-        timestampMs: 3000,
-        toolCallPhase: "delayed",
-      }),
-    ).toEqual([]);
-
-    ttsPlayout.release("assistant-turn");
-    policy.observe({
-      kind: "delegate_state",
-      contextId: "turn-2",
-      timestampMs: 4000,
-      toolCallPhase: "started",
-    });
-    policy.observe({
-      kind: "vad_speech_started",
-      contextId: "user",
-      timestampMs: 4100,
-      confidence: 0.9,
-      interruptedContextId: "",
-    });
-    expect(
-      policy.observe({
-        kind: "delegate_state",
-        contextId: "turn-2",
-        timestampMs: 6000,
-        toolCallPhase: "delayed",
-      }),
-    ).toEqual([]);
-  });
-
-  it("IP-C3: reset clears delegate-gap backchannel state", async () => {
-    const { policy } = await createPolicy();
-
-    policy.observe({
-      kind: "delegate_state",
-      contextId: "turn-1",
-      timestampMs: 1000,
-      toolCallPhase: "started",
-    });
-    policy.reset("turn-1");
-    expect(
-      policy.observe({
-        kind: "delegate_state",
-        contextId: "turn-1",
-        timestampMs: 3000,
-        toolCallPhase: "delayed",
-      }),
-    ).toEqual([]);
-  });
-
-  it("reset clears pending state", async () => {
-    const { ttsPlayout, policy } = await createPolicy(280);
-    ttsPlayout.noteAudio("assistant-turn", 100, 1000);
-
-    const t0 = 4000;
-    policy.observe({
-      kind: "vad_speech_started",
-      contextId: "user",
-      timestampMs: t0,
-      confidence: 0.99,
-      interruptedContextId: "assistant-turn",
-    });
-    policy.reset("user");
-
-    const decisions = policy.observe({
-      kind: "vad_speech_activity",
-      contextId: "user",
-      timestampMs: t0 + 300,
-    });
-    expect(decisions).toEqual([]);
-  });
-});