@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/channels/telegram-adapter.test.mjs

@@ -1,306 +0,0 @@
-/**
- * telegram-adapter.test.mjs — node:test coverage for telegram/adapter.mjs
- *
- * Exercises `_toEvent` for DM vs group vs topic vs reaction vs voice using a
- * FAKE grammY update object — the real `grammy` package is NEVER required
- * (the adapter accepts an injected bot, and _toEvent is called directly).
- * Hermetic: no network, no grammy install needed.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { TelegramAdapter, createTelegramChannel } from "./telegram/adapter.mjs";
-import { getPlatform } from "./contract.mjs";
-
-async function makeRoot() {
-  const p = join(tmpdir(), `tg-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(p, { recursive: true });
-  return p;
-}
-async function rmRoot(p) { try { await fsp.rm(p, { recursive: true, force: true }); } catch { /* */ } }
-
-/** A fake grammY Bot: records api calls, lets the test drive handlers. */
-function fakeBot() {
-  const handlers = {};
-  const calls = { sendMessage: [], setMessageReaction: [], sendChatAction: [], getFile: [] };
-  return {
-    handlers,
-    calls,
-    on(type, fn) { handlers[type] = fn; },
-    start() { return Promise.resolve(); },
-    stop() { return Promise.resolve(); },
-    api: {
-      getMe: async () => ({ id: 555, username: "ravi_bot" }),
-      sendMessage: async (chatId, text, extra) => { calls.sendMessage.push({ chatId, text, extra }); return { message_id: 99 }; },
-      setMessageReaction: async (chatId, mid, reactions) => { calls.setMessageReaction.push({ chatId, mid, reactions }); return true; },
-      sendChatAction: async (chatId, action, extra) => { calls.sendChatAction.push({ chatId, action, extra }); return true; },
-      getFile: async (fileId) => { calls.getFile.push(fileId); return { file_path: "voice/file_1.ogg" }; },
-    },
-  };
-}
-
-function adapterWith(bot, opts = {}) {
-  return new TelegramAdapter({ agentRoot: opts.agentRoot || "/tmp", bot, botId: "555", botUsername: "ravi_bot", token: "T", ...opts });
-}
-
-// ---------------------------------------------------------------------------
-// _toEvent — DM
-// ---------------------------------------------------------------------------
-
-test("_toEvent: private chat → DM message event", () => {
-  const a = adapterWith(fakeBot());
-  const ev = a._toEvent({
-    _kind: "message",
-    update: {
-      message: {
-        message_id: 12,
-        date: 1735689600,
-        text: "hey can you draft the memo?",
-        chat: { id: 987, type: "private" },
-        from: { id: 987, first_name: "Casey", username: "casey" },
-      },
-    },
-  });
-  assert.equal(ev.channel, "telegram");
-  assert.equal(ev.kind, "message");
-  assert.equal(ev.message_id, "12");
-  assert.equal(ev.channel_id, "987");
-  assert.equal(ev.source.userScope, "dm");
-  assert.equal(ev.source.chatId, "987");
-  assert.equal(ev.priority_signals.mentions_agent, true, "DM always mentions agent");
-  assert.equal(ev.raw_ref, "telegram:987:12");
-  assert.match(ev.subject, /^DM from/);
-  assert.equal(ev.ingest_source, "telegram");
-});
-
-test("_toEvent: drops the bot's own messages", () => {
-  const a = adapterWith(fakeBot());
-  const ev = a._toEvent({
-    _kind: "message",
-    update: { message: { message_id: 1, chat: { id: 1, type: "private" }, from: { id: 555 }, text: "echo" } },
-  });
-  assert.equal(ev, null, "self message must be dropped");
-});
-
-// ---------------------------------------------------------------------------
-// _toEvent — group + @mention + cc
-// ---------------------------------------------------------------------------
-
-test("_toEvent: group message without mention → not directed", () => {
-  const a = adapterWith(fakeBot());
-  const ev = a._toEvent({
-    _kind: "message",
-    update: {
-      message: {
-        message_id: 30, date: 1735689600, text: "general chatter",
-        chat: { id: -100123, type: "supergroup", title: "ops" },
-        from: { id: 42, first_name: "Sam" },
-      },
-    },
-  });
-  assert.equal(ev.source.userScope, "group");
-  assert.equal(ev.kind, "message");
-  assert.equal(ev.priority_signals.mentions_agent, false);
-  assert.equal(ev.channel_id, "-100123");
-});
-
-test("_toEvent: group message that @mentions the bot → directed", () => {
-  const a = adapterWith(fakeBot());
-  const ev = a._toEvent({
-    _kind: "message",
-    update: {
-      message: {
-        message_id: 31, date: 1735689600,
-        text: "@ravi_bot can you look at this",
-        entities: [{ type: "mention", offset: 0, length: 9 }],
-        chat: { id: -100123, type: "supergroup", title: "ops" },
-        from: { id: 42, first_name: "Sam" },
-      },
-    },
-  });
-  assert.equal(ev.priority_signals.mentions_agent, true);
-});
-
-test("_toEvent: cc_groups makes a non-mention group message a channel_cc", async () => {
-  const root = await makeRoot();
-  try {
-    const a = adapterWith(fakeBot(), { agentRoot: root, config: { cc_groups: ["-100999"] } });
-    const ev = a._toEvent({
-      _kind: "message",
-      update: {
-        message: {
-          message_id: 40, date: 1735689600, text: "status update for the room",
-          chat: { id: -100999, type: "supergroup", title: "watched" },
-          from: { id: 7, first_name: "Jordan" },
-        },
-      },
-    });
-    assert.equal(ev.kind, "channel_cc");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// _toEvent — topic (forum thread)
-// ---------------------------------------------------------------------------
-
-test("_toEvent: forum topic message maps message_thread_id → thread", () => {
-  const a = adapterWith(fakeBot());
-  const ev = a._toEvent({
-    _kind: "message",
-    update: {
-      message: {
-        message_id: 50, date: 1735689600, text: "in the deployments topic",
-        message_thread_id: 777,
-        chat: { id: -100555, type: "supergroup", title: "eng" },
-        from: { id: 8, first_name: "Pat" },
-      },
-    },
-  });
-  assert.equal(ev.thread_id, "777");
-  assert.equal(ev.source.threadRef, "777");
-  assert.equal(ev.is_reply, true, "topic messages count as threaded");
-});
-
-// ---------------------------------------------------------------------------
-// _toEvent — reaction
-// ---------------------------------------------------------------------------
-
-test("_toEvent: message_reaction → reaction event", () => {
-  const a = adapterWith(fakeBot());
-  const ev = a._toEvent({
-    _kind: "reaction",
-    update: {
-      message_reaction: {
-        message_id: 60, date: 1735689600,
-        chat: { id: 987, type: "private" },
-        user: { id: 987, first_name: "Casey", username: "casey" },
-        new_reaction: [{ type: "emoji", emoji: "👍" }],
-        old_reaction: [],
-      },
-    },
-  });
-  assert.equal(ev.kind, "reaction");
-  assert.equal(ev.reaction.emoji, "👍");
-  assert.equal(ev.reaction.target_message_id, "60");
-  assert.equal(ev.source.replyToRef, "60");
-  assert.equal(ev.raw_ref, "telegram:987:60:reaction");
-});
-
-// ---------------------------------------------------------------------------
-// _toEvent — voice note
-// ---------------------------------------------------------------------------
-
-test("_toEvent: voice note → voice_note kind + attachment + STT marker", () => {
-  const a = adapterWith(fakeBot());
-  const ev = a._toEvent({
-    _kind: "message",
-    update: {
-      message: {
-        message_id: 70, date: 1735689600,
-        voice: { file_id: "VOICE123", mime_type: "audio/ogg", file_size: 4096 },
-        chat: { id: 987, type: "private" },
-        from: { id: 987, first_name: "Casey" },
-      },
-    },
-  });
-  assert.equal(ev.kind, "voice_note");
-  const vn = ev.attachments.find((x) => x.type === "voice_note");
-  assert.ok(vn, "voice_note attachment present");
-  assert.equal(vn.size_bytes, 4096);
-  assert.equal(ev._voiceFileId, "VOICE123", "STT marker carries the file id");
-});
-
-test("voice STT enrichment routes transcript into text + attachment (fail-open ready)", async () => {
-  const root = await makeRoot();
-  try {
-    const bot = fakeBot();
-    // Inject a fake transcriber + intercept the file download.
-    const a = new TelegramAdapter({
-      agentRoot: root, bot, botId: "555", botUsername: "ravi_bot", token: "T",
-      transcribeVoiceNote: async () => "transcribed words",
-    });
-    // Stub _downloadFile so we don't hit the network.
-    a._downloadFile = async () => Buffer.from("oggbytes");
-    const ev = a._toEvent({
-      _kind: "message",
-      update: { message: { message_id: 71, date: 1735689600, voice: { file_id: "V", mime_type: "audio/ogg", file_size: 10 }, chat: { id: 987, type: "private" }, from: { id: 987, first_name: "Casey" } } },
-    });
-    const enriched = await a._enrichVoice(ev);
-    assert.equal(enriched.text, "transcribed words");
-    assert.equal(enriched.attachments.find((x) => x.type === "voice_note").transcript, "transcribed words");
-  } finally { await rmRoot(root); }
-});
-
-test("voice STT failure is fail-open (event still flows, empty transcript)", async () => {
-  const root = await makeRoot();
-  try {
-    const bot = fakeBot();
-    const a = new TelegramAdapter({
-      agentRoot: root, bot, botId: "555", token: "T",
-      transcribeVoiceNote: async () => { throw new Error("whisper down"); },
-    });
-    a._downloadFile = async () => Buffer.from("x");
-    const ev = a._toEvent({ _kind: "message", update: { message: { message_id: 72, date: 1, voice: { file_id: "V" }, chat: { id: 9, type: "private" }, from: { id: 9 } } } });
-    const enriched = await a._enrichVoice(ev); // must not throw
-    assert.equal(enriched.text, "", "transcript stays empty on STT failure");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// outbound + typing
-// ---------------------------------------------------------------------------
-
-test("_send honours thread_ref and reply", async () => {
-  const bot = fakeBot();
-  const a = adapterWith(bot);
-  await a._send({ to: 987, text: "hi", thread_ref: 777, reply: 12 });
-  const call = bot.calls.sendMessage[0];
-  assert.equal(call.chatId, 987);
-  assert.equal(call.text, "hi");
-  assert.equal(call.extra.message_thread_id, 777);
-  assert.deepEqual(call.extra.reply_parameters, { message_id: 12 });
-});
-
-test("_react calls setMessageReaction with the emoji", async () => {
-  const bot = fakeBot();
-  const a = adapterWith(bot);
-  await a._react({ to: 987, messageRef: 60, emoji: "🎉" });
-  const call = bot.calls.setMessageReaction[0];
-  assert.equal(call.chatId, 987);
-  assert.equal(call.mid, 60);
-  assert.deepEqual(call.reactions, [{ type: "emoji", emoji: "🎉" }]);
-});
-
-test("_setTyping sends a typing chat action only for on=true", async () => {
-  const bot = fakeBot();
-  const a = adapterWith(bot);
-  await a._setTyping({ chatId: 987 }, true);
-  await a._setTyping({ chatId: 987 }, false); // no-op (auto-expires)
-  assert.equal(bot.calls.sendChatAction.length, 1);
-  assert.equal(bot.calls.sendChatAction[0].action, "typing");
-});
-
-// ---------------------------------------------------------------------------
-// platform self-registration
-// ---------------------------------------------------------------------------
-
-test("telegram self-registers as a platform with the right gate file", () => {
-  const def = getPlatform("telegram");
-  assert.ok(def, "telegram platform must be registered on import");
-  assert.equal(def.gateFile, "config/telegram.yaml");
-  assert.equal(typeof def.factory, "function");
-  // Factory returns an adapter instance.
-  const inst = def.factory({ agentRoot: "/tmp", bot: fakeBot(), token: "T" });
-  assert.equal(inst.name, "telegram");
-});
-
-test("createTelegramChannel returns a TelegramAdapter", () => {
-  const inst = createTelegramChannel({ agentRoot: "/tmp", bot: fakeBot(), token: "T" });
-  assert.ok(inst instanceof TelegramAdapter);
-  assert.ok(typeof inst.start === "function");
-  assert.ok(typeof inst.send === "function");
-});

package/lib/channels/voice/adapter.test.mjs

@@ -1,278 +0,0 @@
-/**
- * adapter.test.mjs — Voice channel adapter as a BaseAdapter subclass.
- * Run: node --test lib/channels/voice/adapter.test.mjs
- *
- * Task #30 hardening (PARTIAL refactor — see adapter docblock): the voice
- * adapter used to be a plain factory object that bypassed BaseAdapter, so its
- * outbound `send()` (a live PSTN call brief, or a TTS voice message) was
- * UNGATED. It now extends BaseAdapter, so:
- *   - send() runs the ONE shared send-gate on the SPOKEN text/brief BEFORE the
- *     call/message is placed (banned-phrase / AI-disclosure / barrier screening);
- *   - inbound from the agent itself / a peer agent is dropped (bot-loop guard);
- *   - each live call's provider is supervised so a mid-call drop is surfaced +
- *     counted (RECONNECT_DOWN) instead of dying silently.
- *
- * Hermetic: no Twilio, no OpenAI, no network. The outbound transport (_send) is
- * overridden in a test subclass so a clean send is observed without placing a
- * real call; the per-call supervisor is injected.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { EventEmitter } from "node:events";
-
-import { createVoiceChannel, VoiceAdapter } from "./adapter.mjs";
-import { CHANNEL_COUNTERS } from "../base-adapter.mjs";
-import { CONN_STATE } from "../../util/reconnect.mjs";
-import { VOICE_EVENTS } from "../../voice/provider.mjs";
-
-async function makeRoot() {
-  const p = join(tmpdir(), `voice-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  await fsp.mkdir(p, { recursive: true });
-  return p;
-}
-async function rmRoot(p) { try { await fsp.rm(p, { recursive: true, force: true }); } catch { /* */ } }
-
-/**
- * A VoiceAdapter whose _send is recorded (not really placing a call) so we can
- * assert the gate path and outbound routing without Twilio/OpenAI.
- */
-class RecordingVoice extends VoiceAdapter {
-  constructor(opts) { super(opts); this.sent = []; }
-  async _send(out) { this.sent.push(out); return { ok: true, message_id: "rec-1", raw: { out } }; }
-}
-
-function makeVoice(opts = {}) {
-  const counters = [];
-  const a = new (opts.cls || RecordingVoice)({
-    agentRoot: opts.agentRoot,
-    bump: (name, attrs) => { counters.push({ name, attrs }); return 1; },
-    screenOutbound: opts.screenOutbound || (async () => ({ allow: true, reason: "" })),
-    ...opts,
-  });
-  return { a, counters, countOf: (name) => counters.filter((c) => c.name === name).length };
-}
-
-// ---------------------------------------------------------------------------
-// shape
-// ---------------------------------------------------------------------------
-
-test("createVoiceChannel returns a VoiceAdapter (BaseAdapter subclass)", () => {
-  const ch = createVoiceChannel({ agentRoot: "/tmp/x" });
-  assert.ok(ch instanceof VoiceAdapter);
-  assert.equal(ch.name, "voice");
-  assert.equal(typeof ch.start, "function");
-  assert.equal(typeof ch.send, "function");
-  assert.equal(typeof ch.sipHandler, "function");
-});
-
-// ---------------------------------------------------------------------------
-// send-gate (P0-3) — every voice send is screened before the transport runs
-// ---------------------------------------------------------------------------
-
-test("send() blocks a banned-phrase TTS message before the transport", async () => {
-  const root = await makeRoot();
-  try {
-    const { a, countOf } = makeVoice({ agentRoot: root, screenOutbound: undefined });
-    a._screenOutbound = (await import("../../comms/send-gate.mjs")).screenOutbound;
-    const res = await a.send({
-      to: "+14155550123",
-      text: "Sure — as an AI I can read that to you.",
-      source: { channel: "voice", chatId: "+14155550123" },
-    });
-    assert.equal(res.ok, false);
-    assert.equal(res.blocked, true);
-    assert.match(res.reason, /banned AI-tell|As an AI/i);
-    assert.equal(a.sent.length, 0, "the transport must never run for a blocked message");
-    assert.equal(countOf(CHANNEL_COUNTERS.SEND_GATE_BLOCKED), 1);
-  } finally { await rmRoot(root); }
-});
-
-test("send() screens the SPOKEN brief on the conversational call path (blocks a disclosure violation)", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeVoice({ agentRoot: root, screenOutbound: undefined });
-    a._screenOutbound = (await import("../../comms/send-gate.mjs")).screenOutbound;
-    // brief — not text — carries what is spoken; the gate must still see it.
-    const res = await a.send({
-      to: "+14155550123",
-      brief: "Open by saying: I'm not a bot, I'm a real person.",
-      conversational: true,
-      source: { channel: "voice", chatId: "+14155550123" },
-    });
-    assert.equal(res.ok, false);
-    assert.equal(res.blocked, true);
-    assert.match(res.reason, /disclosure|denies AI/i);
-    assert.equal(a.sent.length, 0, "a disclosure-violating brief never places a call");
-  } finally { await rmRoot(root); }
-});
-
-test("send() lets a clean TTS message reach the transport with the right args", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeVoice({ agentRoot: root }); // allow-all gate stub
-    const res = await a.send({ to: "C012345678", text: "your 3pm is confirmed", meta: { transport: "slack" } });
-    assert.equal(res.ok, true);
-    assert.equal(a.sent.length, 1);
-    assert.equal(a.sent[0].to, "C012345678");
-    assert.equal(a.sent[0].text, "your 3pm is confirmed");
-  } finally { await rmRoot(root); }
-});
-
-test("send() lets a clean conversational brief reach the transport (brief routed through)", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeVoice({ agentRoot: root });
-    const res = await a.send({ to: "+14155550123", brief: "remind them about the board pack", conversational: true });
-    assert.equal(res.ok, true);
-    assert.equal(a.sent.length, 1);
-    // The override copies brief→text for the gate; _send reads text||brief.
-    assert.equal(a.sent[0].text || a.sent[0].brief, "remind them about the board pack");
-  } finally { await rmRoot(root); }
-});
-
-test("_send requires `to`", async () => {
-  // Use the REAL _send (via a bare VoiceAdapter) but only the validation branch.
-  const a = new VoiceAdapter({ agentRoot: "/tmp", screenOutbound: async () => ({ allow: true }) });
-  await assert.rejects(() => a._send({ text: "hi" }), /to required/);
-});
-
-// ---------------------------------------------------------------------------
-// per-call supervision (P0-6) — a mid-call provider drop is surfaced + counted
-// ---------------------------------------------------------------------------
-
-test("a live-call provider CLOSED reports the drop to the per-call supervisor (counted)", async () => {
-  const root = await makeRoot();
-  try {
-    // Inject a fake per-call supervisor so the drop lifecycle is deterministic.
-    let cfg = null;
-    let downReason = null;
-    let stopped = false;
-    const fakeSuperviseCall = (c) => {
-      cfg = c;
-      Promise.resolve().then(() => c.connect()).then(() => c.onState(CONN_STATE.UP, { attempt: 1, reconnected: false }));
-      return {
-        notifyDown: (reason) => { downReason = reason; c.onState(CONN_STATE.DOWN, { attempt: 1, delayMs: 500, reason }); },
-        stop: () => { stopped = true; },
-        get state() { return CONN_STATE.DOWN; }, get connection() { return null; }, get attempts() { return 0; },
-        started: Promise.resolve(),
-      };
-    };
-    const { a, countOf } = makeVoice({ agentRoot: root, superviseCall: fakeSuperviseCall });
-    await a.start({ onInbound: () => {} });
-
-    // Stand in a fake provider (EventEmitter) and attach a call.
-    const provider = new EventEmitter();
-    provider.connect = async () => {};
-    provider.close = () => {};
-    a._attachCall(provider, { callId: "call-1", body: { from: "+1999" } });
-    assert.ok(cfg, "a per-call supervisor was built");
-    assert.equal(a._liveSessions.size, 1, "the call is tracked live");
-
-    // The provider drops mid-call.
-    provider.emit(VOICE_EVENTS.CLOSED, { reason: "ws-closed" });
-    assert.match(String(downReason), /ws-closed/, "the drop was reported to the supervisor");
-    assert.equal(countOf(CHANNEL_COUNTERS.RECONNECT_DOWN), 1, "the drop was counted (not silent)");
-    assert.equal(stopped, true, "the supervisor is stopped on teardown (no zombie)");
-    assert.equal(a._liveSessions.size, 0, "the dropped session is removed");
-  } finally { await rmRoot(root); }
-});
-
-test("the per-call supervisor falls back cleanly if it can't be built (fail-open)", async () => {
-  const root = await makeRoot();
-  try {
-    const throwingSupervise = () => { throw new Error("no supervisor"); };
-    const { a } = makeVoice({ agentRoot: root, superviseCall: throwingSupervise });
-    await a.start({ onInbound: () => {} });
-    const provider = new EventEmitter();
-    provider.connect = async () => {};
-    provider.close = () => {};
-    assert.doesNotThrow(() => a._attachCall(provider, { callId: "c2", body: {} }));
-    // A close still tears the session down cleanly.
-    provider.emit(VOICE_EVENTS.CLOSED, { reason: "x" });
-    assert.equal(a._liveSessions.size, 0);
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// bot-loop guard — an inbound call from a peer agent is dropped
-// ---------------------------------------------------------------------------
-
-test("a call-connect event from a peer agent is dropped (bot-loop guard)", async () => {
-  const root = await makeRoot();
-  try {
-    const { a, countOf } = makeVoice({ agentRoot: root, peerAgentIds: ["+1888"], superviseCall: () => ({ notifyDown(){}, stop(){}, get state(){return CONN_STATE.UP;}, get connection(){return null;}, get attempts(){return 0;}, started: Promise.resolve() }) });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    const provider = new EventEmitter();
-    provider.connect = async () => {};
-    provider.close = () => {};
-    a._attachCall(provider, { callId: "c3", body: { from: "+1888" } });
-    assert.equal(received.length, 0, "a peer-agent call must not be auto-handled");
-    assert.equal(countOf(CHANNEL_COUNTERS.PEER_AGENT_DROPPED), 1);
-  } finally { await rmRoot(root); }
-});
-
-test("a call-connect event from a human flows to onInbound", async () => {
-  const root = await makeRoot();
-  try {
-    const { a } = makeVoice({ agentRoot: root, superviseCall: () => ({ notifyDown(){}, stop(){}, get state(){return CONN_STATE.UP;}, get connection(){return null;}, get attempts(){return 0;}, started: Promise.resolve() }) });
-    const received = [];
-    await a.start({ onInbound: (ev) => received.push(ev) });
-    const provider = new EventEmitter();
-    provider.connect = async () => {};
-    provider.close = () => {};
-    a._attachCall(provider, { callId: "c4", body: { from: "+1777" } });
-    assert.equal(received.length, 1, "a human call connect is recorded in the inbox");
-    assert.equal(received[0].kind, "call");
-    assert.equal(received[0].message_id, "c4");
-    assert.equal(received[0].source.channel, "voice");
-  } finally { await rmRoot(root); }
-});
-
-// ---------------------------------------------------------------------------
-// facade behaviour preserved
-// ---------------------------------------------------------------------------
-
-test("sipHandler() returns a function (the mounted webhook handler)", () => {
-  // buildSipInboundHandler asserts OPENAI_API_KEY is present (same as before the
-  // refactor) — set a dummy so we can assert the handler shape without network.
-  const prev = process.env.OPENAI_API_KEY;
-  process.env.OPENAI_API_KEY = "sk-test-dummy";
-  try {
-    const a = createVoiceChannel({ agentRoot: "/tmp/x" });
-    assert.equal(typeof a.sipHandler(), "function");
-  } finally {
-    if (prev === undefined) delete process.env.OPENAI_API_KEY;
-    else process.env.OPENAI_API_KEY = prev;
-  }
-});
-
-test("healthCheck reports the live-session count", async () => {
-  const a = createVoiceChannel({ agentRoot: "/tmp/x" });
-  const hc = await a.healthCheck();
-  assert.equal(hc.ok, true);
-  assert.match(hc.detail, /0 active session/);
-});
-
-test("stop() closes live sessions and stops their supervisors", async () => {
-  const root = await makeRoot();
-  try {
-    let stopped = 0;
-    const { a } = makeVoice({ agentRoot: root, superviseCall: () => ({ notifyDown(){}, stop(){ stopped += 1; }, get state(){return CONN_STATE.UP;}, get connection(){return null;}, get attempts(){return 0;}, started: Promise.resolve() }) });
-    await a.start({ onInbound: () => {} });
-    let closed = false;
-    const provider = new EventEmitter();
-    provider.connect = async () => {};
-    provider.close = () => { closed = true; };
-    a._attachCall(provider, { callId: "c5", body: {} });
-    await a.stop();
-    assert.equal(closed, true, "the live provider was closed");
-    assert.equal(stopped >= 1, true, "the per-call supervisor was stopped");
-    assert.equal(a._liveSessions.size, 0);
-  } finally { await rmRoot(root); }
-});