voicecc 1.1.36 → 1.2.0

package/server/voice/voice-loop-bugs.test.ts

@@ -1,348 +0,0 @@
-/**
- * Tests that reproduce known voice loop bugs.
- *
- * Run: npx tsx --test server/voice/voice-loop-bugs.test.ts
- */
-
-import { test } from "node:test";
-import { strict as assert } from "node:assert";
-
-import { createClaudeSession } from "./claude-session.js";
-import type { TextChunk, ClaudeSessionConfig, ClaudeStreamEvent } from "./types.js";
-
-// ============================================================================
-// HELPERS -- Mock SDK query function
-// ============================================================================
-
-/** A single SDK event to yield, with optional delay before yielding. */
-interface MockStep {
-  /** The SDK message object to yield */
-  event: Record<string, unknown>;
-  /** Delay in ms before yielding this event (default: 0) */
-  delayMs?: number;
-}
-
-/** Events to yield for a single user turn. */
-interface MockTurn {
-  steps: MockStep[];
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-/**
- * Create a mock query function that replaces the real Claude SDK.
- * Consumes user messages from the prompt iterable and yields pre-configured
- * SDK events for each turn, with optional delays between events.
- * @param turns - Array of turn configurations, consumed in order
- * @returns A function matching the SDK query() signature (cast with `as any`)
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function createMockQueryFn(turns: MockTurn[]): any {
-  return function mockQueryFn({ prompt }: { prompt: AsyncIterable<unknown> }) {
-    let turnIndex = 0;
-
-    async function* generateEvents(): AsyncGenerator<Record<string, unknown>> {
-      for await (const _userMsg of prompt) {
-        const turn = turns[turnIndex++];
-        if (!turn) return;
-
-        for (const step of turn.steps) {
-          if (step.delayMs) await sleep(step.delayMs);
-          yield step.event;
-        }
-      }
-    }
-
-    const gen = generateEvents();
-
-    // Return an async iterable with an interrupt() method (matches SDK Query interface)
-    return Object.assign(gen, {
-      interrupt(): void { /* no-op: mock does not support real interruption */ },
-    });
-  };
-}
-
-// -- SDK message factory helpers --
-
-function makeSystemEvent(sessionId: string): Record<string, unknown> {
-  return { type: "system", session_id: sessionId };
-}
-
-function makeBlockStart(index = 0): Record<string, unknown> {
-  return {
-    type: "stream_event",
-    event: {
-      type: "content_block_start",
-      index,
-      content_block: { type: "text", text: "" },
-    },
-  };
-}
-
-function makeTextDelta(text: string, index = 0): Record<string, unknown> {
-  return {
-    type: "stream_event",
-    event: {
-      type: "content_block_delta",
-      index,
-      delta: { type: "text_delta", text },
-    },
-  };
-}
-
-function makeBlockStop(index = 0): Record<string, unknown> {
-  return {
-    type: "stream_event",
-    event: { type: "content_block_stop", index },
-  };
-}
-
-function makeAssistant(text: string): Record<string, unknown> {
-  return {
-    type: "assistant",
-    message: { content: [{ type: "text", text }] },
-  };
-}
-
-function makeResult(): Record<string, unknown> {
-  return { type: "result", is_error: false, subtype: "success" };
-}
-
-// ============================================================================
-// BUG 2: Stale Claude session events after interrupt
-// ============================================================================
-
-/**
- * Verifies that after interrupting a Claude session mid-turn, the next
- * sendMessage call only receives events from the new turn -- no stale
- * text deltas or assistant messages from the interrupted turn leak through.
- */
-test("BUG: after interrupt, next sendMessage receives stale events from previous turn", { timeout: 10_000 }, async () => {
-  const mockQueryFn = createMockQueryFn([
-    {
-      steps: [
-        { event: makeSystemEvent("test-session") },
-        { event: makeBlockStart(0) },
-        { event: makeTextDelta("Turn one response", 0) },
-        { event: makeBlockStop(0) },
-        { event: makeAssistant("Turn one response"), delayMs: 50 },
-        { event: makeResult() },
-      ],
-    },
-    {
-      steps: [
-        { event: makeBlockStart(0) },
-        { event: makeTextDelta("Turn two response", 0) },
-        { event: makeBlockStop(0) },
-        { event: makeAssistant("Turn two response") },
-        { event: makeResult() },
-      ],
-    },
-  ]);
-
-  const config: ClaudeSessionConfig = {
-    allowedTools: [],
-    permissionMode: "bypassPermissions",
-    systemPrompt: "test",
-  };
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mock needs type flexibility
-  const session = await createClaudeSession(config, mockQueryFn as any);
-
-  try {
-    const turn1Events: ClaudeStreamEvent[] = [];
-    for await (const event of session.sendMessage("turn 1 question")) {
-      turn1Events.push(event);
-      if (event.type === "text_delta") break;
-    }
-
-    assert.ok(
-      turn1Events.some((e) => e.type === "text_delta" && e.content.includes("Turn one")),
-      "Turn 1 should have yielded a text delta"
-    );
-
-    session.interrupt();
-    await sleep(10);
-
-    const turn2Events: ClaudeStreamEvent[] = [];
-    for await (const event of session.sendMessage("turn 2 question")) {
-      turn2Events.push(event);
-    }
-
-    const staleDeltas = turn2Events.filter(
-      (e) => e.type === "text_delta" && e.content.includes("Turn one")
-    );
-    assert.equal(
-      staleDeltas.length, 0,
-      `Found stale turn-1 text in turn-2 events: ${JSON.stringify(staleDeltas)}. ` +
-      `Events from the interrupted turn leaked through the event queue into the next turn.`
-    );
-
-    const turn2Deltas = turn2Events.filter(
-      (e) => e.type === "text_delta" && e.content.includes("Turn two")
-    );
-    assert.ok(
-      turn2Deltas.length > 0,
-      `Turn 2 should have yielded text deltas with 'Turn two' content, ` +
-      `but got: ${JSON.stringify(turn2Events.filter((e) => e.type === "text_delta"))}`
-    );
-  } finally {
-    await session.close();
-  }
-});
-
-// ============================================================================
-// BUG 5: Narration summaries queue up and burst at tool_end
-// ============================================================================
-
-/**
- * Verifies that periodic summaries from long-running tools are emitted
- * immediately as they're generated (via the timer), not queued up and
- * drained all at once when the tool ends.
- */
-test("BUG: narration summaries should emit immediately, not queue and burst at end", { timeout: 15_000 }, async () => {
-  const { createNarrator } = await import("./narration.js");
-
-  const emittedTexts: Array<{ text: string; timestamp: number }> = [];
-  const startTime = Date.now();
-
-  const narrator = createNarrator({
-    summaryIntervalMs: 100,
-  }, (text: string) => {
-    emittedTexts.push({ text, timestamp: Date.now() - startTime });
-  });
-
-  const toolStart: ClaudeStreamEvent = { type: "tool_start", toolName: "Write", content: "" };
-  const initialTexts = narrator.processEvent(toolStart);
-
-  for (const text of initialTexts) {
-    emittedTexts.push({ text, timestamp: Date.now() - startTime });
-  }
-
-  await new Promise((r) => setTimeout(r, 450));
-
-  const toolEnd: ClaudeStreamEvent = { type: "tool_end", content: "" };
-  const endTexts = narrator.processEvent(toolEnd);
-
-  for (const text of endTexts) {
-    emittedTexts.push({ text, timestamp: Date.now() - startTime });
-  }
-
-  const stillWorkingMessages = emittedTexts.filter(e => e.text.includes("Still working"));
-
-  assert.ok(
-    stillWorkingMessages.length >= 3,
-    `Expected at least 3 "Still working" messages over 450ms with 100ms interval, got ${stillWorkingMessages.length}`
-  );
-
-  const timestamps = stillWorkingMessages.map(e => e.timestamp);
-  const allAtEnd = timestamps.every(t => t > 400);
-
-  assert.ok(
-    !allAtEnd,
-    `All ${stillWorkingMessages.length} "Still working" messages arrived after 400ms (timestamps: ${timestamps}). ` +
-    `They were queued in pendingSummaries and drained in a burst at tool_end, ` +
-    `instead of being emitted immediately as the timer fired.`
-  );
-
-  narrator.reset();
-});
-
-// ============================================================================
-// BUG: "Thinking" is spoken at the end of thinking, not the beginning
-// ============================================================================
-
-/**
- * When the model uses extended thinking, the user should hear "Thinking..."
- * BEFORE the thinking completes -- not after. The SDK delivers the thinking
- * content_block_start event only once thinking tokens start streaming, which
- * can be seconds into the turn. The "Thinking..." announcement should arrive
- * early in the turn, before the bulk of thinking finishes.
- *
- * This test simulates a thinking block that takes 2 seconds, followed by text.
- * "Thinking..." must appear within the first second -- not after the 2s delay.
- *
- * STATUS: No fix yet. The SDK provides no early signal that thinking has started.
- * The content_block_start type="thinking" event only arrives after ~1.7s+ of API
- * latency (on top of any actual thinking time). See timing investigation in:
- *   testscripts/2026.03.10-thinking-timing/test-sdk-event-timing.mjs
- *   testscripts/2026.03.10-thinking-timing/timing.log
- */
-test.skip("BUG: 'Thinking' should be announced early, not after thinking completes", { timeout: 10_000 }, async () => {
-  // Simulate realistic SDK behaviour: the thinking content_block_start arrives
-  // late (after ~2s of thinking), then text follows shortly after.
-  function makeThinkingBlockStart(index = 0): Record<string, unknown> {
-    return {
-      type: "stream_event",
-      event: {
-        type: "content_block_start",
-        index,
-        content_block: { type: "thinking", thinking: "" },
-      },
-    };
-  }
-
-  function makeThinkingBlockStop(index = 0): Record<string, unknown> {
-    return {
-      type: "stream_event",
-      event: { type: "content_block_stop", index },
-    };
-  }
-
-  const mockQueryFn = createMockQueryFn([
-    {
-      steps: [
-        { event: makeSystemEvent("test-session") },
-        // Thinking block arrives after 2s (simulates SDK buffering)
-        { event: makeThinkingBlockStart(0), delayMs: 2000 },
-        { event: makeThinkingBlockStop(0) },
-        // Then the actual text response
-        { event: makeBlockStart(1) },
-        { event: makeTextDelta("Here is my answer.", 1) },
-        { event: makeBlockStop(1) },
-        { event: makeAssistant("Here is my answer.") },
-        { event: makeResult() },
-      ],
-    },
-  ]);
-
-  const config: ClaudeSessionConfig = {
-    allowedTools: [],
-    permissionMode: "bypassPermissions",
-    systemPrompt: "test",
-  };
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const session = await createClaudeSession(config, mockQueryFn as any);
-
-  try {
-    const events: Array<{ event: ClaudeStreamEvent; elapsedMs: number }> = [];
-    const t0 = Date.now();
-
-    for await (const event of session.sendMessage("complex question")) {
-      events.push({ event, elapsedMs: Date.now() - t0 });
-    }
-
-    // Find the "Thinking" announcement
-    const thinkingEvent = events.find(
-      (e) => e.event.type === "text_delta" && e.event.content.toLowerCase().includes("thinking")
-    );
-
-    assert.ok(
-      thinkingEvent,
-      `Expected a "Thinking..." text delta, but none was found. Events: ${JSON.stringify(events.map(e => e.event))}`
-    );
-
-    // The "Thinking..." must arrive within the first second, NOT after the 2s delay
-    assert.ok(
-      thinkingEvent!.elapsedMs < 1000,
-      `"Thinking..." was announced at ${thinkingEvent!.elapsedMs}ms, but should arrive within 1000ms. ` +
-      `It's being announced when the SDK delivers the thinking event (after thinking completes), ` +
-      `not proactively at the start of the turn.`
-    );
-  } finally {
-    await session.close();
-  }
-});

package/server/voice/voice-server.ts

@@ -1,129 +0,0 @@
-/**
- * Unified HTTP + WebSocket voice server.
- *
- * Runs on TWILIO_PORT (default 8080) and handles both Twilio and browser
- * audio connections on the same port. All other HTTP requests are proxied
- * to the dashboard server.
- *
- * Routes:
- * - POST /twilio/incoming-call → Twilio webhook handler
- * - POST /register-call        → outbound call token registration
- * - WS   /media/:token         → Twilio media stream
- * - WS   /audio?token=<token>  → Browser audio stream
- * - *                           → proxy to dashboard
- */
-
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { config } from "dotenv";
-config({ path: process.env.VOICECC_DIR ? join(process.env.VOICECC_DIR, ".env") : join(homedir(), ".voicecc", ".env") });
-
-import { createServer, request as httpRequest } from "http";
-import { WebSocketServer } from "ws";
-
-import { handleTwilioHttpRequest, handleTwilioUpgrade } from "./twilio-server.js";
-import { handleBrowserUpgrade } from "./browser-server.js";
-
-import type { IncomingMessage, ServerResponse } from "http";
-import type { Duplex } from "stream";
-
-// ============================================================================
-// CONSTANTS
-// ============================================================================
-
-const DEFAULT_PORT = 8080;
-
-/** Ping interval to keep WebSocket connections alive through tunnel (ms) */
-const PING_INTERVAL_MS = 30_000;
-
-// ============================================================================
-// MAIN ENTRYPOINT
-// ============================================================================
-
-/**
- * Start the unified voice server.
- *
- * Creates an HTTP server that routes Twilio webhooks and browser/Twilio
- * WebSocket upgrades, proxying everything else to the dashboard.
- *
- * @param dashboardPort - Dashboard server port for proxying
- * @returns Resolves when the server is listening
- */
-export async function startVoiceServer(dashboardPort: number): Promise<number> {
-  const port = parseInt(process.env.TWILIO_PORT ?? "", 10) || DEFAULT_PORT;
-
-  const server = createServer((req, res) => {
-    // Try Twilio HTTP handlers first
-    if (handleTwilioHttpRequest(req, res)) {
-      return;
-    }
-
-    // Proxy everything else to the dashboard
-    proxyToDashboard(req, res, dashboardPort);
-  });
-
-  const wss = new WebSocketServer({ noServer: true });
-
-  // Route WebSocket upgrades by path
-  server.on("upgrade", (req: IncomingMessage, socket: Duplex, head: Buffer) => {
-    const url = new URL(req.url ?? "", `http://${req.headers.host}`);
-
-    if (url.pathname.startsWith("/media/")) {
-      handleTwilioUpgrade(req, socket, head, wss);
-    } else if (url.pathname === "/audio") {
-      handleBrowserUpgrade(req, socket, head, wss);
-    } else {
-      socket.destroy();
-    }
-  });
-
-  // Periodic ping to keep connections alive through tunnel
-  setInterval(() => {
-    wss.clients.forEach((ws) => {
-      if (ws.readyState === ws.OPEN) {
-        ws.ping();
-      }
-    });
-  }, PING_INTERVAL_MS);
-
-  return new Promise<number>((resolve) => {
-    server.listen(port, () => {
-      console.log(`Voice server listening on port ${port}`);
-      resolve(port);
-    });
-  });
-}
-
-// ============================================================================
-// HELPER FUNCTIONS
-// ============================================================================
-
-/**
- * Proxy an HTTP request to the dashboard server on localhost.
- *
- * @param req - Original incoming request
- * @param res - Response to write the proxied result to
- * @param dashboardPort - Port the dashboard server is listening on
- */
-function proxyToDashboard(req: IncomingMessage, res: ServerResponse, dashboardPort: number): void {
-  const proxyReq = httpRequest(
-    {
-      hostname: "127.0.0.1",
-      port: dashboardPort,
-      path: req.url,
-      method: req.method,
-      headers: { ...req.headers, "x-forwarded-for": "127.0.0.1" },
-    },
-    (proxyRes) => {
-      res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
-      proxyRes.pipe(res);
-    },
-  );
-
-  proxyReq.on("error", () => {
-    res.writeHead(502, { "Content-Type": "text/plain" });
-    res.end("Dashboard unavailable");
-  });
-
-  req.pipe(proxyReq);
-}