@kuralle-syrinx/server-workers 2.1.1 → 3.1.0

package/src/worker-runtime.test.ts

@@ -9,6 +9,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { Miniflare } from "miniflare";
 import { afterEach, describe, expect, it } from "vitest";
+import { decodeMuLawToPcm16, encodePcm16ToMuLaw } from "@kuralle-syrinx/core/audio";
 
 const execFileAsync = promisify(execFile);
 const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
@@ -58,6 +59,7 @@ function newMiniflare(script: string, bindings: Record<string, unknown>): Minifl
     compatibilityFlags: ["nodejs_compat"],
     durableObjects: {
       VOICE_CONVERSATIONS: { className: "VoiceConversation", useSQLite: true },
+      TWILIO_VOICE_CONVERSATIONS: { className: "TwilioVoiceConversation", useSQLite: true },
     },
     vectorize: {
       VECTORIZE: { dimensions: 1536, metric: "cosine", index_name: "kuralle-university-kb" },
@@ -163,6 +165,148 @@ describe("VoiceConversation worker runtime", () => {
   );
 });
 
+describe("TwilioVoiceConversation worker runtime", () => {
+  // Deterministic, no keys: the Twilio Media Streams front accepts a WS upgrade at /twilio
+  // through withVoice(Agent, { transport: "twilio" }) — the cf-agents telephony front bundles
+  // and boots in workerd.
+  it("accepts a Twilio Media Streams WebSocket upgrade at /twilio", async () => {
+    const script = await buildWorker();
+    const mf = newMiniflare(script, {});
+    try {
+      const response = await mf.dispatchFetch("http://localhost/twilio?sessionId=twilio-boot", {
+        headers: { Upgrade: "websocket" },
+      });
+      expect(response.status).toBe(101);
+      const ws = (response as unknown as Response & { webSocket?: WorkersWebSocket }).webSocket;
+      expect(ws).toBeTruthy();
+      ws!.accept();
+      ws!.close();
+    } finally {
+      await mf.dispose();
+    }
+  }, 20_000);
+
+  // Deterministic: the Twilio Voice webhook returns TwiML that bridges the call to /twilio.
+  it("returns <Connect><Stream> TwiML from /incoming-call pointing at /twilio", async () => {
+    const script = await buildWorker();
+    const mf = newMiniflare(script, {});
+    try {
+      const res = await mf.dispatchFetch("http://localhost/incoming-call", {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: "CallSid=CA0123456789abcdef&From=%2B15551234567",
+      });
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("text/xml");
+      const twiml = await res.text();
+      expect(twiml).toContain("<Connect>");
+      expect(twiml).toContain("<Stream");
+      // The Twilio CallSid becomes the /twilio sessionId.
+      expect(twiml).toContain("/twilio?sessionId=CA0123456789abcdef");
+    } finally {
+      await mf.dispose();
+    }
+  }, 20_000);
+
+  // Live: EMULATE A PSTN CALL — speak the Twilio Media Streams protocol (connected/start/media
+  // as base64 μ-law 8 kHz) at /twilio and assert the agent answers with non-silent μ-law media
+  // frames on the phone leg. No carrier, no phone number — the protocol is just a WebSocket.
+  it.skipIf(!liveTurnEnabled)(
+    "answers an emulated Twilio Media Streams call end-to-end in workerd",
+    async () => {
+      expect(existsSync(TURN_DETECTION_FIXTURE)).toBe(true);
+      const pcm16k = readWav16kMono(TURN_DETECTION_FIXTURE);
+      const pcm8k = downsampleTo8k(pcm16k);
+      const script = await buildWorker();
+      const mf = newMiniflare(script, liveEnv);
+      try {
+        const response = await mf.dispatchFetch("http://localhost/twilio?sessionId=twilio-live", {
+          headers: { Upgrade: "websocket" },
+        });
+        expect(response.status).toBe(101);
+        const ws = (response as unknown as Response & { webSocket?: WorkersWebSocket }).webSocket;
+        expect(ws).toBeTruthy();
+
+        let downlinkFrames = 0;
+        let downlinkPeak = 0;
+        let clearReceived = false;
+        ws!.addEventListener("message", (event) => {
+          const data = event.data as string | ArrayBuffer;
+          if (typeof data !== "string" || !data.startsWith("{")) return;
+          const msg = JSON.parse(data) as Record<string, unknown>;
+          if (msg.event === "media") {
+            downlinkFrames += 1;
+            const media = msg.media as { payload?: string } | undefined;
+            if (media?.payload) {
+              const pcm = decodeMuLawToPcm16(base64ToBytes(media.payload));
+              for (const s of pcm) downlinkPeak = Math.max(downlinkPeak, Math.abs(s));
+            }
+          } else if (msg.event === "clear") {
+            clearReceived = true;
+          }
+        });
+        ws!.accept();
+
+        const streamSid = "MZtwiliolivesmoke";
+        ws!.send(JSON.stringify({ event: "connected", protocol: "Call", version: "1.0.0" }));
+        ws!.send(JSON.stringify({
+          event: "start",
+          streamSid,
+          start: { streamSid, callSid: "CAtwiliolivesmoke", mediaFormat: { encoding: "audio/x-mulaw", sampleRate: 8000, channels: 1 } },
+        }));
+
+        const sendMulaw = (frame: Int16Array): void => {
+          ws!.send(JSON.stringify({
+            event: "media",
+            streamSid,
+            media: { payload: bytesToBase64(encodePcm16ToMuLaw(frame)) },
+          }));
+        };
+
+        const frameSamples8k = 160; // 20ms at 8 kHz
+        for (let offset = 0; offset < pcm8k.length; offset += frameSamples8k) {
+          const frame = new Int16Array(frameSamples8k);
+          frame.set(pcm8k.subarray(offset, Math.min(offset + frameSamples8k, pcm8k.length)));
+          sendMulaw(frame);
+          await sleep(20);
+        }
+
+        // Pad silence until the agent answers (Deepgram endpointing + kuralle + TTS).
+        const deadline = Date.now() + 60_000;
+        while (downlinkFrames === 0 && Date.now() < deadline) {
+          sendMulaw(new Int16Array(frameSamples8k));
+          await sleep(20);
+        }
+
+        ws!.send(JSON.stringify({ event: "stop", streamSid }));
+        ws!.close();
+
+        // eslint-disable-next-line no-console
+        console.log(`[twilio-live] downlink media frames=${downlinkFrames} peak=${downlinkPeak} clear=${clearReceived}`);
+        expect(downlinkFrames).toBeGreaterThan(0);
+        expect(downlinkPeak).toBeGreaterThan(100); // non-silent answer on the phone leg
+      } finally {
+        await mf.dispose();
+      }
+    },
+    120_000,
+  );
+});
+
+function downsampleTo8k(samples: Int16Array): Int16Array {
+  const out = new Int16Array(Math.floor(samples.length / 2));
+  for (let i = 0; i < out.length; i += 1) out[i] = samples[i * 2]!;
+  return out;
+}
+
+function base64ToBytes(value: string): Uint8Array {
+  return new Uint8Array(Buffer.from(value, "base64"));
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+  return Buffer.from(bytes).toString("base64");
+}
+
 function firstSessionError(messages: ReadonlyArray<string | ArrayBuffer>): string | null {
   for (const m of messages) {
     if (typeof m !== "string") continue;

package/src/worker.ts

@@ -1,18 +1,24 @@
 // SPDX-License-Identifier: MIT
+//
+// Cloudflare Workers cascaded voice host, built on `withVoice(Agent)` (issue #10 / W1).
+// The Durable Object IS an `agents` SDK Agent: it provides hibernation, the
+// `keepAlive()` lease, `Connection` lifecycle, and SQLite natively — so the prior
+// manual alarm scheduler, durable session store, WebSocket lifecycle, and the 1012
+// eviction-orphan workaround are gone. The brain is the `reasoner` param; the
+// pipeline (Deepgram STT/TTS + kuralle) lives in live-session.ts.
 
+import { Agent } from "agents";
+import { withVoice } from "@kuralle-syrinx/cf-agents";
+import { R2EdgeRecorder } from "@kuralle-syrinx/cf-agents/r2-recorder";
 import {
-  createVoiceEdgeWebSocketUpgrade,
-  type VoiceEdgeWebSocketUpgrade,
-} from "@kuralle-syrinx/server-websocket/edge";
-import { createTwilioEdgeWebSocketUpgrade } from "@kuralle-syrinx/server-websocket/edge-twilio";
-import type { WorkersInboundSocketController } from "@kuralle-syrinx/ws/workers";
-import { DurableObjectAlarmScheduler } from "./alarm-scheduler.js";
-import { DurableObjectSessionStore } from "./durable-session-store.js";
-import { createLiveVoiceAgentSession, type LiveSessionEnv } from "./live-session.js";
-import { R2EdgeRecorder } from "./r2-recorder.js";
+  createLiveReasoner,
+  liveCascadedPipeline,
+  type LiveSessionEnv,
+} from "./live-session.js";
 
 export interface Env extends LiveSessionEnv {
   VOICE_CONVERSATIONS: DurableObjectNamespace;
+  TWILIO_VOICE_CONVERSATIONS: DurableObjectNamespace;
   /** Optional: when bound, full call audio is recorded to this bucket. */
   RECORDINGS?: R2Bucket;
 }
@@ -20,20 +26,83 @@ export interface Env extends LiveSessionEnv {
 const INPUT_SAMPLE_RATE_HZ = 16000;
 const OUTPUT_SAMPLE_RATE_HZ = 16000;
 
+/** Browser/edge cascaded host (Syrinx JSON+envelope protocol over /ws). */
+export class VoiceConversation extends withVoice<Env, typeof Agent<Env>>(Agent<Env>, {
+  pipeline: liveCascadedPipeline,
+  reasoner: (env, ctx) => createLiveReasoner(env, ctx),
+  recorder: (env, { sessionId }) =>
+    env.RECORDINGS
+      ? new R2EdgeRecorder({ bucket: env.RECORDINGS, sessionId, startedAtMs: Date.now() })
+      : undefined,
+  inputSampleRateHz: INPUT_SAMPLE_RATE_HZ,
+  outputSampleRateHz: OUTPUT_SAMPLE_RATE_HZ,
+  resumeWindowMs: 15_000,
+}) {}
+
+/** Telephony cascaded host (Twilio Media Streams μ-law 8 kHz over /twilio). Same pipeline/brain. */
+export class TwilioVoiceConversation extends withVoice<Env, typeof Agent<Env>>(Agent<Env>, {
+  transport: "twilio",
+  pipeline: liveCascadedPipeline,
+  reasoner: (env, ctx) => createLiveReasoner(env, ctx),
+  inputSampleRateHz: INPUT_SAMPLE_RATE_HZ,
+  resumeWindowMs: 15_000,
+}) {}
+
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
     const url = new URL(request.url);
     if (url.pathname === "/health") return new Response("ok");
     if (url.pathname === "/recordings") return await listRecordings(url, env);
-    if (url.pathname !== "/ws" && url.pathname !== "/twilio") {
-      return new Response("not found", { status: 404 });
-    }
+    // Twilio Voice webhook: returns TwiML that bridges the inbound PSTN call to this
+    // worker's own /twilio Media Streams endpoint over a bidirectional <Stream>. Point a
+    // Twilio number's "A call comes in" webhook at https://<host>/incoming-call.
+    if (url.pathname === "/incoming-call") return await twilioIncomingCallResponse(request, url);
+    // Name-addressed routing: one DO per sessionId (callSid for telephony). The Agent
+    // (partyserver) resolves its name from ctx.id.name, so a direct stub.fetch() upgrade
+    // is valid for both transports.
     const sessionId = url.searchParams.get("sessionId") ?? crypto.randomUUID();
+    if (url.pathname === "/twilio") {
+      const id = env.TWILIO_VOICE_CONVERSATIONS.idFromName(sessionId);
+      return await env.TWILIO_VOICE_CONVERSATIONS.get(id).fetch(request);
+    }
+    if (url.pathname !== "/ws") return new Response("not found", { status: 404 });
     const id = env.VOICE_CONVERSATIONS.idFromName(sessionId);
     return await env.VOICE_CONVERSATIONS.get(id).fetch(request);
   },
 };
 
+/**
+ * Twilio Voice webhook → TwiML connecting the PSTN leg to /twilio over a bidirectional
+ * <Stream>. The Twilio CallSid becomes the session id, so the call's media stream and any
+ * resume/recording key off the same stable id.
+ */
+async function twilioIncomingCallResponse(request: Request, url: URL): Promise<Response> {
+  let callSid = url.searchParams.get("CallSid") ?? "";
+  if (!callSid && request.method === "POST") {
+    const form = await request.formData().catch(() => null);
+    const value = form?.get("CallSid");
+    if (typeof value === "string") callSid = value;
+  }
+  const sessionId = callSid || crypto.randomUUID();
+  const wsScheme = url.protocol === "https:" ? "wss" : "ws";
+  const streamUrl = `${wsScheme}://${url.host}/twilio?sessionId=${encodeURIComponent(sessionId)}`;
+  const twiml = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    "<Response>",
+    "  <Connect>",
+    `    <Stream url="${xmlEscape(streamUrl)}" />`,
+    "  </Connect>",
+    "</Response>",
+  ].join("\n");
+  return new Response(twiml, { headers: { "content-type": "text/xml; charset=utf-8" } });
+}
+
+function xmlEscape(value: string): string {
+  return value.replace(/[<>&"']/g, (c) =>
+    ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", '"': "&quot;", "'": "&apos;" })[c] ?? c,
+  );
+}
+
 /** List recorded objects for a session: GET /recordings?sessionId=<id>. */
 async function listRecordings(url: URL, env: Env): Promise<Response> {
   const sessionId = url.searchParams.get("sessionId");
@@ -41,85 +110,3 @@ async function listRecordings(url: URL, env: Env): Promise<Response> {
   const listed = await env.RECORDINGS.list({ prefix: `recordings/${sessionId}/` });
   return Response.json(listed.objects.map((o) => ({ key: o.key, size: o.size })));
 }
-
-export class VoiceConversation {
-  private readonly scheduler: DurableObjectAlarmScheduler;
-  private readonly store: DurableObjectSessionStore;
-  private activeUpgrade: VoiceEdgeWebSocketUpgrade | null = null;
-
-  constructor(
-    private readonly ctx: DurableObjectState,
-    private readonly env: Env,
-  ) {
-    this.scheduler = new DurableObjectAlarmScheduler(ctx.storage);
-    this.store = new DurableObjectSessionStore(ctx.storage, this.scheduler);
-  }
-
-  async fetch(request: Request): Promise<Response> {
-    if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
-      return new Response("expected websocket", { status: 426 });
-    }
-    const requestUrl = new URL(request.url);
-    const sessionId = requestUrl.searchParams.get("sessionId") ?? crypto.randomUUID();
-    if (requestUrl.pathname === "/twilio") {
-      const upgrade = createTwilioEdgeWebSocketUpgrade(request, {
-        sessionStore: this.store,
-        scheduler: this.scheduler,
-        createSession: () =>
-          createLiveVoiceAgentSession(this.env, {
-            sessionId,
-            inputSampleRateHz: INPUT_SAMPLE_RATE_HZ,
-            outputSampleRateHz: OUTPUT_SAMPLE_RATE_HZ,
-          }),
-        engineSampleRateHz: INPUT_SAMPLE_RATE_HZ,
-      }, {
-        acceptWebSocket: (socket) => this.ctx.acceptWebSocket(socket as WebSocket),
-      });
-      this.activeUpgrade = upgrade;
-      return upgrade.response;
-    }
-    const recorder = this.env.RECORDINGS
-      ? new R2EdgeRecorder({ bucket: this.env.RECORDINGS, sessionId, startedAtMs: Date.now() })
-      : undefined;
-    const upgrade = createVoiceEdgeWebSocketUpgrade(request, {
-      sessionStore: this.store,
-      scheduler: this.scheduler,
-      recorder,
-      createSession: () =>
-        createLiveVoiceAgentSession(this.env, {
-          sessionId,
-          inputSampleRateHz: INPUT_SAMPLE_RATE_HZ,
-          outputSampleRateHz: OUTPUT_SAMPLE_RATE_HZ,
-        }),
-      sessionId: () => sessionId,
-      inputSampleRateHz: INPUT_SAMPLE_RATE_HZ,
-      outputSampleRateHz: OUTPUT_SAMPLE_RATE_HZ,
-      resumeWindowMs: 15_000,
-    }, {
-      acceptWebSocket: (socket) => this.ctx.acceptWebSocket(socket as WebSocket),
-    });
-    this.activeUpgrade = upgrade;
-    return upgrade.response;
-  }
-
-  async alarm(): Promise<void> {
-    await this.scheduler.runDue();
-  }
-
-  webSocketMessage(_ws: WebSocket, message: string | ArrayBuffer): void {
-    this.controller?.message(message);
-  }
-
-  webSocketClose(_ws: WebSocket, code: number, reason: string): void {
-    this.controller?.close(code, reason);
-    this.activeUpgrade = null;
-  }
-
-  webSocketError(_ws: WebSocket, error: unknown): void {
-    this.controller?.error(error instanceof Error ? error : new Error(String(error)));
-  }
-
-  private get controller(): WorkersInboundSocketController | undefined {
-    return this.activeUpgrade?.controller;
-  }
-}

package/wrangler.jsonc

@@ -9,6 +9,10 @@
       {
         "name": "VOICE_CONVERSATIONS",
         "class_name": "VoiceConversation"
+      },
+      {
+        "name": "TWILIO_VOICE_CONVERSATIONS",
+        "class_name": "TwilioVoiceConversation"
       }
     ]
   },
@@ -22,6 +26,10 @@
     {
       "tag": "v1",
       "new_sqlite_classes": ["VoiceConversation"]
+    },
+    {
+      "tag": "v2",
+      "new_sqlite_classes": ["TwilioVoiceConversation"]
     }
   ],
   "vectorize": [

package/src/alarm-scheduler.test.ts

@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-import { DurableObjectAlarmScheduler } from "./alarm-scheduler.js";
-import { MemoryDurableStorage } from "./test-storage.js";
-
-describe("DurableObjectAlarmScheduler", () => {
-  it("persists deadlines, fires due callbacks, and rearms the nearest remaining task", async () => {
-    const storage = new MemoryDurableStorage();
-    const scheduler = new DurableObjectAlarmScheduler(storage);
-    const fired: string[] = [];
-
-    scheduler.schedule("late", 1000, () => {
-      fired.push("late");
-    });
-    scheduler.schedule("soon", 50, () => {
-      fired.push("soon");
-    });
-
-    expect(storage.tasks.has("soon")).toBe(true);
-    expect(storage.alarm).toBeLessThanOrEqual(Date.now() + 1000);
-
-    await scheduler.runDue(Date.now() + 100);
-
-    expect(fired).toEqual(["soon"]);
-    expect(storage.tasks.has("soon")).toBe(false);
-    expect(storage.tasks.has("late")).toBe(true);
-  });
-
-  it("cancels persisted tasks before the alarm fires", async () => {
-    const storage = new MemoryDurableStorage();
-    const scheduler = new DurableObjectAlarmScheduler(storage);
-    let fired = false;
-
-    scheduler.schedule("task", 1, () => {
-      fired = true;
-    });
-    scheduler.cancel("task");
-    await scheduler.runDue(Date.now() + 10);
-
-    expect(fired).toBe(false);
-    expect(storage.tasks.size).toBe(0);
-  });
-});

package/src/alarm-scheduler.ts

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import type { ScheduledCallback, Scheduler } from "@kuralle-syrinx/core";
-
-type SqlCursor<T> = Iterable<T>;
-
-interface SqlStorage {
-  exec(query: string, ...bindings: unknown[]): SqlCursor<Record<string, unknown>>;
-}
-
-export interface DurableSchedulerStorage {
-  readonly sql: SqlStorage;
-  setAlarm(scheduledTime: number | Date): Promise<void>;
-  deleteAlarm(): Promise<void>;
-}
-
-export class DurableObjectAlarmScheduler implements Scheduler {
-  private readonly callbacks = new Map<string, ScheduledCallback>();
-
-  constructor(private readonly storage: DurableSchedulerStorage) {
-    this.storage.sql.exec(
-      "CREATE TABLE IF NOT EXISTS scheduled_tasks (key TEXT PRIMARY KEY, deadline_ms INTEGER NOT NULL)",
-    );
-  }
-
-  schedule(key: string, delayMs: number, cb: ScheduledCallback): void {
-    const deadlineMs = Date.now() + Math.max(0, delayMs);
-    this.callbacks.set(key, cb);
-    this.storage.sql.exec(
-      "INSERT OR REPLACE INTO scheduled_tasks (key, deadline_ms) VALUES (?, ?)",
-      key,
-      deadlineMs,
-    );
-    void this.armNext();
-  }
-
-  cancel(key: string): void {
-    this.callbacks.delete(key);
-    this.storage.sql.exec("DELETE FROM scheduled_tasks WHERE key = ?", key);
-    void this.armNext();
-  }
-
-  async runDue(nowMs = Date.now()): Promise<void> {
-    const due = [...this.storage.sql.exec(
-      "SELECT key FROM scheduled_tasks WHERE deadline_ms <= ? ORDER BY deadline_ms ASC",
-      nowMs,
-    )] as Array<{ key: string }>;
-    for (const row of due) {
-      this.storage.sql.exec("DELETE FROM scheduled_tasks WHERE key = ?", row.key);
-      const cb = this.callbacks.get(row.key);
-      this.callbacks.delete(row.key);
-      if (cb) await cb();
-    }
-    await this.armNext();
-  }
-
-  private async armNext(): Promise<void> {
-    const [next] = [...this.storage.sql.exec(
-      "SELECT deadline_ms FROM scheduled_tasks ORDER BY deadline_ms ASC LIMIT 1",
-    )] as Array<{ deadline_ms: number }>;
-    if (!next) {
-      await this.storage.deleteAlarm();
-      return;
-    }
-    await this.storage.setAlarm(next.deadline_ms);
-  }
-}

package/src/durable-session-store.test.ts

@@ -1,60 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { describe, expect, it } from "vitest";
-import type { ManagedSession } from "@kuralle-syrinx/server-websocket/session-store";
-import { DurableObjectAlarmScheduler } from "./alarm-scheduler.js";
-import { DurableObjectSessionStore } from "./durable-session-store.js";
-import { MemoryDurableStorage } from "./test-storage.js";
-
-describe("DurableObjectSessionStore", () => {
-  it("persists turn metadata and restores it when the live session is recreated", async () => {
-    const storage = new MemoryDurableStorage();
-    const scheduler = new DurableObjectAlarmScheduler(storage);
-    const store = new DurableObjectSessionStore(storage, scheduler);
-
-    const first = await store.lease("s1", async () => managed("s1", "turn-a"));
-    store.update("s1", (stored) => {
-      stored.currentContextId = "turn-b";
-      stored.inputSequence.lastSequence = 7;
-    });
-    first.managed.connectionCount = 0;
-    await store.release("s1", 1000);
-
-    const recreatedStore = new DurableObjectSessionStore(storage, scheduler);
-    const second = await recreatedStore.lease("s1", async () => managed("s1", "fresh"));
-
-    expect(second.resumed).toBe(true);
-    expect(second.managed.currentContextId).toBe("turn-b");
-    expect(second.managed.inputSequence.lastSequence).toBe(7);
-  });
-
-  it("deletes retained sessions when the scheduled release fires", async () => {
-    const storage = new MemoryDurableStorage();
-    const scheduler = new DurableObjectAlarmScheduler(storage);
-    const store = new DurableObjectSessionStore(storage, scheduler);
-    const leased = await store.lease("s2", async () => managed("s2", "turn-a"));
-    leased.managed.connectionCount = 0;
-
-    await store.release("s2", 5);
-    await scheduler.runDue(Date.now() + 10);
-
-    expect(await store.get("s2")).toBeNull();
-    expect(storage.sessions.has("s2")).toBe(false);
-  });
-});
-
-function managed(id: string, currentContextId: string): ManagedSession {
-  return {
-    id,
-    session: {
-      start: async () => undefined,
-      close: async () => undefined,
-    } as ManagedSession["session"],
-    currentContextId,
-    contextSampleRates: new Map(),
-    inputSequence: { lastSequence: null },
-    turnMetricsTurns: new Map(),
-    closeTimer: null,
-    connectionCount: 0,
-  };
-}