@kuralle-syrinx/core 4.2.0 → 4.4.0

package/src/reasoner-route.test.ts

@@ -1,248 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-
-import { PipelineBusImpl } from "./pipeline-bus.js";
-import type { ConversationMetricPacket } from "./packets.js";
-import type { Reasoner, ReasonerTurn, ReasoningPart } from "./reasoner.js";
-import { RoutingReasoner } from "./reasoner-route.js";
-
-class ControllableReasoner implements Reasoner {
-  streamInvoked = false;
-  streamCallCount = 0;
-  capturedSignal: AbortSignal | undefined;
-  private deliver: ((part: ReasoningPart) => void) | null = null;
-
-  stream(turn: ReasonerTurn): AsyncIterable<ReasoningPart> {
-    this.streamInvoked = true;
-    this.streamCallCount += 1;
-    this.capturedSignal = turn.signal;
-    const queue: ReasoningPart[] = [];
-    let wake: (() => void) | null = null;
-
-    this.deliver = (part: ReasoningPart) => {
-      queue.push(part);
-      wake?.();
-      wake = null;
-    };
-
-    async function* generator(): AsyncGenerator<ReasoningPart> {
-      while (!turn.signal.aborted) {
-        if (queue.length === 0) {
-          await new Promise<void>((resolve) => {
-            if (turn.signal.aborted) {
-              resolve();
-              return;
-            }
-            wake = resolve;
-            turn.signal.addEventListener("abort", () => resolve(), { once: true });
-          });
-        }
-        if (turn.signal.aborted) return;
-        const part = queue.shift();
-        if (part === undefined) return;
-        yield part;
-        if (part.type === "error" || part.type === "suspended" || part.type === "finish") return;
-      }
-    }
-
-    return generator();
-  }
-
-  emit(part: ReasoningPart): void {
-    this.deliver?.(part);
-  }
-}
-
-function baseTurn(signal = new AbortController().signal): ReasonerTurn {
-  return { userText: "hi", messages: [{ role: "user", content: "hi" }], signal };
-}
-
-async function collect(reasoner: Reasoner, turn: ReasonerTurn): Promise<ReasoningPart[]> {
-  const parts: ReasoningPart[] = [];
-  for await (const part of reasoner.stream(turn)) {
-    parts.push(part);
-  }
-  return parts;
-}
-
-function scriptedReasoner(
-  parts: readonly ReasoningPart[],
-  hook?: (turn: ReasonerTurn) => void,
-): Reasoner {
-  return {
-    stream(turn) {
-      hook?.(turn);
-      return (async function*() {
-        for (const part of parts) {
-          if (turn.signal.aborted) return;
-          yield part;
-        }
-      })();
-    },
-  };
-}
-
-const fastParts: ReasoningPart[] = [
-  { type: "text-delta", text: "fast" },
-  { type: "finish", reason: "stop", text: "fast" },
-];
-
-const deepParts: ReasoningPart[] = [
-  { type: "text-delta", text: "deep" },
-  { type: "finish", reason: "stop", text: "deep" },
-];
-
-describe("RoutingReasoner", () => {
-  it("classify routing — fast and deep without speculation", async () => {
-    let fastInvoked = false;
-    let deepInvoked = false;
-
-    const routes = [
-      {
-        id: "fast",
-        reasoner: scriptedReasoner(fastParts, () => {
-          fastInvoked = true;
-        }),
-      },
-      {
-        id: "deep",
-        reasoner: scriptedReasoner(deepParts, () => {
-          deepInvoked = true;
-        }),
-      },
-    ];
-
-    const fastRouter = new RoutingReasoner({
-      routes,
-      classify: () => "fast",
-    });
-    const fastOutput = await collect(fastRouter, baseTurn());
-    expect(fastOutput).toEqual(fastParts);
-    expect(fastInvoked).toBe(true);
-    expect(deepInvoked).toBe(false);
-
-    fastInvoked = false;
-    deepInvoked = false;
-
-    const deepRouter = new RoutingReasoner({
-      routes,
-      classify: () => "deep",
-    });
-    const deepOutput = await collect(deepRouter, baseTurn());
-    expect(deepOutput).toEqual(deepParts);
-    expect(deepInvoked).toBe(true);
-    expect(fastInvoked).toBe(false);
-  });
-
-  it("speculation kept (agree)", async () => {
-    const fast = new ControllableReasoner();
-    const deep = new ControllableReasoner();
-    const bus = new PipelineBusImpl();
-    const started = bus.start();
-    const metrics: ConversationMetricPacket[] = [];
-    bus.on("metric.conversation", (pkt) => {
-      metrics.push(pkt as ConversationMetricPacket);
-    });
-
-    const router = new RoutingReasoner({
-      routes: [
-        { id: "fast", reasoner: fast },
-        { id: "deep", reasoner: deep },
-      ],
-      classify: () => "fast",
-      speculateRouteId: "fast",
-      bus,
-      contextId: "ctx-1",
-    });
-
-    const streamPromise = collect(router, baseTurn());
-    fast.emit({ type: "text-delta", text: "fast" });
-    fast.emit({ type: "finish", reason: "stop", text: "fast" });
-    const parts = await streamPromise;
-
-    expect(fast.streamCallCount).toBe(1);
-    expect(deep.streamInvoked).toBe(false);
-    expect(parts).toEqual(fastParts);
-    expect(metrics).toContainEqual(expect.objectContaining({ name: "route.selected", value: "fast" }));
-    expect(metrics.some((m) => m.name === "route.mispredict")).toBe(false);
-
-    bus.stop();
-    await started;
-  });
-
-  it("speculation discarded (disagree) — no forwarded part from mispredicted route", async () => {
-    const fast = new ControllableReasoner();
-    let deepInvoked = false;
-    let resolveClassify: ((id: string) => void) | undefined;
-    const classifyGate = new Promise<string>((resolve) => {
-      resolveClassify = resolve;
-    });
-
-    const bus = new PipelineBusImpl();
-    const started = bus.start();
-    const metrics: ConversationMetricPacket[] = [];
-    bus.on("metric.conversation", (pkt) => {
-      metrics.push(pkt as ConversationMetricPacket);
-    });
-
-    const router = new RoutingReasoner({
-      routes: [
-        { id: "fast", reasoner: fast },
-        {
-          id: "deep",
-          reasoner: scriptedReasoner(deepParts, () => {
-            deepInvoked = true;
-          }),
-        },
-      ],
-      classify: () => classifyGate,
-      speculateRouteId: "fast",
-      bus,
-      contextId: "ctx-2",
-    });
-
-    const streamPromise = collect(router, baseTurn());
-    await Promise.resolve();
-    fast.emit({ type: "text-delta", text: "must-not-forward" });
-    resolveClassify!("deep");
-    const parts = await streamPromise;
-
-    expect(fast.capturedSignal?.aborted).toBe(true);
-    expect(fast.streamCallCount).toBe(1);
-    expect(deepInvoked).toBe(true);
-    expect(parts).toEqual(deepParts);
-    expect(metrics).toContainEqual(expect.objectContaining({ name: "route.mispredict", value: "1" }));
-    expect(metrics).toContainEqual(expect.objectContaining({ name: "route.selected", value: "deep" }));
-
-    bus.stop();
-    await started;
-  });
-
-  it("R8 passthrough — single route equals direct stream", async () => {
-    const soleParts: ReasoningPart[] = [
-      { type: "text-delta", text: "only" },
-      { type: "finish", reason: "stop", text: "only" },
-    ];
-    const sole = scriptedReasoner(soleParts);
-    const direct = await collect(sole, baseTurn());
-
-    const router = new RoutingReasoner({
-      routes: [{ id: "only", reasoner: sole }],
-      classify: () => "only",
-    });
-    const routed = await collect(router, baseTurn());
-
-    expect(routed).toEqual(direct);
-    expect(routed).toEqual(soleParts);
-  });
-
-  it("unknown id — throws clear error", async () => {
-    const router = new RoutingReasoner({
-      routes: [{ id: "fast", reasoner: scriptedReasoner(fastParts) }],
-      classify: () => "missing",
-    });
-
-    await expect(collect(router, baseTurn())).rejects.toThrow('RoutingReasoner: unknown route id "missing"');
-  });
-});

package/src/reasoner.test.ts

@@ -1,69 +0,0 @@
-// SPDX-License-Identifier: MIT
-//
-// Compile-guard: pins the ReasoningPart union shape without runtime consumers.
-
-import { describe, expect, it } from "vitest";
-
-import type { Reasoner, ReasonerMessage, ReasonerTurn, ReasoningPart } from "./reasoner.js";
-
-describe("Reasoner seam types", () => {
-  it("reasoner_union_compile_guard", async () => {
-    const userMsg = { role: "user", content: "hi" } satisfies ReasonerMessage;
-
-    const turn: ReasonerTurn = {
-      userText: "hi",
-      messages: [userMsg],
-      signal: new AbortController().signal,
-    };
-
-    const textDeltaPart = { type: "text-delta", text: "hello" } satisfies ReasoningPart;
-    const toolCallPart = {
-      type: "tool-call",
-      toolId: "tool-1",
-      toolName: "doThing",
-      args: { input: 123 },
-    } satisfies ReasoningPart;
-    const toolResultPart = {
-      type: "tool-result",
-      toolId: "tool-1",
-      toolName: "doThing",
-      result: "ok",
-    } satisfies ReasoningPart;
-    const suspendedPart = {
-      type: "suspended",
-      runId: "run-1",
-      toolId: "tool-1",
-      prompt: "Pause for human-in-the-loop.",
-      payload: { step: 3 },
-    } satisfies ReasoningPart;
-    const errorPart = {
-      type: "error",
-      cause: new Error("backend exploded"),
-      recoverable: true,
-    } satisfies ReasoningPart;
-    const finishPart = { type: "finish", reason: "stop", text: "done" } satisfies ReasoningPart;
-
-    const emptyStream = async function*(): AsyncIterable<ReasoningPart> {
-      // Intentionally empty: this is purely a type-level compile guard.
-    };
-
-    const reasoner: Reasoner = {
-      stream: (_turn: ReasonerTurn): AsyncIterable<ReasoningPart> => emptyStream(),
-    };
-
-    const collected: ReasoningPart[] = [];
-    for await (const part of reasoner.stream(turn)) {
-      collected.push(part);
-    }
-
-    expect(collected).toEqual([]);
-    expect(textDeltaPart).toBeDefined();
-    expect(toolCallPart).toBeDefined();
-    expect(toolResultPart).toBeDefined();
-    expect(suspendedPart).toBeDefined();
-    expect(errorPart).toBeDefined();
-    expect(finishPart).toBeDefined();
-    expect(reasoner).toBeDefined();
-  });
-});
-

package/src/retry.test.ts

@@ -1,83 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it, vi } from "vitest";
-
-import { DEFAULT_RETRY_CONFIG, VOICE_PROVIDER_OUTAGE_RETRY_CONFIG, VOICE_PROVIDER_RETRY_CONFIG, readProviderRetryConfig, readRetryConfig, retryDelayMs, retryDelayWithJitterMs, waitForRetryDelay } from "./retry.js";
-
-describe("retry helpers", () => {
-  it("reads bounded retry config from plugin config", () => {
-    expect(
-      readRetryConfig({
-        retry_max_attempts: 5,
-        retry_base_delay_ms: 100,
-        retry_max_delay_ms: 900,
-      }),
-    ).toEqual({
-      maxAttempts: 5,
-      baseDelayMs: 100,
-      maxDelayMs: 900,
-    });
-  });
-
-  it("backs off exponentially up to the configured cap", () => {
-    const config = {
-      maxAttempts: 5,
-      baseDelayMs: 100,
-      maxDelayMs: 250,
-    };
-    expect(retryDelayMs(1, config)).toBe(100);
-    expect(retryDelayMs(2, config)).toBe(200);
-    expect(retryDelayMs(3, config)).toBe(250);
-  });
-
-  it("applies equal jitter: half the deterministic delay plus a random half", () => {
-    const config = { maxAttempts: 5, baseDelayMs: 100, maxDelayMs: 1000 };
-    // attempt 2 deterministic = 200 → equal-jitter range [100, 200].
-    expect(retryDelayWithJitterMs(2, config, () => 0)).toBe(100);
-    expect(retryDelayWithJitterMs(2, config, () => 1)).toBe(200);
-    expect(retryDelayWithJitterMs(2, config, () => 0.5)).toBe(150);
-  });
-
-  it("can be aborted while waiting", async () => {
-    vi.useFakeTimers();
-    const controller = new AbortController();
-    const wait = waitForRetryDelay(
-      1,
-      {
-        maxAttempts: 3,
-        baseDelayMs: 1000,
-        maxDelayMs: 1000,
-      },
-      controller.signal,
-    );
-
-    controller.abort();
-    await expect(wait).rejects.toMatchObject({ name: "AbortError" });
-    vi.useRealTimers();
-  });
-
-  it("voice-provider profile keeps fast first reconnect but raises the backoff cap", () => {
-    // Fast first reconnect (no multi-second floor → no dead air on transient blips)...
-    expect(retryDelayMs(1, VOICE_PROVIDER_RETRY_CONFIG)).toBe(250);
-    expect(retryDelayMs(1, VOICE_PROVIDER_RETRY_CONFIG)).toBe(DEFAULT_RETRY_CONFIG.baseDelayMs);
-    // ...but a patient cap for persistent provider failure (vs the 2s default).
-    expect(retryDelayMs(10, VOICE_PROVIDER_RETRY_CONFIG)).toBe(10_000);
-    expect(VOICE_PROVIDER_RETRY_CONFIG.maxAttempts).toBeGreaterThan(DEFAULT_RETRY_CONFIG.maxAttempts);
-  });
-
-  it("readProviderRetryConfig defaults to the voice-provider profile but honors overrides", () => {
-    expect(readProviderRetryConfig({})).toEqual(VOICE_PROVIDER_RETRY_CONFIG);
-    expect(readProviderRetryConfig({ retry_max_delay_ms: 3000 }).maxDelayMs).toBe(3000);
-    // The plain default profile is unchanged (intra-turn low-latency retries).
-    expect(readRetryConfig({})).toEqual(DEFAULT_RETRY_CONFIG);
-  });
-
-  it("offers a provider-outage profile with a 4s floor and 10s cap", () => {
-    expect(retryDelayMs(1, VOICE_PROVIDER_OUTAGE_RETRY_CONFIG)).toBe(4_000);
-    expect(retryDelayMs(2, VOICE_PROVIDER_OUTAGE_RETRY_CONFIG)).toBe(8_000);
-    expect(retryDelayMs(3, VOICE_PROVIDER_OUTAGE_RETRY_CONFIG)).toBe(10_000);
-    expect(readProviderRetryConfig({ retry_profile: "provider_outage" })).toEqual(VOICE_PROVIDER_OUTAGE_RETRY_CONFIG);
-    expect(readProviderRetryConfig({ retry_profile: "provider_outage", retry_base_delay_ms: 5000 }).baseDelayMs).toBe(5000);
-    expect(readRetryConfig({})).toEqual(DEFAULT_RETRY_CONFIG);
-  });
-});

package/src/route-throwing-spec.test.ts

@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Regression guard (RL-WBS-2): a mispredicted speculative route whose next() rejects must NOT leak an
-// unhandled rejection (the abandoned specNext must be caught); and a throwing route must surface, not hang.
-import { describe, expect, it } from "vitest";
-import { RoutingReasoner } from "./reasoner-route.js";
-import type { Reasoner, ReasonerTurn, ReasoningPart } from "./reasoner.js";
-
-class ThrowingReasoner implements Reasoner {
-  async *stream(_t: ReasonerTurn): AsyncGenerator<ReasoningPart> { throw new Error("spec boom"); }
-}
-class GoodReasoner implements Reasoner {
-  constructor(private readonly text: string) {}
-  async *stream(_t: ReasonerTurn): AsyncGenerator<ReasoningPart> {
-    yield { type: "text-delta", text: this.text };
-    yield { type: "finish", reason: "stop", text: this.text };
-  }
-}
-function turn(): ReasonerTurn { return { userText: "hi", messages: [], signal: new AbortController().signal }; }
-
-describe("route reject repro", () => {
-  it("mispredicted speculative route that throws must not cause an unhandled rejection", async () => {
-    const unhandled: unknown[] = [];
-    const onUnhandled = (e: unknown) => unhandled.push(e);
-    process.on("unhandledRejection", onUnhandled);
-    try {
-      const router = new RoutingReasoner({
-        routes: [
-          { id: "fast", reasoner: new ThrowingReasoner() },     // speculated → will be abandoned
-          { id: "deep", reasoner: new GoodReasoner("deep ok") }, // classify picks this (disagree)
-        ],
-        classify: () => "deep",
-        speculateRouteId: "fast",
-      });
-      const parts: string[] = [];
-      for await (const p of router.stream(turn())) if (p.type === "text-delta") parts.push(p.text);
-      expect(parts).toEqual(["deep ok"]); // no part from the discarded spec route
-      // let any dangling rejection surface
-      await new Promise((r) => setTimeout(r, 50));
-      expect(unhandled, `unhandled rejections: ${unhandled.map(String).join("; ")}`).toEqual([]);
-    } finally {
-      process.off("unhandledRejection", onUnhandled);
-    }
-  });
-});

package/src/tts-playout-clock.test.ts

@@ -1,125 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { TtsPlayoutClock } from "./tts-playout-clock.js";
-
-describe("TtsPlayoutClock", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.setSystemTime(0);
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("marks a context active on the first audio chunk", () => {
-    const clock = new TtsPlayoutClock();
-    expect(clock.isActive("c1")).toBe(false);
-    clock.noteAudio("c1", 100, Date.now());
-    expect(clock.isActive("c1")).toBe(true);
-    expect(clock.latestActive()).toBe("c1");
-  });
-
-  it("keeps a context interruptible until its playout estimate elapses, then releases", () => {
-    const clock = new TtsPlayoutClock();
-    clock.noteAudio("c1", 200, Date.now()); // playout ends at t=200
-    clock.scheduleRelease("c1", Date.now()); // 200ms remaining
-    expect(clock.isActive("c1")).toBe(true);
-    vi.advanceTimersByTime(199);
-    expect(clock.isActive("c1")).toBe(true);
-    vi.advanceTimersByTime(1);
-    expect(clock.isActive("c1")).toBe(false);
-  });
-
-  it("releases immediately when the playout estimate has already passed", () => {
-    const clock = new TtsPlayoutClock();
-    clock.noteAudio("c1", 50, Date.now());
-    vi.setSystemTime(100); // well past the 50ms estimate
-    clock.scheduleRelease("c1", Date.now());
-    expect(clock.isActive("c1")).toBe(false);
-  });
-
-  it("lets real transport playout override the estimate: the timer must not pre-empt", () => {
-    const clock = new TtsPlayoutClock();
-    clock.noteAudio("c1", 100, Date.now());
-    clock.scheduleRelease("c1", Date.now()); // estimate release at t=100
-    clock.noteProgress("c1", false); // transport now authoritative, not yet complete
-    vi.advanceTimersByTime(500); // estimate timer fires but must defer
-    expect(clock.isActive("c1")).toBe(true);
-    clock.noteProgress("c1", true); // transport says done
-    expect(clock.isActive("c1")).toBe(false);
-  });
-
-  it("advances the playout cursor across chunks instead of resetting it", () => {
-    const clock = new TtsPlayoutClock();
-    clock.noteAudio("c1", 100, Date.now()); // ends at 100
-    clock.noteAudio("c1", 100, Date.now()); // still t=0, extends to 200
-    clock.scheduleRelease("c1", Date.now());
-    vi.advanceTimersByTime(150);
-    expect(clock.isActive("c1")).toBe(true); // would have released at 100 if reset
-    vi.advanceTimersByTime(50);
-    expect(clock.isActive("c1")).toBe(false);
-  });
-
-  it("reports the most-recently-added active context as latest", () => {
-    const clock = new TtsPlayoutClock();
-    clock.noteAudio("a", 10, Date.now());
-    clock.noteAudio("b", 10, Date.now());
-    expect(clock.latestActive()).toBe("b");
-    clock.release("b");
-    expect(clock.latestActive()).toBe("a");
-    clock.release("a");
-    expect(clock.latestActive()).toBe("");
-  });
-
-  it("records playout position and returns it via positionMs", () => {
-    const clock = new TtsPlayoutClock();
-    expect(clock.positionMs("c1")).toBeUndefined();
-    clock.noteAudio("c1", 100, Date.now());
-    clock.noteProgress("c1", false, 42);
-    expect(clock.positionMs("c1")).toBe(42);
-  });
-
-  it("keeps the latest playout position across multiple progress updates", () => {
-    const clock = new TtsPlayoutClock();
-    clock.noteAudio("c1", 100, Date.now());
-    clock.noteProgress("c1", false, 10);
-    clock.noteProgress("c1", false, 55);
-    expect(clock.positionMs("c1")).toBe(55);
-  });
-
-  it("drops recorded position on release and clear", () => {
-    const clock = new TtsPlayoutClock();
-    clock.noteAudio("c1", 100, Date.now());
-    clock.noteProgress("c1", false, 30);
-    clock.release("c1");
-    expect(clock.positionMs("c1")).toBeUndefined();
-
-    clock.noteAudio("c2", 100, Date.now());
-    clock.noteProgress("c2", false, 20);
-    clock.clear();
-    expect(clock.positionMs("c2")).toBeUndefined();
-  });
-
-  it("noteProgress without position still releases on complete", () => {
-    const clock = new TtsPlayoutClock();
-    clock.noteAudio("c1", 100, Date.now());
-    clock.noteProgress("c1", false);
-    expect(clock.positionMs("c1")).toBeUndefined();
-    expect(clock.isActive("c1")).toBe(true);
-    clock.noteProgress("c1", true);
-    expect(clock.isActive("c1")).toBe(false);
-    expect(clock.positionMs("c1")).toBeUndefined();
-  });
-
-  it("clear() drops all state and cancels pending release timers", () => {
-    const clock = new TtsPlayoutClock();
-    clock.noteAudio("c1", 100, Date.now());
-    clock.scheduleRelease("c1", Date.now());
-    clock.clear();
-    expect(clock.isActive("c1")).toBe(false);
-    // A leaked timer would throw "release of cleared context" — assert none fire.
-    expect(() => vi.advanceTimersByTime(1000)).not.toThrow();
-    expect(clock.latestActive()).toBe("");
-  });
-});