@kodelyth/voice-call 2026.5.42 → 2026.6.2

package/src/manager/timers.test.ts

@@ -1,127 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const { persistCallRecordMock } = vi.hoisted(() => ({
-  persistCallRecordMock: vi.fn(),
-}));
-
-vi.mock("./store.js", () => ({
-  persistCallRecord: persistCallRecordMock,
-}));
-
-import {
-  clearMaxDurationTimer,
-  clearTranscriptWaiter,
-  rejectTranscriptWaiter,
-  resolveTranscriptWaiter,
-  startMaxDurationTimer,
-  waitForFinalTranscript,
-} from "./timers.js";
-
-describe("voice-call manager timers", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("starts and clears max duration timers, persisting timeout metadata before delegation", async () => {
-    const call = { id: "call-1", state: "active" };
-    const ctx = {
-      activeCalls: new Map([["call-1", call]]),
-      maxDurationTimers: new Map(),
-      config: { maxDurationSeconds: 5 },
-      storePath: "/tmp/voice-call",
-    };
-    const onTimeout = vi.fn(async () => {});
-
-    startMaxDurationTimer({
-      ctx: ctx as never,
-      callId: "call-1",
-      onTimeout,
-    });
-
-    expect(ctx.maxDurationTimers.has("call-1")).toBe(true);
-
-    await vi.advanceTimersByTimeAsync(5_000);
-
-    expect(call).toEqual({ id: "call-1", state: "active", endReason: "timeout" });
-    expect(persistCallRecordMock).toHaveBeenCalledWith("/tmp/voice-call", call);
-    expect(onTimeout).toHaveBeenCalledWith("call-1");
-    expect(ctx.maxDurationTimers.has("call-1")).toBe(false);
-
-    startMaxDurationTimer({
-      ctx: ctx as never,
-      callId: "call-1",
-      onTimeout,
-    });
-    clearMaxDurationTimer(ctx as never, "call-1");
-    expect(ctx.maxDurationTimers.has("call-1")).toBe(false);
-  });
-
-  it("does not time out terminal calls", async () => {
-    const ctx = {
-      activeCalls: new Map([["call-1", { id: "call-1", state: "completed" }]]),
-      maxDurationTimers: new Map(),
-      config: { maxDurationSeconds: 5 },
-      storePath: "/tmp/voice-call",
-    };
-    const onTimeout = vi.fn(async () => {});
-
-    startMaxDurationTimer({
-      ctx: ctx as never,
-      callId: "call-1",
-      onTimeout,
-    });
-
-    await vi.advanceTimersByTimeAsync(5_000);
-
-    expect(persistCallRecordMock).not.toHaveBeenCalled();
-    expect(onTimeout).not.toHaveBeenCalled();
-  });
-
-  it("waits for transcripts, resolves matching tokens, rejects mismatches and timeouts", async () => {
-    const ctx = {
-      transcriptWaiters: new Map(),
-      config: { transcriptTimeoutMs: 1_000 },
-    };
-
-    const pending = waitForFinalTranscript(ctx as never, "call-1", "turn-1");
-    expect(resolveTranscriptWaiter(ctx as never, "call-1", "ignored", "turn-2")).toBe(false);
-    expect(resolveTranscriptWaiter(ctx as never, "call-1", "final transcript", "turn-1")).toBe(
-      true,
-    );
-    await expect(pending).resolves.toBe("final transcript");
-
-    const another = waitForFinalTranscript(ctx as never, "call-2");
-    rejectTranscriptWaiter(ctx as never, "call-2", "provider failed");
-    await expect(another).rejects.toThrow("provider failed");
-
-    const timedOut = waitForFinalTranscript(ctx as never, "call-3").catch((error) => error);
-    await vi.advanceTimersByTimeAsync(1_000);
-    const timeoutError = await timedOut;
-    expect(timeoutError).toBeInstanceOf(Error);
-    expect((timeoutError as Error).message).toBe("Timed out waiting for transcript after 1000ms");
-
-    const toClear = waitForFinalTranscript(ctx as never, "call-4");
-    clearTranscriptWaiter(ctx as never, "call-4");
-    expect(ctx.transcriptWaiters.has("call-4")).toBe(false);
-    void toClear.catch(() => {});
-  });
-
-  it("rejects duplicate transcript waiters for the same call", async () => {
-    const ctx = {
-      transcriptWaiters: new Map(),
-      config: { transcriptTimeoutMs: 1_000 },
-    };
-
-    const pending = waitForFinalTranscript(ctx as never, "call-1");
-    await expect(waitForFinalTranscript(ctx as never, "call-1")).rejects.toThrow(
-      "Already waiting for transcript",
-    );
-    rejectTranscriptWaiter(ctx as never, "call-1", "done");
-    await expect(pending).rejects.toThrow("done");
-  });
-});

package/src/manager/timers.ts

@@ -1,113 +0,0 @@
-import { TerminalStates, type CallId } from "../types.js";
-import type { CallManagerContext } from "./context.js";
-import { persistCallRecord } from "./store.js";
-
-type TimerContext = Pick<
-  CallManagerContext,
-  "activeCalls" | "maxDurationTimers" | "config" | "storePath" | "transcriptWaiters"
->;
-type MaxDurationTimerContext = Pick<
-  TimerContext,
-  "activeCalls" | "maxDurationTimers" | "config" | "storePath"
->;
-type TranscriptWaiterContext = Pick<TimerContext, "transcriptWaiters">;
-
-export function clearMaxDurationTimer(
-  ctx: Pick<MaxDurationTimerContext, "maxDurationTimers">,
-  callId: CallId,
-): void {
-  const timer = ctx.maxDurationTimers.get(callId);
-  if (timer) {
-    clearTimeout(timer);
-    ctx.maxDurationTimers.delete(callId);
-  }
-}
-
-export function startMaxDurationTimer(params: {
-  ctx: MaxDurationTimerContext;
-  callId: CallId;
-  onTimeout: (callId: CallId) => Promise<void>;
-  timeoutMs?: number;
-}): void {
-  clearMaxDurationTimer(params.ctx, params.callId);
-
-  const maxDurationMs = params.timeoutMs ?? params.ctx.config.maxDurationSeconds * 1000;
-  console.log(
-    `[voice-call] Starting max duration timer (${Math.ceil(maxDurationMs / 1000)}s) for call ${params.callId}`,
-  );
-
-  const timer = setTimeout(async () => {
-    params.ctx.maxDurationTimers.delete(params.callId);
-    const call = params.ctx.activeCalls.get(params.callId);
-    if (call && !TerminalStates.has(call.state)) {
-      console.log(
-        `[voice-call] Max duration reached (${Math.ceil(maxDurationMs / 1000)}s), ending call ${params.callId}`,
-      );
-      call.endReason = "timeout";
-      persistCallRecord(params.ctx.storePath, call);
-      await params.onTimeout(params.callId);
-    }
-  }, maxDurationMs);
-
-  params.ctx.maxDurationTimers.set(params.callId, timer);
-}
-
-export function clearTranscriptWaiter(ctx: TranscriptWaiterContext, callId: CallId): void {
-  const waiter = ctx.transcriptWaiters.get(callId);
-  if (!waiter) {
-    return;
-  }
-  clearTimeout(waiter.timeout);
-  ctx.transcriptWaiters.delete(callId);
-}
-
-export function rejectTranscriptWaiter(
-  ctx: TranscriptWaiterContext,
-  callId: CallId,
-  reason: string,
-): void {
-  const waiter = ctx.transcriptWaiters.get(callId);
-  if (!waiter) {
-    return;
-  }
-  clearTranscriptWaiter(ctx, callId);
-  waiter.reject(new Error(reason));
-}
-
-export function resolveTranscriptWaiter(
-  ctx: TranscriptWaiterContext,
-  callId: CallId,
-  transcript: string,
-  turnToken?: string,
-): boolean {
-  const waiter = ctx.transcriptWaiters.get(callId);
-  if (!waiter) {
-    return false;
-  }
-  if (waiter.turnToken && waiter.turnToken !== turnToken) {
-    return false;
-  }
-  clearTranscriptWaiter(ctx, callId);
-  waiter.resolve(transcript);
-  return true;
-}
-
-export function waitForFinalTranscript(
-  ctx: TimerContext,
-  callId: CallId,
-  turnToken?: string,
-): Promise<string> {
-  if (ctx.transcriptWaiters.has(callId)) {
-    return Promise.reject(new Error("Already waiting for transcript"));
-  }
-
-  const timeoutMs = ctx.config.transcriptTimeoutMs;
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      ctx.transcriptWaiters.delete(callId);
-      reject(new Error(`Timed out waiting for transcript after ${timeoutMs}ms`));
-    }, timeoutMs);
-
-    ctx.transcriptWaiters.set(callId, { resolve, reject, timeout, turnToken });
-  });
-}

package/src/manager/twiml.test.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { generateNotifyTwiml } from "./twiml.js";
-
-describe("generateNotifyTwiml", () => {
-  it("renders escaped xml with the requested voice", () => {
-    expect(generateNotifyTwiml(`Call <ended> & "logged"`, "Polly.Joanna"))
-      .toBe(`<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Say voice="Polly.Joanna">Call &lt;ended&gt; &amp; &quot;logged&quot;</Say>
-  <Hangup/>
-</Response>`);
-  });
-});

package/src/manager/twiml.ts

@@ -1,17 +0,0 @@
-import { escapeXml } from "../voice-mapping.js";
-
-export function generateNotifyTwiml(message: string, voice: string): string {
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Say voice="${voice}">${escapeXml(message)}</Say>
-  <Hangup/>
-</Response>`;
-}
-
-export function generateDtmfRedirectTwiml(digits: string, webhookUrl: string): string {
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Play digits="${escapeXml(digits)}" />
-  <Redirect method="POST">${escapeXml(webhookUrl)}</Redirect>
-</Response>`;
-}

package/src/manager.closed-loop.test.ts

@@ -1,259 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createManagerHarness, FakeProvider, markCallAnswered } from "./manager.test-harness.js";
-
-function requireCall(
-  manager: Awaited<ReturnType<typeof createManagerHarness>>["manager"],
-  callId: string,
-) {
-  const call = manager.getCall(callId);
-  if (!call) {
-    throw new Error(`expected active call ${callId}`);
-  }
-  return call;
-}
-
-function requireTurnToken(provider: Awaited<ReturnType<typeof createManagerHarness>>["provider"]) {
-  const firstStart = provider.startListeningCalls[0];
-  if (!firstStart?.turnToken) {
-    throw new Error("expected closed-loop turn to capture a turn token");
-  }
-  return firstStart.turnToken;
-}
-
-function expectTranscriptWaiter(
-  manager: Awaited<ReturnType<typeof createManagerHarness>>["manager"],
-  callId: string,
-) {
-  const waiters = (
-    manager as unknown as {
-      transcriptWaiters: Map<string, unknown>;
-    }
-  ).transcriptWaiters;
-  expect(waiters.has(callId)).toBe(true);
-}
-
-describe("CallManager closed-loop turns", () => {
-  it("completes a closed-loop turn without live audio", async () => {
-    const { manager, provider } = await createManagerHarness({
-      transcriptTimeoutMs: 5000,
-    });
-
-    const started = await manager.initiateCall("+15550000003");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-closed-loop-answered");
-
-    const turnPromise = manager.continueCall(started.callId, "How can I help?");
-    await vi.waitFor(() => {
-      expect(provider.startListeningCalls).toHaveLength(1);
-      expectTranscriptWaiter(manager, started.callId);
-    });
-
-    manager.processEvent({
-      id: "evt-closed-loop-speech",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "Please check status",
-      isFinal: true,
-    });
-
-    const turn = await turnPromise;
-    expect(turn.success).toBe(true);
-    expect(turn.transcript).toBe("Please check status");
-    expect(provider.startListeningCalls).toHaveLength(1);
-    expect(provider.stopListeningCalls).toHaveLength(1);
-
-    const call = requireCall(manager, started.callId);
-    expect(call.transcript.map((entry) => entry.text)).toEqual([
-      "How can I help?",
-      "Please check status",
-    ]);
-    const metadata = call.metadata ?? {};
-    expect(typeof metadata.lastTurnLatencyMs).toBe("number");
-    expect(typeof metadata.lastTurnListenWaitMs).toBe("number");
-    expect(metadata.turnCount).toBe(1);
-  });
-
-  it("rejects overlapping continueCall requests for the same call", async () => {
-    const { manager, provider } = await createManagerHarness({
-      transcriptTimeoutMs: 5000,
-    });
-
-    const started = await manager.initiateCall("+15550000004");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-overlap-answered");
-
-    const first = manager.continueCall(started.callId, "First prompt");
-    const second = await manager.continueCall(started.callId, "Second prompt");
-    expect(second.success).toBe(false);
-    expect(second.error).toBe("Already waiting for transcript");
-
-    manager.processEvent({
-      id: "evt-overlap-speech",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "Done",
-      isFinal: true,
-    });
-
-    const firstResult = await first;
-    expect(firstResult.success).toBe(true);
-    expect(firstResult.transcript).toBe("Done");
-    expect(provider.startListeningCalls).toHaveLength(1);
-    expect(provider.stopListeningCalls).toHaveLength(1);
-  });
-
-  it("ignores speech events with mismatched turnToken while waiting for transcript", async () => {
-    const { manager, provider } = await createManagerHarness(
-      {
-        transcriptTimeoutMs: 5000,
-      },
-      new FakeProvider("twilio"),
-    );
-
-    const started = await manager.initiateCall("+15550000004");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-turn-token-answered");
-
-    const turnPromise = manager.continueCall(started.callId, "Prompt");
-    await vi.waitFor(() => {
-      expect(provider.startListeningCalls).toHaveLength(1);
-      expectTranscriptWaiter(manager, started.callId);
-    });
-
-    const expectedTurnToken = requireTurnToken(provider);
-
-    manager.processEvent({
-      id: "evt-turn-token-bad",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "stale replay",
-      isFinal: true,
-      turnToken: "wrong-token",
-    });
-
-    expectTranscriptWaiter(manager, started.callId);
-
-    manager.processEvent({
-      id: "evt-turn-token-good",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "final answer",
-      isFinal: true,
-      turnToken: expectedTurnToken,
-    });
-
-    const turnResult = await turnPromise;
-    expect(turnResult.success).toBe(true);
-    expect(turnResult.transcript).toBe("final answer");
-
-    const call = requireCall(manager, started.callId);
-    expect(call.transcript.map((entry) => entry.text)).toEqual(["Prompt", "final answer"]);
-  });
-
-  it("tracks latency metadata across multiple closed-loop turns", async () => {
-    const { manager, provider } = await createManagerHarness({
-      transcriptTimeoutMs: 5000,
-    });
-
-    const started = await manager.initiateCall("+15550000005");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-multi-answered");
-
-    const firstTurn = manager.continueCall(started.callId, "First question");
-    await vi.waitFor(() => {
-      expect(provider.startListeningCalls).toHaveLength(1);
-      expectTranscriptWaiter(manager, started.callId);
-    });
-    manager.processEvent({
-      id: "evt-multi-speech-1",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "First answer",
-      isFinal: true,
-    });
-    await firstTurn;
-
-    const secondTurn = manager.continueCall(started.callId, "Second question");
-    await vi.waitFor(() => {
-      expect(provider.startListeningCalls).toHaveLength(2);
-      expectTranscriptWaiter(manager, started.callId);
-    });
-    manager.processEvent({
-      id: "evt-multi-speech-2",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "Second answer",
-      isFinal: true,
-    });
-    const secondResult = await secondTurn;
-
-    expect(secondResult.success).toBe(true);
-
-    const call = requireCall(manager, started.callId);
-    expect(call.transcript.map((entry) => entry.text)).toEqual([
-      "First question",
-      "First answer",
-      "Second question",
-      "Second answer",
-    ]);
-    const metadata = call.metadata ?? {};
-    expect(metadata.turnCount).toBe(2);
-    expect(typeof metadata.lastTurnLatencyMs).toBe("number");
-    expect(typeof metadata.lastTurnListenWaitMs).toBe("number");
-    expect(provider.startListeningCalls).toHaveLength(2);
-    expect(provider.stopListeningCalls).toHaveLength(2);
-  });
-
-  it("handles repeated closed-loop turns without waiter churn", async () => {
-    const { manager, provider } = await createManagerHarness({
-      transcriptTimeoutMs: 5000,
-    });
-
-    const started = await manager.initiateCall("+15550000006");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-loop-answered");
-
-    for (let i = 1; i <= 5; i++) {
-      const turnPromise = manager.continueCall(started.callId, `Prompt ${i}`);
-      await vi.waitFor(() => {
-        expect(provider.startListeningCalls).toHaveLength(i);
-        expectTranscriptWaiter(manager, started.callId);
-      });
-      manager.processEvent({
-        id: `evt-loop-speech-${i}`,
-        type: "call.speech",
-        callId: started.callId,
-        providerCallId: "request-uuid",
-        timestamp: Date.now(),
-        transcript: `Answer ${i}`,
-        isFinal: true,
-      });
-      const result = await turnPromise;
-      expect(result.success).toBe(true);
-      expect(result.transcript).toBe(`Answer ${i}`);
-    }
-
-    const call = requireCall(manager, started.callId);
-    const metadata = call.metadata ?? {};
-    expect(metadata.turnCount).toBe(5);
-    expect(provider.startListeningCalls).toHaveLength(5);
-    expect(provider.stopListeningCalls).toHaveLength(5);
-  });
-});