@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/voice/voice.test.mjs

@@ -1,990 +0,0 @@
-/**
- * voice.test.mjs — node:test coverage for the voice subsystem.
- *
- * Tests are pure-Node: no real WebSocket, no real OpenAI. We mock the
- * provider where the real implementation needs the network.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-
-import {
-  VoiceProvider,
-  VOICE_EVENTS,
-  createProvider,
-  buildSessionConfig,
-} from "./index.mjs";
-
-import {
-  shouldRotate,
-  rotateSessionIfStale,
-  makeSummary,
-  SESSION_ROTATION_DEFAULTS,
-} from "./session-rotation.mjs";
-
-import {
-  actionsToRealtimeTools,
-  registerToolBridge,
-  loadActionClassification,
-  redactAuditValue,
-} from "./tool-bridge.mjs";
-
-import {
-  sendVoiceMessage,
-  placeOutboundCall,
-} from "./outbound.mjs";
-
-import {
-  buildMediaStreamsBridge,
-  buildSipInboundHandler,
-} from "./twilio-sip-bridge.mjs";
-
-import { createOpenAIRealtimeProvider } from "./openai-realtime.mjs";
-
-// ---------------------------------------------------------------------------
-// buildSessionConfig
-// ---------------------------------------------------------------------------
-
-test("buildSessionConfig fills defaults: gpt-realtime-2, cedar, PCM16, server_vad", () => {
-  const cfg = buildSessionConfig({}, { name: "Ravi", role: "VP AI" });
-  assert.equal(cfg.type, "realtime");
-  assert.equal(cfg.model, "gpt-realtime-2");
-  assert.equal(cfg.voice, "cedar");
-  assert.deepEqual(cfg.output_modalities, ["audio"]);
-  assert.equal(cfg.input_audio_format, "pcm16");
-  assert.equal(cfg.output_audio_format, "pcm16");
-  assert.equal(cfg.input_audio_transcription.model, "gpt-realtime-whisper");
-  assert.equal(cfg.turn_detection.type, "server_vad");
-  assert.match(cfg.instructions, /Ravi.*VP AI/);
-});
-
-test("buildSessionConfig allows full override", () => {
-  const cfg = buildSessionConfig({
-    model: "gpt-realtime-translate",
-    voice: "marin",
-    instructions: "You are a translator.",
-    turn_detection: { type: "semantic_vad", eagerness: "high" },
-    tools: [{ type: "function", name: "send_slack_message", parameters: {} }],
-  });
-  assert.equal(cfg.model, "gpt-realtime-translate");
-  assert.equal(cfg.voice, "marin");
-  assert.equal(cfg.instructions, "You are a translator.");
-  assert.equal(cfg.turn_detection.type, "semantic_vad");
-  assert.equal(cfg.tools[0].name, "send_slack_message");
-});
-
-// ---------------------------------------------------------------------------
-// createProvider — factory dispatch (without actually connecting)
-// ---------------------------------------------------------------------------
-
-test("createProvider returns an OpenAIRealtimeProvider for openai-realtime", () => {
-  const p = createProvider("openai-realtime", { apiKey: "fake" });
-  assert.ok(p instanceof VoiceProvider);
-  assert.equal(p.transport, "ws");
-  assert.equal(p.model, "gpt-realtime-2");
-});
-
-test("createProvider rejects unknown / unbuilt providers", () => {
-  assert.throws(() => createProvider("gemini-live"), /gemini-live/);
-  assert.throws(() => createProvider("claude-voice"), /claude-voice/);
-  assert.throws(() => createProvider("does-not-exist"), /unknown voice provider/);
-});
-
-// ---------------------------------------------------------------------------
-// session-rotation
-// ---------------------------------------------------------------------------
-
-test("shouldRotate returns false on a fresh session", () => {
-  const decision = shouldRotate({ turns: 0, started_at: Date.now(), recent_latencies_ms: [] });
-  assert.equal(decision.rotate, false);
-});
-
-test("shouldRotate triggers on max_turns", () => {
-  const decision = shouldRotate({ turns: 12, started_at: Date.now() });
-  assert.equal(decision.rotate, true);
-  assert.equal(decision.reason, "max_turns");
-});
-
-test("shouldRotate triggers on max_duration", () => {
-  const decision = shouldRotate({
-    turns: 2,
-    started_at: Date.now() - SESSION_ROTATION_DEFAULTS.max_duration_ms - 1000,
-  });
-  assert.equal(decision.rotate, true);
-  assert.equal(decision.reason, "max_duration");
-});
-
-test("shouldRotate triggers on p95 latency drift", () => {
-  const decision = shouldRotate({
-    turns: 3,
-    started_at: Date.now(),
-    recent_latencies_ms: [400, 500, 600, 2500, 2800],
-  });
-  assert.equal(decision.rotate, true);
-  assert.equal(decision.reason, "latency_drift");
-});
-
-test("shouldRotate respects custom thresholds", () => {
-  const decision = shouldRotate(
-    { turns: 5, started_at: Date.now() },
-    { max_turns: 3 }
-  );
-  assert.equal(decision.rotate, true);
-  assert.equal(decision.reason, "max_turns");
-});
-
-test("makeSummary keeps recent exchanges and tool activity", () => {
-  const transcript = [
-    { role: "user", text: "Hello" },
-    { role: "assistant", text: "Hi Ravi, how can I help?" },
-    { role: "user", text: "Send Alex a message that the deal is approved" },
-    { role: "assistant", text: "Confirmed. Sending now." },
-    { tool: { name: "send_slack_message", args: { channel: "@alex", text: "deal approved" } } },
-    { role: "assistant", text: "Sent." },
-  ];
-  const summary = makeSummary(transcript);
-  assert.match(summary, /Session rotated/);
-  assert.match(summary, /Send Alex/);
-  assert.match(summary, /send_slack_message/);
-  assert.match(summary, /Continue the conversation/);
-});
-
-test("makeSummary copes with empty transcript", () => {
-  assert.match(makeSummary([]), /no prior context/i);
-  assert.match(makeSummary(null), /no prior context/i);
-});
-
-test("rotateSessionIfStale skips when not stale", async () => {
-  const provider = { close: () => {}, connect: async () => {}, sendText: () => {} };
-  const result = await rotateSessionIfStale(provider, { turns: 1, started_at: Date.now() }, {
-    createNewProvider: () => { throw new Error("should not be called"); },
-  });
-  assert.equal(result.rotated, false);
-  assert.equal(result.provider, provider);
-});
-
-test("rotateSessionIfStale spins up a new provider and re-seeds with summary", async () => {
-  const oldClosed = [];
-  const oldProvider = {
-    sessionConfig: { type: "realtime", model: "gpt-realtime-2" },
-    close: (reason) => oldClosed.push(reason),
-  };
-  let newConnect = null;
-  let newText = null;
-  const newProvider = {
-    state: "idle",
-    connect: async (cfg) => { newConnect = cfg; newProvider.state = "connected"; },
-    sendText: (t) => { newText = t; },
-    close: () => {},
-  };
-  const result = await rotateSessionIfStale(
-    oldProvider,
-    {
-      turns: 15,
-      started_at: Date.now(),
-      sessionConfig: oldProvider.sessionConfig,
-      transcript: [{ role: "user", text: "ping" }, { role: "assistant", text: "pong" }],
-    },
-    { createNewProvider: () => newProvider }
-  );
-  assert.equal(result.rotated, true);
-  assert.equal(result.provider, newProvider);
-  assert.equal(result.reason, "max_turns");
-  assert.deepEqual(newConnect, oldProvider.sessionConfig);
-  assert.match(newText, /pong|Session rotated/);
-  assert.equal(oldClosed.length, 1);
-  assert.match(oldClosed[0], /rotated/);
-});
-
-// M10 — rotation keeps the old provider when the new session fails to come up.
-test("rotateSessionIfStale keeps old provider and reports rotated:false when next.connect rejects", async () => {
-  const oldClosed = [];
-  const oldProvider = {
-    state: "connected",
-    sessionConfig: { type: "realtime", model: "gpt-realtime-2" },
-    close: (reason) => oldClosed.push(reason),
-    sendText: () => { throw new Error("old provider sendText must not be touched"); },
-  };
-  let newSendTextCalled = false;
-  let newClosed = null;
-  const failingProvider = {
-    state: "idle",
-    connect: async () => { throw new Error("upstream refused"); },
-    sendText: () => { newSendTextCalled = true; },
-    close: (reason) => { newClosed = reason; },
-  };
-  const result = await rotateSessionIfStale(
-    oldProvider,
-    {
-      turns: 99,
-      started_at: Date.now(),
-      sessionConfig: oldProvider.sessionConfig,
-      transcript: [{ role: "user", text: "hi" }],
-    },
-    { createNewProvider: () => failingProvider, confirmTimeoutMs: 200 },
-  );
-  assert.equal(result.rotated, false, "must not rotate when bring-up fails");
-  assert.equal(result.provider, oldProvider, "must keep serving the old provider");
-  assert.match(result.error || "", /upstream refused/);
-  assert.equal(oldClosed.length, 0, "old provider must NOT be closed on failed rotation");
-  assert.equal(newSendTextCalled, false, "must not seed a session that never came up");
-  assert.match(newClosed || "", /rotation_failed/, "half-open new provider must be torn down");
-});
-
-// M10 — a new provider that resolves connect() but then drops before
-// confirming live must NOT cause us to cut over.
-test("rotateSessionIfStale does not cut over when new session drops before confirmed live", async () => {
-  const { EventEmitter } = await import("node:events");
-  const oldClosed = [];
-  const oldProvider = {
-    state: "connected",
-    sessionConfig: { type: "realtime" },
-    close: (r) => oldClosed.push(r),
-  };
-  const next = new EventEmitter();
-  next.state = "idle";
-  next.connect = async () => { /* resolves but never becomes healthy */ };
-  next.sendText = () => { throw new Error("should not seed a dead session"); };
-  let nextClosed = null;
-  next.close = (r) => { nextClosed = r; };
-  // Emit CLOSED shortly after connect resolves to simulate an immediate drop.
-  setImmediate(() => next.emit(VOICE_EVENTS.CLOSED, { reason: "upstream gone" }));
-
-  const result = await rotateSessionIfStale(
-    oldProvider,
-    { turns: 99, started_at: Date.now(), sessionConfig: oldProvider.sessionConfig, transcript: [] },
-    { createNewProvider: () => next, confirmTimeoutMs: 500 },
-  );
-  assert.equal(result.rotated, false);
-  assert.equal(result.provider, oldProvider);
-  assert.equal(oldClosed.length, 0);
-  assert.match(nextClosed || "", /rotation_failed/);
-});
-
-// ---------------------------------------------------------------------------
-// twilio-sip-bridge — media streams (M11) + native SIP webhook (L17)
-// ---------------------------------------------------------------------------
-
-test("buildMediaStreamsBridge: failing internal connect does NOT throw unhandled + frames drop safely (M11)", async () => {
-  // Capture any unhandled rejection for the duration of this test.
-  const unhandled = [];
-  const onUnhandled = (err) => unhandled.push(err);
-  process.on("unhandledRejection", onUnhandled);
-
-  const bridge = buildMediaStreamsBridge({ apiKey: "fake" });
-  // The real module created a provider with a real (lazy) WS connect that
-  // will reject because there's no network/key. Force a deterministic
-  // rejection by replacing the provider's socket path: easiest is to assert
-  // the bridge exposes the safety surface and that ready rejects cleanly.
-  assert.equal(typeof bridge.isConnected, "function");
-  assert.equal(typeof bridge.lastError, "function");
-
-  // ready must reject (no real upstream) but must be already-handled.
-  let readyRejected = false;
-  try { await bridge.ready; } catch { readyRejected = true; }
-  assert.equal(readyRejected, true, "ready should reject without a real upstream");
-  assert.equal(bridge.isConnected(), false, "bridge must report not-connected");
-  assert.ok(bridge.lastError(), "bridge must record the connect error");
-
-  // Forwarding a media frame on a never-connected provider must be a no-op
-  // (no throw), not forwarded into a dead provider.
-  assert.doesNotThrow(() => bridge.onTwilioFrame(JSON.stringify({
-    event: "media", media: { payload: "AAAA" },
-  })));
-
-  // Let any microtasks settle, then assert no unhandled rejection escaped.
-  await new Promise((r) => setImmediate(r));
-  process.removeListener("unhandledRejection", onUnhandled);
-  assert.equal(unhandled.length, 0, "internal connect rejection must not be unhandled");
-
-  try { bridge.close(); } catch { /* */ }
-});
-
-test("buildMediaStreamsBridge: connected provider forwards frames; closed provider drops them (M11)", async () => {
-  const bridge = buildMediaStreamsBridge({ apiKey: "fake" });
-  // Simulate a successful connect by flipping the provider live + connected.
-  const appends = [];
-  bridge.provider.appendAudio = (b64) => appends.push(b64);
-  bridge.provider.commitTurn = () => appends.push("__commit__");
-  bridge.provider.state = "connected";
-  bridge.provider.emit(VOICE_EVENTS.CONNECTED, {}); // sets connected=true
-
-  bridge.onTwilioFrame(JSON.stringify({ event: "media", media: { payload: "ZZZ" } }));
-  assert.deepEqual(appends, ["ZZZ"]);
-
-  // Now mark the provider closed — further frames must drop.
-  bridge.provider.state = "closed";
-  bridge.onTwilioFrame(JSON.stringify({ event: "media", media: { payload: "YYY" } }));
-  assert.deepEqual(appends, ["ZZZ"], "frames must drop once provider is closed");
-
-  // Swallow the (unrelated) ready rejection from the fake upstream.
-  bridge.ready.catch(() => {});
-});
-
-test("buildSipInboundHandler: failed event-WS attach tears down provider + detach (L17)", async () => {
-  // We can't easily inject the provider the handler creates, so we assert the
-  // observable contract: the handler responds 200 and never throws even when
-  // the internal connect rejects, and detach is invoked via CLOSED teardown.
-  let detachCalls = 0;
-  const handler = buildSipInboundHandler({
-    apiKey: "fake",
-    acceptedByRelay: true, // skip the /accept fetch so no network is needed
-    sessionConfig: async () => ({ type: "realtime" }),
-    attachBridges: () => () => { detachCalls += 1; },
-  });
-
-  const req = { body: { type: "realtime.call.incoming", data: { call: { id: "call_123" } } } };
-  let status = null;
-  let payload = null;
-  const res = {
-    status: (s) => { status = s; return res; },
-    json: (b) => { payload = b; },
-  };
-
-  await assert.doesNotReject(handler(req, res));
-  assert.equal(status, 200, "webhook must still 200 even if event-WS attach fails");
-  assert.equal(payload.ok, true);
-  assert.equal(payload.call_id, "call_123");
-
-  // The real provider's connect will reject (fake key/no network); give the
-  // microtask + teardown time to run, then assert detach fired.
-  await new Promise((r) => setTimeout(r, 50));
-  assert.ok(detachCalls >= 1, "detach must be invoked when the connect fails (no leak)");
-});
-
-// ---------------------------------------------------------------------------
-// openai-realtime — client vs upstream close + bounded reconnect (H4)
-// ---------------------------------------------------------------------------
-
-// A minimal fake WebSocket: EventEmitter-ish with the .on/.send/.close the
-// provider's non-addEventListener path uses.
-function makeFakeSocket() {
-  const handlers = {};
-  return {
-    on(ev, fn) { (handlers[ev] ||= []).push(fn); },
-    once(ev, fn) { (handlers[ev] ||= []).push(fn); },
-    send() { /* swallow */ },
-    close() { this._emit("close", 1000, "client"); },
-    _emit(ev, ...args) { for (const fn of (handlers[ev] || [])) fn(...args); },
-    _handlers: handlers,
-  };
-}
-
-// The provider creates the socket inside an async _connectWebSocket().then(),
-// so the socket factory hasn't run synchronously after connect() returns. Wait
-// (via microtasks) until at least `n` sockets exist before driving events.
-async function waitForSocket(sockets, n, tries = 50) {
-  while (sockets.length < n && tries-- > 0) {
-    await new Promise((r) => setImmediate(r));
-  }
-  if (sockets.length < n) throw new Error(`waitForSocket: expected ${n}, got ${sockets.length}`);
-  return sockets[n - 1];
-}
-
-test("openai-realtime: client close() does NOT trigger a reconnect (H4)", async () => {
-  let ctorCalls = 0;
-  const sockets = [];
-  const provider = createOpenAIRealtimeProvider({
-    apiKey: "fake",
-    wsCtor: () => { ctorCalls += 1; const s = makeFakeSocket(); sockets.push(s); return s; },
-  });
-  // Drive connect: the socket is created asynchronously, so wait for it then
-  // fire "open" to resolve the connect handshake.
-  const connecting = provider.connect({ type: "realtime" });
-  (await waitForSocket(sockets, 1))._emit("open");
-  await connecting;
-  assert.equal(provider.state, "connected");
-  assert.equal(ctorCalls, 1);
-
-  const closes = [];
-  provider.on(VOICE_EVENTS.CLOSED, (info) => closes.push(info));
-  provider.close("done");
-  // Now fire the underlying socket close as a consequence of client close().
-  sockets[0]._emit("close", 1000, "client");
-
-  await new Promise((r) => setImmediate(r));
-  assert.equal(ctorCalls, 1, "client close() must not reopen the socket");
-  assert.equal(provider.state, "closed");
-  assert.ok(closes.length >= 1, "client close emits CLOSED");
-});
-
-test("openai-realtime: upstream drop attempts bounded reconnect, then fails deterministically (H4)", async () => {
-  let ctorCalls = 0;
-  const sockets = [];
-  // Use a synchronous fake timer so backoff fires immediately.
-  const timers = [];
-  const fakeSetTimeout = (fn) => { timers.push(fn); return { _t: true, unref() {} }; };
-  const fakeClearTimeout = () => {};
-
-  const provider = createOpenAIRealtimeProvider({
-    apiKey: "fake",
-    maxReconnectAttempts: 2,
-    reconnectBaseDelayMs: 1,
-    setTimeout: fakeSetTimeout,
-    clearTimeout: fakeClearTimeout,
-    // Every reconnect attempt's new socket immediately errors so reconnect
-    // fails and we exhaust the budget deterministically.
-    wsCtor: () => {
-      ctorCalls += 1;
-      const s = makeFakeSocket();
-      sockets.push(s);
-      return s;
-    },
-  });
-
-  const connecting = provider.connect({ type: "realtime", model: "gpt-realtime-2" });
-  (await waitForSocket(sockets, 1))._emit("open"); // initial connect succeeds
-  await connecting;
-  assert.equal(provider.state, "connected");
-  assert.equal(ctorCalls, 1);
-
-  const errors = [];
-  const closes = [];
-  provider.on(VOICE_EVENTS.ERROR, (e) => errors.push(e));
-  provider.on(VOICE_EVENTS.CLOSED, (i) => closes.push(i));
-
-  // Simulate an UNEXPECTED upstream drop (not client-initiated).
-  sockets[0]._emit("close", 1006, "upstream gone");
-  assert.equal(provider.state, "reconnecting", "upstream drop must enter reconnecting, not closed");
-
-  // Drain the scheduled reconnect attempts. Each attempt opens a new fake
-  // socket; we make each reconnect fail by emitting 'error' before 'open'.
-  let guard = 0;
-  while (timers.length && guard++ < 10) {
-    const fn = timers.shift();
-    const before = sockets.length;
-    fn(); // runs _attemptReconnect → _connectWebSocket (creates a socket)
-    await new Promise((r) => setImmediate(r));
-    // Fail the newly created socket's connect handshake.
-    if (sockets.length > before) {
-      sockets[sockets.length - 1]._emit("error", new Error("reconnect refused"));
-      await new Promise((r) => setImmediate(r));
-    }
-  }
-
-  assert.ok(ctorCalls >= 2, "must have attempted at least one reconnect");
-  assert.equal(provider.state, "closed", "exhausted reconnect must end closed");
-  assert.ok(closes.length >= 1, "must emit CLOSED on exhaustion (not silent)");
-  assert.match(
-    String(closes[closes.length - 1].reason || ""),
-    /upstream_drop_reconnect_exhausted/,
-    "CLOSED reason must signal exhausted reconnect",
-  );
-  assert.ok(errors.length >= 1, "must surface errors during reconnect");
-});
-
-test("openai-realtime: upstream drop reconnect succeeds and re-sends session config (H4)", async () => {
-  let ctorCalls = 0;
-  const sockets = [];
-  const sent = [];
-  const timers = [];
-  const fakeSetTimeout = (fn) => { timers.push(fn); return { unref() {} }; };
-
-  const provider = createOpenAIRealtimeProvider({
-    apiKey: "fake",
-    maxReconnectAttempts: 3,
-    reconnectBaseDelayMs: 1,
-    setTimeout: fakeSetTimeout,
-    clearTimeout: () => {},
-    wsCtor: () => {
-      ctorCalls += 1;
-      const s = makeFakeSocket();
-      s.send = (data) => sent.push(data);
-      sockets.push(s);
-      return s;
-    },
-  });
-
-  const sessionCfg = { type: "realtime", model: "gpt-realtime-2", voice: "cedar" };
-  const connecting = provider.connect(sessionCfg);
-  (await waitForSocket(sockets, 1))._emit("open");
-  await connecting;
-  sent.length = 0; // ignore the initial session.update
-
-  // The provider emits VOICE_EVENTS.ERROR (== "error") during reconnect; an
-  // EventEmitter with no "error" listener throws on emit, so register one.
-  const errors = [];
-  provider.on(VOICE_EVENTS.ERROR, (e) => errors.push(e));
-
-  // Upstream drop.
-  sockets[0]._emit("close", 1006, "blip");
-  assert.equal(provider.state, "reconnecting");
-
-  // Run the scheduled reconnect; let the new socket "open" successfully.
-  assert.equal(timers.length, 1);
-  timers.shift()();
-  await new Promise((r) => setImmediate(r));
-  // The reconnect created a fresh socket; fire its open.
-  sockets[sockets.length - 1]._emit("open");
-  await new Promise((r) => setImmediate(r));
-
-  assert.equal(provider.state, "connected", "successful reconnect returns to connected");
-  assert.ok(ctorCalls >= 2, "reconnect opened a new socket");
-  // The stored session config must be re-sent via session.update.
-  const sessionUpdates = sent
-    .map((d) => { try { return JSON.parse(d); } catch { return null; } })
-    .filter((m) => m && m.type === "session.update");
-  assert.ok(sessionUpdates.length >= 1, "must re-send session.update after reconnect");
-  assert.deepEqual(sessionUpdates[0].session, sessionCfg);
-
-  provider.close("test-done");
-});
-
-// ---------------------------------------------------------------------------
-// tool-bridge
-// ---------------------------------------------------------------------------
-
-test("loadActionClassification normalises both root-shape and actions-shape", () => {
-  // We can't write YAML without js-yaml, so test the normaliser directly
-  // via the in-memory shape.
-  const out = loadActionClassification("/tmp/nonexistent-agent-root");
-  // No file → empty object.
-  assert.deepEqual(out, {});
-});
-
-test("actionsToRealtimeTools filters via include / exclude / classification", async () => {
-  // We mock the dynamic import by setting up a minimal classification.
-  // Because tool-definitions.js is real and exported, the call should
-  // succeed and return only tools that exist in include[].
-  let tools;
-  try {
-    tools = await actionsToRealtimeTools({
-      include: [],
-      exclude: [],
-      accessLevel: "voice",
-    });
-  } catch (err) {
-    // If the framework's tool-definitions.js doesn't define "voice" yet,
-    // we expect an empty array, not a crash.
-    if (/getToolsForAccessLevel/.test(err.message)) tools = [];
-    else throw err;
-  }
-  assert.ok(Array.isArray(tools), "actionsToRealtimeTools must return an array");
-});
-
-test("registerToolBridge calls executor and replies via sendToolResult", async () => {
-  const calls = [];
-  const provider = new EventEmitter();
-  provider.sendToolResult = (callId, output) => calls.push({ callId, output });
-  const teardown = registerToolBridge(provider, {
-    executor: async (name, args) => ({ ok: true, echoed: { name, args } }),
-  });
-
-  provider.emit("tool.call", {
-    call_id: "c1",
-    name: "send_slack_message",
-    arguments: { channel: "@alex", text: "hi" },
-  });
-  // Allow the async handler to flush.
-  await new Promise((r) => setImmediate(r));
-
-  assert.equal(calls.length, 1);
-  assert.equal(calls[0].callId, "c1");
-  assert.equal(calls[0].output.ok, true);
-  assert.equal(calls[0].output.echoed.name, "send_slack_message");
-  teardown();
-  // After teardown, the bridge no longer responds.
-  provider.emit("tool.call", { call_id: "c2", name: "x" });
-  await new Promise((r) => setImmediate(r));
-  assert.equal(calls.length, 1);
-});
-
-test("registerToolBridge enforces allow-list", async () => {
-  const calls = [];
-  const provider = new EventEmitter();
-  provider.sendToolResult = (callId, output) => calls.push({ callId, output });
-  registerToolBridge(provider, {
-    allow: ["send_slack_message"],
-    executor: async () => ({ should_not_run: true }),
-  });
-  provider.emit("tool.call", { call_id: "c1", name: "wire_transfer", arguments: { amount: 50000 } });
-  await new Promise((r) => setImmediate(r));
-  assert.equal(calls.length, 1);
-  assert.equal(calls[0].output.ok, false);
-  assert.equal(calls[0].output.error, "tool_not_allowed");
-});
-
-test("registerToolBridge calls audit hook for both success and error paths", async () => {
-  const auditEntries = [];
-  const provider = new EventEmitter();
-  provider.sendToolResult = () => {};
-  registerToolBridge(provider, {
-    executor: async (name) => {
-      if (name === "fails") throw new Error("kaboom");
-      return { ok: true };
-    },
-    audit: (entry) => auditEntries.push(entry),
-  });
-  provider.emit("tool.call", { call_id: "c1", name: "succeeds", arguments: {} });
-  provider.emit("tool.call", { call_id: "c2", name: "fails", arguments: {} });
-  await new Promise((r) => setImmediate(r));
-  assert.equal(auditEntries.length, 2);
-  assert.equal(auditEntries[0].error, null);
-  assert.equal(auditEntries[1].error, "kaboom");
-});
-
-// ---------------------------------------------------------------------------
-// VOICE_EVENTS constants
-// ---------------------------------------------------------------------------
-
-test("VOICE_EVENTS surface is frozen and complete", () => {
-  assert.ok(Object.isFrozen(VOICE_EVENTS));
-  for (const k of ["AUDIO_DELTA", "TRANSCRIPT_DELTA", "TOOL_CALL", "TURN_DONE", "USER_SPEECH_STARTED", "ERROR", "CLOSED"]) {
-    assert.ok(VOICE_EVENTS[k], `missing event: ${k}`);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// L12 — openai-realtime backpressure / readyState on _send + appendAudio
-// ---------------------------------------------------------------------------
-
-// A fake socket that lets a test drive readyState + bufferedAmount and records
-// everything written. (makeFakeSocket above has no numeric readyState; this one
-// does, exactly so the L12 guard can observe it.)
-function makeBackpressureSocket() {
-  return {
-    sent: [],
-    listeners: {},
-    readyState: 1, // OPEN
-    bufferedAmount: 0,
-    addEventListener(type, fn) { (this.listeners[type] ||= []).push(fn); },
-    send(data) { this.sent.push(data); },
-    close() { this.closed = true; },
-    fire(type, evt) { (this.listeners[type] || []).forEach((fn) => fn(evt)); },
-  };
-}
-
-async function connectBackpressureProvider(overrides = {}) {
-  const sockets = [];
-  const provider = createOpenAIRealtimeProvider({
-    apiKey: "sk-test",
-    wsCtor: () => { const s = makeBackpressureSocket(); sockets.push(s); return s; },
-    ...overrides,
-  });
-  const connectP = provider.connect({ voice: "cedar" });
-  const sock = await waitForSocket(sockets, 1);
-  sock.fire("open");
-  await connectP;
-  return { provider, socket: sockets[sockets.length - 1] };
-}
-
-test("openai-realtime: appendAudio forwards a frame when the socket is OPEN and drained (L12)", async () => {
-  const { provider, socket } = await connectBackpressureProvider();
-  const before = socket.sent.length; // session.update from connect()
-  provider.appendAudio("AAAA");
-  assert.equal(socket.sent.length, before + 1);
-  const last = JSON.parse(socket.sent[socket.sent.length - 1]);
-  assert.equal(last.type, "input_audio_buffer.append");
-  assert.equal(provider.droppedAudioFrames, 0);
-});
-
-test("openai-realtime: appendAudio drops frames under bufferedAmount backpressure but keeps the socket alive (L12)", async () => {
-  const { provider, socket } = await connectBackpressureProvider({ maxBufferedBytes: 100 });
-  const before = socket.sent.length;
-  socket.bufferedAmount = 1000; // over threshold → backpressured
-  provider.appendAudio("AAAA");
-  provider.appendAudio("BBBB");
-  assert.equal(socket.sent.length, before, "no audio frames written while backpressured");
-  assert.equal(provider.droppedAudioFrames, 2);
-  // Buffer drains → audio flows again (normal case keeps working).
-  socket.bufferedAmount = 0;
-  provider.appendAudio("CCCC");
-  assert.equal(socket.sent.length, before + 1);
-  assert.equal(provider.droppedAudioFrames, 2);
-});
-
-test("openai-realtime: _send / appendAudio skip a non-OPEN socket instead of throwing (L12)", async () => {
-  const { provider, socket } = await connectBackpressureProvider();
-  const before = socket.sent.length;
-  socket.readyState = 0; // CONNECTING — not OPEN
-  socket.send = () => { throw new Error("should not be called on a non-open socket"); };
-  provider.appendAudio("AAAA"); // audio path
-  provider.sendText("hi");      // control path via _send
-  assert.equal(socket.sent.length, before);
-  assert.equal(provider.droppedAudioFrames, 1);
-  // Restore an open, working socket → control frames flow again.
-  socket.readyState = 1;
-  socket.send = (d) => socket.sent.push(d);
-  provider.sendText("now");
-  assert.ok(socket.sent.length > before);
-});
-
-// ---------------------------------------------------------------------------
-// L11/L20 — tool-bridge audit redaction
-// ---------------------------------------------------------------------------
-
-function makeAuditProvider() {
-  const provider = new EventEmitter();
-  provider.sendToolResult = () => {};
-  return provider;
-}
-
-test("tool-bridge: registerToolBridge audit is RAW by default (no redaction) (L11)", async () => {
-  const audits = [];
-  const provider = makeAuditProvider();
-  const teardown = registerToolBridge(provider, {
-    executor: async () => ({ ok: true, body: "secret message body" }),
-    audit: (e) => audits.push(e),
-  });
-  provider.emit("tool.call", {
-    call_id: "c1",
-    name: "send_message",
-    arguments: { to: "+15551234567", token: "sk-live-abcdef", body: "hello there" },
-  });
-  await new Promise((r) => setImmediate(r));
-  assert.equal(audits.length, 1);
-  assert.equal(audits[0].args.token, "sk-live-abcdef");
-  assert.equal(audits[0].args.body, "hello there");
-  assert.equal(audits[0].result.body, "secret message body");
-  teardown();
-});
-
-test("tool-bridge: redactAudit masks sensitive fields + URL creds, preserves structure (L11)", async () => {
-  const audits = [];
-  const provider = makeAuditProvider();
-  const teardown = registerToolBridge(provider, {
-    redactAudit: true,
-    executor: async () => ({ ok: true, link: "https://api.example.com/x?api_key=zzz" }),
-    audit: (e) => audits.push(e),
-  });
-  provider.emit("tool.call", {
-    call_id: "c2",
-    name: "send_message",
-    arguments: { to: "+15551234567", token: "sk-live-abcdef", body: "hello" },
-  });
-  await new Promise((r) => setImmediate(r));
-  assert.equal(audits.length, 1);
-  assert.equal(audits[0].args.token, "***");
-  assert.equal(audits[0].args.body, "hello");
-  assert.equal(audits[0].args.to, "+15551234567");
-  assert.ok(audits[0].result.link.includes("api_key=***"));
-  assert.ok(!audits[0].result.link.includes("zzz"));
-  assert.equal(audits[0].name, "send_message");
-  teardown();
-});
-
-test("tool-bridge: auditAllowlist keeps only listed top-level fields (L11)", async () => {
-  const audits = [];
-  const provider = makeAuditProvider();
-  const teardown = registerToolBridge(provider, {
-    auditAllowlist: ["to"],
-    executor: async () => ({ ok: true, body: "should be dropped" }),
-    audit: (e) => audits.push(e),
-  });
-  provider.emit("tool.call", {
-    call_id: "c3",
-    name: "send_message",
-    arguments: { to: "+15551234567", body: "private body", amount: 50000 },
-  });
-  await new Promise((r) => setImmediate(r));
-  assert.equal(audits.length, 1);
-  assert.equal(audits[0].args.to, "+15551234567");
-  assert.ok(!("body" in audits[0].args));
-  assert.ok(!("amount" in audits[0].args));
-  assert.ok(!("body" in audits[0].result));
-  teardown();
-});
-
-test("tool-bridge: custom opts.redact wins and never breaks auditing (L11)", async () => {
-  const audits = [];
-  const provider = makeAuditProvider();
-  let firstCall = true;
-  const teardown = registerToolBridge(provider, {
-    executor: async () => ({ ok: true }),
-    redact: (entry) => {
-      if (firstCall) { firstCall = false; throw new Error("redactor blew up"); }
-      return { ...entry, args: { redacted: true } };
-    },
-    audit: (e) => audits.push(e),
-  });
-  provider.emit("tool.call", { call_id: "r1", name: "t", arguments: { secret: "x" } });
-  await new Promise((r) => setImmediate(r));
-  provider.emit("tool.call", { call_id: "r2", name: "t", arguments: { secret: "y" } });
-  await new Promise((r) => setImmediate(r));
-  assert.equal(audits.length, 2);
-  // First: redactor threw → fell back to the RAW entry (auditing preserved).
-  assert.equal(audits[0].args.secret, "x");
-  // Second: custom redactor applied.
-  assert.deepEqual(audits[1].args, { redacted: true });
-  teardown();
-});
-
-test("tool-bridge: redactAuditValue is pure, cycle-safe, and truncates long strings (L11)", () => {
-  const long = "a".repeat(1000);
-  const out = redactAuditValue({ password: "p", note: long, nested: { token: "t", ok: 1 } });
-  assert.equal(out.password, "***");
-  assert.equal(out.nested.token, "***");
-  assert.equal(out.nested.ok, 1);
-  assert.ok(out.note.length < long.length, "long string truncated");
-  const cyc = { a: 1 };
-  cyc.self = cyc;
-  const safe = redactAuditValue(cyc);
-  assert.equal(safe.a, 1);
-});
-
-// ---------------------------------------------------------------------------
-// L13 (text coercion) + L19 (context_delivered) — outbound dispatcher.
-//
-// These tests stub global.fetch + process.env. node:test runs top-level tests
-// concurrently, so a module-level FIFO lock serialises every stubbed section so
-// two of them never overlap (one would otherwise restore the real fetch while
-// another is mid-flight). No other test in this file touches global.fetch.
-// ---------------------------------------------------------------------------
-
-let _fetchStubLock = Promise.resolve();
-function withFetchStubLock(fn) {
-  const run = _fetchStubLock.then(fn, fn);
-  // Keep the chain alive but swallow errors so one failure doesn't poison the
-  // lock for later tests; the awaited `run` still rejects to its own caller.
-  _fetchStubLock = run.then(() => {}, () => {});
-  return run;
-}
-
-// Stub global.fetch so sendVoiceMessage runs fully offline (TTS → slack upload
-// flow → twilio call all resolve to canned responses).
-function withStubbedVoiceFetch(run) {
-  return withFetchStubLock(() => {
-    const realFetch = global.fetch;
-    const env = {
-      OPENAI_API_KEY: process.env.OPENAI_API_KEY,
-      SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN,
-      TWILIO_ACCOUNT_SID: process.env.TWILIO_ACCOUNT_SID,
-      TWILIO_AUTH_TOKEN: process.env.TWILIO_AUTH_TOKEN,
-      TWILIO_FROM_NUMBER: process.env.TWILIO_FROM_NUMBER,
-    };
-    process.env.OPENAI_API_KEY = "sk-test";
-    process.env.SLACK_BOT_TOKEN = "xoxb-test";
-    process.env.TWILIO_ACCOUNT_SID = "ACtest";
-    process.env.TWILIO_AUTH_TOKEN = "tok";
-    process.env.TWILIO_FROM_NUMBER = "+15550000000";
-
-    const okJson = (obj) => ({ ok: true, status: 200, json: async () => obj, text: async () => JSON.stringify(obj) });
-    global.fetch = async (url) => {
-      const u = String(url);
-      if (u.includes("/v1/audio/speech")) {
-        return { ok: true, status: 200, arrayBuffer: async () => new Uint8Array([1, 2, 3]).buffer };
-      }
-      if (u.includes("files.getUploadURLExternal")) {
-        return okJson({ ok: true, upload_url: "https://files.slack.test/upload", file_id: "F1" });
-      }
-      if (u.includes("files.slack.test/upload")) return { ok: true, status: 200 };
-      if (u.includes("files.completeUploadExternal")) {
-        return okJson({ ok: true, files: [{ permalink: "https://slack.test/f1" }] });
-      }
-      if (u.includes("/Calls.json")) return okJson({ sid: "CA1", status: "queued" });
-      return okJson({ ok: true });
-    };
-
-    const restore = () => {
-      global.fetch = realFetch;
-      for (const [k, v] of Object.entries(env)) {
-        if (v === undefined) delete process.env[k]; else process.env[k] = v;
-      }
-    };
-    return Promise.resolve().then(run).finally(restore);
-  });
-}
-
-function withStubbedOutboundFetch(opts, run) {
-  return withFetchStubLock(() => {
-    const realFetch = global.fetch;
-    const env = {
-      TWILIO_ACCOUNT_SID: process.env.TWILIO_ACCOUNT_SID,
-      TWILIO_AUTH_TOKEN: process.env.TWILIO_AUTH_TOKEN,
-      TWILIO_FROM_NUMBER: process.env.TWILIO_FROM_NUMBER,
-      VOICE_RELAY_URL: process.env.VOICE_RELAY_URL,
-      OPENAI_SIP_URI: process.env.OPENAI_SIP_URI,
-    };
-    process.env.TWILIO_ACCOUNT_SID = "ACtest";
-    process.env.TWILIO_AUTH_TOKEN = "tok";
-    process.env.TWILIO_FROM_NUMBER = "+15550000000";
-    if (opts.relayUrl == null) delete process.env.VOICE_RELAY_URL;
-    else process.env.VOICE_RELAY_URL = opts.relayUrl;
-    if (opts.sipUri) process.env.OPENAI_SIP_URI = opts.sipUri;
-    else delete process.env.OPENAI_SIP_URI;
-
-    const calls = [];
-    global.fetch = async (url, init) => {
-      const u = String(url);
-      calls.push({ url: u, method: init?.method });
-      if (u.includes("/Calls/") && u.endsWith(".json")) {
-        // cancel endpoint
-        return { ok: true, status: 200, json: async () => ({ sid: "CA1", status: "completed" }), text: async () => "{}" };
-      }
-      if (u.includes("/Calls.json")) {
-        return { ok: true, status: 200, json: async () => ({ sid: "CA1", status: "queued" }), text: async () => "{}" };
-      }
-      if (u.includes("/twilio/queue-outbound")) {
-        return opts.queueOk
-          ? { ok: true, status: 200, text: async () => "ok" }
-          : { ok: false, status: 500, text: async () => "relay boom" };
-      }
-      return { ok: true, status: 200, json: async () => ({}), text: async () => "{}" };
-    };
-    const restore = () => {
-      global.fetch = realFetch;
-      for (const [k, v] of Object.entries(env)) {
-        if (v === undefined) delete process.env[k]; else process.env[k] = v;
-      }
-    };
-    return Promise.resolve().then(() => run(calls)).finally(restore);
-  });
-}
-
-// L13: a non-string text (number) must flow through the delivery helpers'
-// String(text||"") coercion without throwing. The PSTN path routes the coerced
-// text into escapeXml() (the <Say> TwiML body) and slugify() — the call sites
-// that would throw on a non-string; deliverViaSlack shares the identical
-// coercion at its top.
-test("L13: sendVoiceMessage(pstn) tolerates non-string text via String(text||\"\") coercion", async () => {
-  await withStubbedVoiceFetch(async () => {
-    const r = await sendVoiceMessage({ transport: "pstn", to: "+15551234567", text: 67890 });
-    assert.equal(r.transport, "pstn");
-    assert.equal(r.message_id, "CA1");
-  });
-});
-
-test("L19: placeOutboundCall reports context_delivered:true when relay queue succeeds", async () => {
-  await withStubbedOutboundFetch({ relayUrl: "https://relay.test", queueOk: true }, async () => {
-    const r = await placeOutboundCall({ to: "+15551234567", brief: "say hi", agentRoot: "/tmp/nope-agent" });
-    assert.equal(r.transport, "media_streams");
-    assert.equal(r.context_delivered, true);
-    assert.equal(r.twilio_call_sid, "CA1");
-  });
-});
-
-test("L19: placeOutboundCall reports context_delivered:false when relay queue fails (call still proceeds)", async () => {
-  await withStubbedOutboundFetch({ relayUrl: "https://relay.test", queueOk: false }, async (calls) => {
-    const r = await placeOutboundCall({ to: "+15551234567", brief: "say hi", agentRoot: "/tmp/nope-agent" });
-    assert.equal(r.context_delivered, false);
-    assert.equal(r.twilio_call_sid, "CA1");
-    assert.ok(!calls.some((c) => c.url.includes("/Calls/CA1")), "no cancel call by default");
-  });
-});
-
-test("L19: placeOutboundCall(cancelOnContextFail) cancels the dialed call when context fails", async () => {
-  await withStubbedOutboundFetch({ relayUrl: "https://relay.test", queueOk: false }, async (calls) => {
-    const r = await placeOutboundCall({
-      to: "+15551234567",
-      brief: "say hi",
-      agentRoot: "/tmp/nope-agent",
-      cancelOnContextFail: true,
-    });
-    assert.equal(r.context_delivered, false);
-    assert.ok(calls.some((c) => c.url.includes("/Calls/CA1")), "cancel endpoint was hit");
-  });
-});
-
-test("L19: placeOutboundCall(sip) reports context_delivered:true (no relay pre-registration)", async () => {
-  await withStubbedOutboundFetch({ relayUrl: null, sipUri: "sip:proj@sip.openai.com", queueOk: true }, async () => {
-    const r = await placeOutboundCall({
-      to: "+15551234567",
-      brief: "say hi",
-      agentRoot: "/tmp/nope-agent",
-      transport: "sip",
-    });
-    assert.equal(r.transport, "sip");
-    assert.equal(r.context_delivered, true);
-  });
-});