@kuralle-syrinx/server-workers 2.1.1 → 3.1.0

package/.dev.vars.example

@@ -0,0 +1,17 @@
+# Syrinx on Cloudflare Workers — local dev secrets.
+# Copy to `.dev.vars` for `wrangler dev`; for production use `wrangler secret put <NAME>`.
+# .dev.vars is gitignored — never commit real keys.
+
+# --- Cascaded host (wrangler.jsonc → VoiceConversation / TwilioVoiceConversation) ---
+# Deepgram Nova-3 STT + Deepgram Aura TTS.
+DEEPGRAM_API_KEY=
+
+# OpenAI (the kuralle reasoner's model).
+OPENAI_API_KEY=
+
+# --- Realtime host (wrangler.realtime.jsonc → RealtimeVoiceConversation) ---
+# Front model select: "openai" (default) or "gemini".
+# REALTIME_FRONT=openai
+# OPENAI_API_KEY is reused for the OpenAI realtime front.
+# GEMINI_API_KEY=            # required when REALTIME_FRONT=gemini
+# GEMINI_LIVE_MODEL=gemini-3.1-flash-live-preview

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuralle-syrinx/server-workers",
-  "version": "2.1.1",
+  "version": "3.1.0",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -12,16 +12,19 @@
     "@kuralle-agents/rag": "^0.8.5",
     "@kuralle-agents/skills": "^0.8.5",
     "@kuralle-agents/vectorize-store": "^0.8.5",
+    "agents": "0.14.0",
     "ai": "^6.0.0",
     "zod": "^4.1.8",
-    "@kuralle-syrinx/core": "2.1.1",
-    "@kuralle-syrinx/aisdk": "2.1.1",
-    "@kuralle-syrinx/server-websocket": "2.1.1",
-    "@kuralle-syrinx/realtime": "2.1.1",
-    "@kuralle-syrinx/ws": "2.1.1",
-    "@kuralle-syrinx/kuralle": "2.1.1",
-    "@kuralle-syrinx/cartesia": "2.1.1",
-    "@kuralle-syrinx/deepgram": "2.1.1"
+    "@kuralle-syrinx/core": "3.1.0",
+    "@kuralle-syrinx/aisdk": "3.1.0",
+    "@kuralle-syrinx/cf-agents": "3.1.0",
+    "@kuralle-syrinx/server-websocket": "3.1.0",
+    "@kuralle-syrinx/kuralle": "3.1.0",
+    "@kuralle-syrinx/recorder": "3.1.0",
+    "@kuralle-syrinx/realtime": "3.1.0",
+    "@kuralle-syrinx/ws": "3.1.0",
+    "@kuralle-syrinx/deepgram": "3.1.0",
+    "@kuralle-syrinx/cartesia": "3.1.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20260601.0",

package/src/live-realtime-session.test.ts

@@ -3,34 +3,40 @@
 import { readFileSync, readdirSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { describe, expect, it, vi } from "vitest";
-import { VoiceAgentSession } from "@kuralle-syrinx/core";
-import { RealtimeBridge } from "@kuralle-syrinx/realtime";
+import { describe, expect, it } from "vitest";
 
 import {
-  createRealtimeVoiceAgentSession,
   hasRealtimeSessionCredentials,
+  realtimeVoicePipeline,
   resolveRealtimeFront,
 } from "./live-realtime-session.js";
 
 const srcDir = path.dirname(fileURLToPath(import.meta.url));
 
 const mockVectorize = {} as import("@cloudflare/workers-types").VectorizeIndex;
+const ctx = { sessionId: "s1" };
 
-describe("createRealtimeVoiceAgentSession", () => {
-  it("registers the realtime plugin with RealtimeBridge", async () => {
-    const registerSpy = vi.spyOn(VoiceAgentSession.prototype, "registerPlugin");
-    const session = await createRealtimeVoiceAgentSession({
-      OPENAI_API_KEY: "test-key",
-      VECTORIZE: mockVectorize,
-    });
-    expect(session).toBeInstanceOf(VoiceAgentSession);
-    expect(registerSpy).toHaveBeenCalledWith("realtime", expect.any(RealtimeBridge));
-    registerSpy.mockRestore();
+describe("realtimeVoicePipeline", () => {
+  it("is a realtime pipeline routed through the ask_university delegate tool", () => {
+    expect(realtimeVoicePipeline.kind).toBe("realtime");
+    expect(realtimeVoicePipeline.delegateToolName).toBe("ask_university");
+  });
+
+  it("builds an OpenAI front by default and a Gemini front when REALTIME_FRONT=gemini", () => {
+    const openai = realtimeVoicePipeline.front({ OPENAI_API_KEY: "k", VECTORIZE: mockVectorize }, ctx);
+    expect(openai).toBeTruthy();
+    const gemini = realtimeVoicePipeline.front(
+      { REALTIME_FRONT: "gemini", GEMINI_API_KEY: "g", VECTORIZE: mockVectorize },
+      ctx,
+    );
+    expect(gemini).toBeTruthy();
   });
 
-  it("requires OPENAI_API_KEY", async () => {
-    await expect(createRealtimeVoiceAgentSession({ VECTORIZE: mockVectorize })).rejects.toThrow(/OPENAI_API_KEY/);
+  it("requires the front model's key (OPENAI_API_KEY default; GEMINI_API_KEY for gemini)", () => {
+    expect(() => realtimeVoicePipeline.front({ VECTORIZE: mockVectorize }, ctx)).toThrow(/OPENAI_API_KEY/);
+    expect(() =>
+      realtimeVoicePipeline.front({ REALTIME_FRONT: "gemini", VECTORIZE: mockVectorize }, ctx),
+    ).toThrow(/GEMINI_API_KEY/);
   });
 
   it("reports credential presence via hasRealtimeSessionCredentials", () => {
@@ -47,13 +53,6 @@ describe("createRealtimeVoiceAgentSession", () => {
     })).toBe(false);
   });
 
-  it("requires GEMINI_API_KEY when REALTIME_FRONT=gemini", async () => {
-    await expect(createRealtimeVoiceAgentSession({
-      REALTIME_FRONT: "gemini",
-      VECTORIZE: mockVectorize,
-    })).rejects.toThrow(/GEMINI_API_KEY/);
-  });
-
   it("defaults REALTIME_FRONT to openai", () => {
     expect(resolveRealtimeFront({ VECTORIZE: mockVectorize })).toBe("openai");
     expect(resolveRealtimeFront({ REALTIME_FRONT: "gemini", VECTORIZE: mockVectorize })).toBe("gemini");

package/src/live-realtime-session.ts

@@ -1,11 +1,14 @@
 // SPDX-License-Identifier: MIT
 //
-// Bi-model VoiceAgentSession for Cloudflare Workers: gpt-realtime or Gemini Live front model,
-// with a kuralle Vectorize-backed Reasoner back model.
+// Bi-model voice pipeline for the Cloudflare Workers host: a gpt-realtime or Gemini
+// Live front model with a kuralle Vectorize-backed Reasoner back model, consulted
+// via the `ask_university` front-model delegate tool. This is the pipeline/brain
+// layer — the host (worker-realtime.ts) composes it via `withVoice(Agent)`.
 
-import { VoiceAgentSession } from "@kuralle-syrinx/core";
-import { RealtimeBridge, fromGeminiLive, fromOpenAIRealtime } from "@kuralle-syrinx/realtime";
-import type { RealtimeToolDef } from "@kuralle-syrinx/realtime";
+import type { Reasoner } from "@kuralle-syrinx/core";
+import type { RealtimePipeline, VoicePipelineContext } from "@kuralle-syrinx/cf-agents";
+import { fromGeminiLive, fromOpenAIRealtime } from "@kuralle-syrinx/realtime";
+import type { RealtimeAdapter, RealtimeToolDef } from "@kuralle-syrinx/realtime";
 import { createWorkersSocket } from "@kuralle-syrinx/ws/workers";
 import type { VectorizeIndex } from "@cloudflare/workers-types";
 import { createRealtimeKuralleReasoner } from "./kuralle-realtime-agent.js";
@@ -21,12 +24,6 @@ export interface RealtimeSessionEnv {
   readonly VECTORIZE: VectorizeIndex;
 }
 
-export interface RealtimeSessionOptions {
-  readonly sessionId?: string;
-  readonly inputSampleRateHz?: number;
-  readonly outputSampleRateHz?: number;
-}
-
 const DEFAULT_GEMINI_LIVE_MODEL = "gemini-3.1-flash-live-preview";
 
 const REALTIME_SYSTEM_INSTRUCTION =
@@ -53,38 +50,38 @@ export function hasRealtimeSessionCredentials(env: RealtimeSessionEnv): boolean
   return Boolean(env.OPENAI_API_KEY?.trim());
 }
 
-export async function createRealtimeVoiceAgentSession(
-  env: RealtimeSessionEnv,
-  options: RealtimeSessionOptions = {},
-): Promise<VoiceAgentSession> {
-  const sessionId = options.sessionId?.trim() || crypto.randomUUID();
+function buildRealtimeFront(env: RealtimeSessionEnv): RealtimeAdapter {
   const front = resolveRealtimeFront(env);
+  if (front === "gemini") {
+    return fromGeminiLive({
+      apiKey: requireKey(env.GEMINI_API_KEY, "GEMINI_API_KEY"),
+      model: env.GEMINI_LIVE_MODEL?.trim() || DEFAULT_GEMINI_LIVE_MODEL,
+      systemInstruction: REALTIME_SYSTEM_INSTRUCTION,
+      tools: [ASK_UNIVERSITY_TOOL],
+    });
+  }
+  return fromOpenAIRealtime({
+    apiKey: requireKey(env.OPENAI_API_KEY, "OPENAI_API_KEY"),
+    socketFactory: createWorkersSocket,
+    turnDetection: { type: "server_vad", silence_duration_ms: 500 },
+    inputTranscription: true,
+    tools: [ASK_UNIVERSITY_TOOL],
+  });
+}
 
-  const adapter = front === "gemini"
-    ? fromGeminiLive({
-        apiKey: requireKey(env.GEMINI_API_KEY, "GEMINI_API_KEY"),
-        model: env.GEMINI_LIVE_MODEL?.trim() || DEFAULT_GEMINI_LIVE_MODEL,
-        systemInstruction: REALTIME_SYSTEM_INSTRUCTION,
-        tools: [ASK_UNIVERSITY_TOOL],
-      })
-    : fromOpenAIRealtime({
-        apiKey: requireKey(env.OPENAI_API_KEY, "OPENAI_API_KEY"),
-        socketFactory: createWorkersSocket,
-        turnDetection: { type: "server_vad", silence_duration_ms: 500 },
-        inputTranscription: true,
-        tools: [ASK_UNIVERSITY_TOOL],
-      });
-
-  const universityReasoner = await createRealtimeKuralleReasoner(env, { sessionId });
-
-  const bridge = new RealtimeBridge(adapter, universityReasoner, ASK_UNIVERSITY_TOOL.name);
+/** Realtime pipeline descriptor consumed by `withVoice(Agent)`. */
+export const realtimeVoicePipeline: RealtimePipeline<RealtimeSessionEnv> = {
+  kind: "realtime",
+  front: (env) => buildRealtimeFront(env),
+  delegateToolName: ASK_UNIVERSITY_TOOL.name,
+};
 
-  const session = new VoiceAgentSession({
-    plugins: { realtime: {} },
-    endpointingOwner: "timer",
-  });
-  session.registerPlugin("realtime", bridge);
-  return session;
+/** The back model: a kuralle Vectorize-backed Reasoner, keyed by the session id. */
+export function createRealtimeReasoner(
+  env: RealtimeSessionEnv,
+  ctx: VoicePipelineContext,
+): Promise<Reasoner> {
+  return createRealtimeKuralleReasoner(env, { sessionId: ctx.sessionId });
 }
 
 function requireKey(value: string | undefined, name: string): string {

package/src/live-session.test.ts

@@ -3,48 +3,53 @@
 import { readFileSync, readdirSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { describe, expect, it, vi } from "vitest";
-import { VoiceAgentSession } from "@kuralle-syrinx/core";
-import { ReasoningBridge } from "@kuralle-syrinx/aisdk";
+import { describe, expect, it } from "vitest";
 import { DeepgramSTTPlugin, DeepgramTTSPlugin } from "@kuralle-syrinx/deepgram";
 
 import {
-  createLiveVoiceAgentSession,
+  createLiveReasoner,
   hasLiveSessionCredentials,
+  liveCascadedPipeline,
 } from "./live-session.js";
 
 const srcDir = path.dirname(fileURLToPath(import.meta.url));
 const mockVectorize = {} as import("@cloudflare/workers-types").VectorizeIndex;
+const ctx = { sessionId: "s1" };
 
-describe("createLiveVoiceAgentSession", () => {
-  it("registers stt, kuralle bridge, and Deepgram TTS plugins", async () => {
-    const registerSpy = vi.spyOn(VoiceAgentSession.prototype, "registerPlugin");
-    const session = await createLiveVoiceAgentSession({
-      DEEPGRAM_API_KEY: "dg-key",
-      OPENAI_API_KEY: "oa-key",
-      VECTORIZE: mockVectorize,
-    });
-    expect(session).toBeInstanceOf(VoiceAgentSession);
-    expect(registerSpy).toHaveBeenCalledWith("stt", expect.any(DeepgramSTTPlugin));
-    expect(registerSpy).toHaveBeenCalledWith("bridge", expect.any(ReasoningBridge));
-    expect(registerSpy).toHaveBeenCalledWith("tts", expect.any(DeepgramTTSPlugin));
-    registerSpy.mockRestore();
+describe("liveCascadedPipeline", () => {
+  it("is a provider-endpointed cascade with a tightened force-finalize timeout", () => {
+    expect(liveCascadedPipeline.kind).toBe("cascaded");
+    expect(liveCascadedPipeline.endpointingOwner).toBe("provider_stt");
+    expect(liveCascadedPipeline.sttForceFinalizeTimeoutMs).toBe(3500);
   });
 
-  it("requires DEEPGRAM_API_KEY, OPENAI_API_KEY, and VECTORIZE", async () => {
-    await expect(createLiveVoiceAgentSession({
-      OPENAI_API_KEY: "k",
-      VECTORIZE: mockVectorize,
-    })).rejects.toThrow(/DEEPGRAM_API_KEY/);
-    await expect(createLiveVoiceAgentSession({
-      DEEPGRAM_API_KEY: "k",
-      VECTORIZE: mockVectorize,
-    })).rejects.toThrow(/OPENAI_API_KEY/);
-    await expect(createLiveVoiceAgentSession({
-      DEEPGRAM_API_KEY: "k",
-      OPENAI_API_KEY: "k",
-      VECTORIZE: undefined as unknown as typeof mockVectorize,
-    })).rejects.toThrow(/VECTORIZE/);
+  it("builds Deepgram Nova-3 STT (VAD events) and Aura TTS stages from the env", () => {
+    const env = { DEEPGRAM_API_KEY: "dg-key", OPENAI_API_KEY: "oa-key", VECTORIZE: mockVectorize };
+    const stt = liveCascadedPipeline.stt(env, ctx);
+    expect(stt.plugin).toBeInstanceOf(DeepgramSTTPlugin);
+    expect(stt.config).toMatchObject({ model: "nova-3", endpointing: 300, vad_events: true, api_key: "dg-key" });
+
+    const tts = liveCascadedPipeline.tts(env, ctx);
+    expect(tts.plugin).toBeInstanceOf(DeepgramTTSPlugin);
+    expect(tts.config).toMatchObject({ model: "aura-2-thalia-en", api_key: "dg-key" });
+  });
+
+  it("requires DEEPGRAM_API_KEY to build the stt/tts stages", () => {
+    const env = { OPENAI_API_KEY: "k", VECTORIZE: mockVectorize };
+    expect(() => liveCascadedPipeline.stt(env, ctx)).toThrow(/DEEPGRAM_API_KEY/);
+    expect(() => liveCascadedPipeline.tts(env, ctx)).toThrow(/DEEPGRAM_API_KEY/);
+  });
+});
+
+describe("createLiveReasoner", () => {
+  it("requires OPENAI_API_KEY and VECTORIZE", async () => {
+    await expect(createLiveReasoner({ VECTORIZE: mockVectorize }, ctx)).rejects.toThrow(/OPENAI_API_KEY/);
+    await expect(
+      createLiveReasoner(
+        { OPENAI_API_KEY: "k", VECTORIZE: undefined as unknown as typeof mockVectorize },
+        ctx,
+      ),
+    ).rejects.toThrow(/VECTORIZE/);
   });
 
   it("reports credential presence via hasLiveSessionCredentials", () => {

package/src/live-session.ts

@@ -1,14 +1,18 @@
 // SPDX-License-Identifier: MIT
 //
-// Live VoiceAgentSession for the Cloudflare Workers Durable Object: real
-// Deepgram STT + kuralle (Vectorize RAG) + Deepgram Aura TTS, all dialed over
-// the Workers fetch-upgrade socket (createWorkersSocket) so no Node `ws` is pulled
-// into the edge bundle. Turn-taking is owned by Deepgram endpointing
-// (endpointingOwner: "provider_stt"), so no Silero VAD / Smart Turn ONNX is
-// needed on the hot path.
+// Cascaded voice pipeline for the Cloudflare Workers host: real Deepgram STT
+// (nova-3, provider-endpointed) + kuralle (Vectorize RAG) Reasoner + Deepgram
+// Aura TTS, all dialed over the Workers fetch-upgrade socket (createWorkersSocket)
+// so no Node `ws` is pulled into the edge bundle. Turn-taking is owned by Deepgram
+// endpointing (endpointingOwner: "provider_stt"), so no Silero VAD / Smart Turn
+// ONNX is needed on the hot path.
+//
+// This is the pipeline/brain layer — the host (worker.ts) composes it via
+// `withVoice(Agent)`; this module owns the plugin slots and the reasoner, not the
+// connection lifecycle.
 
-import { VoiceAgentSession } from "@kuralle-syrinx/core";
-import { ReasoningBridge } from "@kuralle-syrinx/aisdk";
+import type { Reasoner } from "@kuralle-syrinx/core";
+import type { CascadedPipeline, VoicePipelineContext } from "@kuralle-syrinx/cf-agents";
 import { DeepgramSTTPlugin, DeepgramTTSPlugin } from "@kuralle-syrinx/deepgram";
 import { createWorkersSocket } from "@kuralle-syrinx/ws/workers";
 import type { VectorizeIndex } from "@cloudflare/workers-types";
@@ -22,60 +26,55 @@ export interface LiveSessionEnv {
   readonly VECTORIZE: VectorizeIndex;
 }
 
-export interface LiveSessionOptions {
-  readonly sessionId?: string;
-  readonly inputSampleRateHz?: number;
-  readonly outputSampleRateHz?: number;
-}
-
 const DEFAULT_DEEPGRAM_TTS_MODEL = "aura-2-thalia-en";
+const INPUT_SAMPLE_RATE_HZ = 16000;
+const OUTPUT_SAMPLE_RATE_HZ = 16000;
 
 /** True when every provider secret needed for a live turn is present. */
 export function hasLiveSessionCredentials(env: LiveSessionEnv): boolean {
   return Boolean(env.DEEPGRAM_API_KEY?.trim() && env.OPENAI_API_KEY?.trim() && env.VECTORIZE);
 }
 
-export async function createLiveVoiceAgentSession(
-  env: LiveSessionEnv,
-  options: LiveSessionOptions = {},
-): Promise<VoiceAgentSession> {
-  const deepgramKey = requireKey(env.DEEPGRAM_API_KEY, "DEEPGRAM_API_KEY");
-  requireKey(env.OPENAI_API_KEY, "OPENAI_API_KEY");
-  if (!env.VECTORIZE) throw new Error("VECTORIZE binding is required to start a live voice session");
-  const sessionId = options.sessionId?.trim() || crypto.randomUUID();
-  const inputSampleRateHz = options.inputSampleRateHz ?? 16000;
-  const outputSampleRateHz = options.outputSampleRateHz ?? 16000;
-
-  const session = new VoiceAgentSession({
-    plugins: {
-      stt: {
-        api_key: deepgramKey,
-        sample_rate: inputSampleRateHz,
-        model: "nova-3",
-        language: "en-US",
-        endpointing: 300,
-        provider_finalize_timeout_ms: 2500,
-        finalize_timeout_fallback: true,
-        // No local VAD on the edge: Deepgram SpeechStarted is the barge-in
-        // speech-start signal (vad.speech_started producer).
-        vad_events: true,
-      },
-      bridge: {},
-      tts: {
-        api_key: deepgramKey,
-        model: DEFAULT_DEEPGRAM_TTS_MODEL,
-        sample_rate: outputSampleRateHz,
-      },
+/**
+ * Cascaded pipeline descriptor consumed by `withVoice(Agent)`. Deepgram Nova-3 STT
+ * (provider-endpointed, VAD events for barge-in) → kuralle Reasoner → Deepgram Aura
+ * TTS. `sttForceFinalizeTimeoutMs: 3500` keeps the engine's force-finalize tighter
+ * than the 7000ms default for the provider-endpointed cascade.
+ */
+export const liveCascadedPipeline: CascadedPipeline<LiveSessionEnv> = {
+  kind: "cascaded",
+  stt: (env) => ({
+    plugin: new DeepgramSTTPlugin(createWorkersSocket),
+    config: {
+      api_key: requireKey(env.DEEPGRAM_API_KEY, "DEEPGRAM_API_KEY"),
+      sample_rate: INPUT_SAMPLE_RATE_HZ,
+      model: "nova-3",
+      language: "en-US",
+      endpointing: 300,
+      provider_finalize_timeout_ms: 2500,
+      finalize_timeout_fallback: true,
+      // No local VAD on the edge: Deepgram SpeechStarted is the barge-in
+      // speech-start signal (vad.speech_started producer).
+      vad_events: true,
+    },
+  }),
+  tts: (env) => ({
+    plugin: new DeepgramTTSPlugin(createWorkersSocket),
+    config: {
+      api_key: requireKey(env.DEEPGRAM_API_KEY, "DEEPGRAM_API_KEY"),
+      model: DEFAULT_DEEPGRAM_TTS_MODEL,
+      sample_rate: OUTPUT_SAMPLE_RATE_HZ,
     },
-    sttForceFinalizeTimeoutMs: 3500,
-    endpointingOwner: "provider_stt",
-  });
+  }),
+  endpointingOwner: "provider_stt",
+  sttForceFinalizeTimeoutMs: 3500,
+};
 
-  const reasoner = await createRealtimeKuralleReasoner(env, { sessionId });
-  session.registerPlugin("stt", new DeepgramSTTPlugin(createWorkersSocket));
-  session.registerPlugin("bridge", new ReasoningBridge(reasoner));
-  session.registerPlugin("tts", new DeepgramTTSPlugin(createWorkersSocket));
-  return session;
+/** The brain: a kuralle Vectorize-backed Reasoner, keyed by the session id. */
+export async function createLiveReasoner(env: LiveSessionEnv, ctx: VoicePipelineContext): Promise<Reasoner> {
+  requireKey(env.OPENAI_API_KEY, "OPENAI_API_KEY");
+  if (!env.VECTORIZE) throw new Error("VECTORIZE binding is required to start a live voice session");
+  return createRealtimeKuralleReasoner(env, { sessionId: ctx.sessionId });
 }
 
 function requireKey(value: string | undefined, name: string): string {

package/src/worker-realtime.ts

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: MIT
+//
+// Cloudflare Workers realtime (bi-model) voice host, built on `withVoice(Agent)`
+// (issue #10 / W1). Same host machinery as the cascaded worker — the only
+// difference is the pipeline (realtime front + kuralle back) and the reasoner.
 
+import { Agent } from "agents";
+import { withVoice } from "@kuralle-syrinx/cf-agents";
 import {
-  createVoiceEdgeWebSocketUpgrade,
-  type VoiceEdgeWebSocketUpgrade,
-} from "@kuralle-syrinx/server-websocket/edge";
-import type { WorkersInboundSocketController } from "@kuralle-syrinx/ws/workers";
-import { DurableObjectAlarmScheduler } from "./alarm-scheduler.js";
-import { DurableObjectSessionStore } from "./durable-session-store.js";
-import {
-  createRealtimeVoiceAgentSession,
+  createRealtimeReasoner,
+  realtimeVoicePipeline,
   type RealtimeSessionEnv,
 } from "./live-realtime-session.js";
 
@@ -19,6 +19,14 @@ export interface Env extends RealtimeSessionEnv {
 const INPUT_SAMPLE_RATE_HZ = 16000;
 const OUTPUT_SAMPLE_RATE_HZ = 16000;
 
+export class RealtimeVoiceConversation extends withVoice<Env, typeof Agent<Env>>(Agent<Env>, {
+  pipeline: realtimeVoicePipeline,
+  reasoner: (env, ctx) => createRealtimeReasoner(env, ctx),
+  inputSampleRateHz: INPUT_SAMPLE_RATE_HZ,
+  outputSampleRateHz: OUTPUT_SAMPLE_RATE_HZ,
+  resumeWindowMs: 15_000,
+}) {}
+
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
     const url = new URL(request.url);
@@ -29,63 +37,3 @@ export default {
     return await env.REALTIME_VOICE_CONVERSATIONS.get(id).fetch(request);
   },
 };
-
-export class RealtimeVoiceConversation {
-  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 sessionId = new URL(request.url).searchParams.get("sessionId") ?? crypto.randomUUID();
-    const upgrade = createVoiceEdgeWebSocketUpgrade(request, {
-      sessionStore: this.store,
-      scheduler: this.scheduler,
-      createSession: () =>
-        createRealtimeVoiceAgentSession(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;
-  }
-}