@kuralle-syrinx/server-workers 4.1.0 → 4.3.0

package/package.json

@@ -1,9 +1,28 @@
 {
   "name": "@kuralle-syrinx/server-workers",
-  "version": "4.1.0",
+  "version": "4.3.0",
   "private": false,
-  "type": "module",
+  "description": "Cloudflare Workers voice host for Syrinx — the full STT→LLM→TTS engine in one hibernatable Durable Object per session, with R2 call recording",
+  "keywords": [
+    "voice",
+    "voice-agent",
+    "speech",
+    "syrinx",
+    "cloudflare-workers",
+    "durable-objects",
+    "edge"
+  ],
   "license": "MIT",
+  "homepage": "https://github.com/kuralle/syrinx#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kuralle/syrinx.git",
+    "directory": "packages/server-workers"
+  },
+  "bugs": {
+    "url": "https://github.com/kuralle/syrinx/issues"
+  },
+  "type": "module",
   "main": "./src/worker.ts",
   "types": "./src/worker.ts",
   "dependencies": {
@@ -15,23 +34,24 @@
     "agents": "0.14.0",
     "ai": "^6.0.0",
     "zod": "^4.1.8",
-    "@kuralle-syrinx/core": "4.1.0",
-    "@kuralle-syrinx/aisdk": "4.1.0",
-    "@kuralle-syrinx/server-websocket": "4.1.0",
-    "@kuralle-syrinx/realtime": "4.1.0",
-    "@kuralle-syrinx/deepgram": "4.1.0",
-    "@kuralle-syrinx/ws": "4.1.0",
-    "@kuralle-syrinx/recorder": "4.1.0",
-    "@kuralle-syrinx/kuralle": "4.1.0",
-    "@kuralle-syrinx/cartesia": "4.1.0",
-    "@kuralle-syrinx/cf-agents": "4.1.0"
+    "@kuralle-syrinx/core": "4.3.0",
+    "@kuralle-syrinx/aisdk": "4.3.0",
+    "@kuralle-syrinx/deepgram": "4.3.0",
+    "@kuralle-syrinx/server-websocket": "4.3.0",
+    "@kuralle-syrinx/cf-agents": "4.3.0",
+    "@kuralle-syrinx/realtime": "4.3.0",
+    "@kuralle-syrinx/cartesia": "4.3.0",
+    "@kuralle-syrinx/kuralle": "4.3.0",
+    "@kuralle-syrinx/recorder": "4.3.0",
+    "@kuralle-syrinx/pipecat-smart-turn": "4.3.0",
+    "@kuralle-syrinx/ws": "4.3.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20260601.0",
-    "esbuild": "^0.25.0",
+    "esbuild": "^0.28.1",
     "miniflare": "^4.20260601.0",
     "typescript": "^5.7.0",
-    "vitest": "^2.1.0",
+    "vitest": "^3.2.6",
     "wrangler": "^4.19.0"
   },
   "scripts": {

package/src/live-session.ts

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MIT
 //
 // 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.
+// (nova-3) + 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. Default turn-taking is Deepgram endpointing
+// (endpointingOwner: "provider_stt"); when `env.AI` is bound, hosted Workers AI
+// Smart Turn owns EOS via the edge-safe PipecatEOSPlugin (`/eos` subpath, no ONNX).
 //
 // 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
@@ -14,9 +14,11 @@
 import type { Reasoner } from "@kuralle-syrinx/core";
 import type { CascadedPipeline, VoicePipelineContext } from "@kuralle-syrinx/cf-agents";
 import { DeepgramSTTPlugin, DeepgramTTSPlugin } from "@kuralle-syrinx/deepgram";
+import { PipecatEOSPlugin } from "@kuralle-syrinx/pipecat-smart-turn/eos";
 import { createWorkersSocket } from "@kuralle-syrinx/ws/workers";
 import type { VectorizeIndex } from "@cloudflare/workers-types";
 import { createRealtimeKuralleReasoner } from "./kuralle-realtime-agent.js";
+import { WorkersAiSmartTurnPredictor, type Ai } from "./workers-ai-smart-turn.js";
 
 /** Provider secrets + optional tuning, supplied as Workers env/secret bindings. */
 export interface LiveSessionEnv {
@@ -24,6 +26,8 @@ export interface LiveSessionEnv {
   readonly OPENAI_API_KEY?: string;
   readonly OPENAI_MODEL?: string;
   readonly VECTORIZE: VectorizeIndex;
+  /** Optional Cloudflare Workers AI binding for hosted Smart Turn. */
+  readonly AI?: Ai;
 }
 
 const DEFAULT_DEEPGRAM_TTS_MODEL = "aura-2-thalia-en";
@@ -77,7 +81,11 @@ export const liveCascadedPipeline: CascadedPipeline<LiveSessionEnv> = {
       sample_rate: OUTPUT_SAMPLE_RATE_HZ,
     },
   }),
-  endpointingOwner: "provider_stt",
+  eos: (env) => {
+    const predictor = createWorkersAiSmartTurnPredictor(env);
+    return predictor ? { plugin: new PipecatEOSPlugin(predictor), config: {} } : undefined;
+  },
+  endpointingOwner: (env) => (env.AI ? "smart_turn" : "provider_stt"),
   sttForceFinalizeTimeoutMs: 3500,
 };
 
@@ -88,6 +96,12 @@ export async function createLiveReasoner(env: LiveSessionEnv, ctx: VoicePipeline
   return createRealtimeKuralleReasoner(env, { sessionId: ctx.sessionId });
 }
 
+/** Factory: returns a hosted Smart Turn predictor when `env.AI` is present, otherwise undefined. */
+export function createWorkersAiSmartTurnPredictor(env: LiveSessionEnv): WorkersAiSmartTurnPredictor | undefined {
+  if (!env.AI) return undefined;
+  return new WorkersAiSmartTurnPredictor(env.AI);
+}
+
 function requireKey(value: string | undefined, name: string): string {
   const trimmed = value?.trim();
   if (!trimmed) throw new Error(`${name} is required to start a live voice session`);

package/src/worker.ts

@@ -19,8 +19,11 @@ import {
 export interface Env extends LiveSessionEnv {
   VOICE_CONVERSATIONS: DurableObjectNamespace;
   TWILIO_VOICE_CONVERSATIONS: DurableObjectNamespace;
+  TELNYX_VOICE_CONVERSATIONS: DurableObjectNamespace;
   /** Optional: when bound, full call audio is recorded to this bucket. */
   RECORDINGS?: R2Bucket;
+  /** Optional: Cloudflare Workers AI binding for hosted Smart Turn endpointing. */
+  AI?: import("./workers-ai-smart-turn.js").Ai;
 }
 
 const INPUT_SAMPLE_RATE_HZ = 16000;
@@ -37,6 +40,11 @@ export class VoiceConversation extends withVoice<Env, typeof Agent<Env>>(Agent<E
   inputSampleRateHz: INPUT_SAMPLE_RATE_HZ,
   outputSampleRateHz: OUTPUT_SAMPLE_RATE_HZ,
   resumeWindowMs: 15_000,
+  // Browser/studio clients: no telephony-style idle re-engagement. The 15s default nags
+  // ("Are you still there?") and disconnects a user who is granting mic or reading the UI
+  // before speaking; the DO hibernates abandoned browser sessions anyway. Telephony keeps
+  // the default on TwilioVoiceConversation below.
+  idleTimeout: { durationMs: 0 },
 }) {}
 
 /** Telephony cascaded host (Twilio Media Streams μ-law 8 kHz over /twilio). Same pipeline/brain. */
@@ -48,6 +56,19 @@ export class TwilioVoiceConversation extends withVoice<Env, typeof Agent<Env>>(A
   resumeWindowMs: 15_000,
 }) {}
 
+/**
+ * Telephony cascaded host (Telnyx Media Streaming over /telnyx). Same pipeline/brain;
+ * idle timeout keeps the telephony re-engagement default. Live streaming_start →
+ * /telnyx is carrier-gated / unit-tested only.
+ */
+export class TelnyxVoiceConversation extends withVoice<Env, typeof Agent<Env>>(Agent<Env>, {
+  transport: "telnyx",
+  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);
@@ -57,6 +78,9 @@ export default {
     // 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);
+    // Telnyx TeXML / Call Control stream-start helper: pure payload construction.
+    // Live dispatch of streaming_start to a real trunk is carrier-gated.
+    if (url.pathname === "/telnyx-stream-start") return await telnyxStreamStartResponse(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.
@@ -65,6 +89,10 @@ export default {
       const id = env.TWILIO_VOICE_CONVERSATIONS.idFromName(sessionId);
       return await env.TWILIO_VOICE_CONVERSATIONS.get(id).fetch(request);
     }
+    if (url.pathname === "/telnyx") {
+      const id = env.TELNYX_VOICE_CONVERSATIONS.idFromName(sessionId);
+      return await env.TELNYX_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);
@@ -97,6 +125,56 @@ async function twilioIncomingCallResponse(request: Request, url: URL): Promise<R
   return new Response(twiml, { headers: { "content-type": "text/xml; charset=utf-8" } });
 }
 
+/**
+ * Telnyx stream-start helper — pure payload construction (no live carrier dispatch).
+ *
+ * - Default (`format=texml` or omitted): TeXML `<Stream url="wss://…/telnyx?sessionId=…">`
+ *   for TeXML applications that start bidirectional media via the Stream verb.
+ * - `format=streaming_start`: JSON body matching Call Control `streaming_start`
+ *   (`stream_url`, `stream_bidirectional_mode`, `stream_bidirectional_codec`, …).
+ *   Live POST to `/v2/calls/{call_control_id}/actions/streaming_start` is carrier-gated.
+ *
+ * Query: `sessionId` (optional), `codec` (PCMU|PCMA|G722|L16, default PCMU),
+ * `sampleRate` (default from codec), `format` (texml|streaming_start).
+ */
+async function telnyxStreamStartResponse(request: Request, url: URL): Promise<Response> {
+  let sessionId = url.searchParams.get("sessionId")?.trim() ?? "";
+  if (!sessionId && request.method === "POST") {
+    const form = await request.formData().catch(() => null);
+    const value = form?.get("sessionId") ?? form?.get("CallControlId") ?? form?.get("call_control_id");
+    if (typeof value === "string") sessionId = value.trim();
+  }
+  if (!sessionId) sessionId = crypto.randomUUID();
+
+  const codec = (url.searchParams.get("codec")?.trim().toUpperCase() || "PCMU");
+  const defaultRate = codec === "L16" || codec === "G722" ? "16000" : "8000";
+  const sampleRate = url.searchParams.get("sampleRate")?.trim() || defaultRate;
+  const format = url.searchParams.get("format")?.trim().toLowerCase() || "texml";
+
+  const wsScheme = url.protocol === "https:" ? "wss" : "ws";
+  const streamUrl = `${wsScheme}://${url.host}/telnyx?sessionId=${encodeURIComponent(sessionId)}`;
+
+  if (format === "streaming_start") {
+    // Call Control streaming_start body — pure; live dispatch carrier-gated.
+    return Response.json({
+      stream_url: streamUrl,
+      stream_track: "inbound_track",
+      stream_bidirectional_mode: "rtp",
+      stream_bidirectional_codec: codec,
+      stream_bidirectional_sampling_rate: Number(sampleRate),
+      send_silence_when_idle: true,
+    });
+  }
+
+  const texml = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    "<Response>",
+    `  <Stream url="${xmlEscape(streamUrl)}" bidirectionalMode="rtp" bidirectionalCodec="${xmlEscape(codec)}" bidirectionalSamplingRate="${xmlEscape(sampleRate)}" />`,
+    "</Response>",
+  ].join("\n");
+  return new Response(texml, { 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,

package/src/workers-ai-smart-turn.ts

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+
+import type { SmartTurnPredictor } from "@kuralle-syrinx/pipecat-smart-turn/eos";
+import type { PluginConfig } from "@kuralle-syrinx/core";
+
+/** Minimal Cloudflare Workers AI binding surface for the Smart Turn v2 model. */
+export interface Ai {
+  run(model: string, input: unknown): Promise<{
+    is_complete?: boolean;
+    probability?: number;
+  }>;
+}
+
+const MODEL_ID = "@cf/pipecat-ai/smart-turn-v2";
+
+/**
+ * Cloudflare Workers AI-hosted Smart Turn predictor.
+ *
+ * Uses the hosted `@cf/pipecat-ai/smart-turn-v2` model (v3 is NOT available in the
+ * Workers AI catalog). No ONNX is loaded locally — the model runs in Cloudflare's
+ * inference cluster, so `initialize`/`close` are no-ops.
+ */
+export class WorkersAiSmartTurnPredictor implements SmartTurnPredictor {
+  constructor(private readonly ai: Ai) {}
+
+  async initialize(_config: PluginConfig): Promise<void> {
+    // Hosted model — nothing to load.
+  }
+
+  async predict(audio: Float32Array): Promise<number> {
+    const base64 = float32ArrayToBase64(audio);
+    const result = await this.ai.run(MODEL_ID, { audio: base64, dtype: "float32" });
+    return typeof result.probability === "number" ? result.probability : 0;
+  }
+
+  async close(): Promise<void> {
+    // Nothing to release.
+  }
+}
+
+function float32ArrayToBase64(arr: Float32Array): string {
+  const bytes = new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+  const chunks: string[] = [];
+  const chunkSize = 0x8000; // 32 KB — safe for String.fromCharCode spread
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    chunks.push(String.fromCharCode(...bytes.subarray(i, i + chunkSize)));
+  }
+  return btoa(chunks.join(""));
+}

package/wrangler.jsonc

@@ -13,6 +13,10 @@
       {
         "name": "TWILIO_VOICE_CONVERSATIONS",
         "class_name": "TwilioVoiceConversation"
+      },
+      {
+        "name": "TELNYX_VOICE_CONVERSATIONS",
+        "class_name": "TelnyxVoiceConversation"
       }
     ]
   },
@@ -30,6 +34,10 @@
     {
       "tag": "v2",
       "new_sqlite_classes": ["TwilioVoiceConversation"]
+    },
+    {
+      "tag": "v3",
+      "new_sqlite_classes": ["TelnyxVoiceConversation"]
     }
   ],
   "vectorize": [

package/wrangler.smartturn-spike.jsonc

@@ -0,0 +1,44 @@
+{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "syrinx-voice-smartturn-spike",
+  "main": "src/worker.ts",
+  "compatibility_date": "2026-06-01",
+  "compatibility_flags": ["nodejs_compat"],
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "VOICE_CONVERSATIONS",
+        "class_name": "VoiceConversation"
+      },
+      {
+        "name": "TWILIO_VOICE_CONVERSATIONS",
+        "class_name": "TwilioVoiceConversation"
+      }
+    ]
+  },
+  "r2_buckets": [
+    {
+      "binding": "RECORDINGS",
+      "bucket_name": "syrinx-voice-recordings"
+    }
+  ],
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_sqlite_classes": ["VoiceConversation"]
+    },
+    {
+      "tag": "v2",
+      "new_sqlite_classes": ["TwilioVoiceConversation"]
+    }
+  ],
+  "vectorize": [
+    {
+      "binding": "VECTORIZE",
+      "index_name": "kuralle-university-kb"
+    }
+  ],
+  "ai": {
+    "binding": "AI"
+  }
+}

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

@@ -1,88 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { readFileSync, readdirSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-
-import {
-  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("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 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", () => {
-    expect(hasRealtimeSessionCredentials({ OPENAI_API_KEY: "k", VECTORIZE: mockVectorize })).toBe(true);
-    expect(hasRealtimeSessionCredentials({ VECTORIZE: mockVectorize })).toBe(false);
-    expect(hasRealtimeSessionCredentials({
-      REALTIME_FRONT: "gemini",
-      GEMINI_API_KEY: "g",
-      VECTORIZE: mockVectorize,
-    })).toBe(true);
-    expect(hasRealtimeSessionCredentials({
-      REALTIME_FRONT: "gemini",
-      VECTORIZE: mockVectorize,
-    })).toBe(false);
-  });
-
-  it("defaults REALTIME_FRONT to openai", () => {
-    expect(resolveRealtimeFront({ VECTORIZE: mockVectorize })).toBe("openai");
-    expect(resolveRealtimeFront({ REALTIME_FRONT: "gemini", VECTORIZE: mockVectorize })).toBe("gemini");
-  });
-});
-
-describe("realtime worker edge safety", () => {
-  it("live-realtime-session and worker-realtime stay free of Node-only primitives", () => {
-    const files = ["live-realtime-session.ts", "worker-realtime.ts", "kuralle-realtime-agent.ts"];
-    const banned = /\bBuffer\b|from "node:|process\./;
-    for (const file of files) {
-      const source = readFileSync(path.join(srcDir, file), "utf8");
-      for (const [index, line] of source.split("\n").entries()) {
-        expect(line, `${file}:${index + 1}`).not.toMatch(banned);
-      }
-    }
-  });
-
-  it("does not pull node: imports into the realtime worker src tree", () => {
-    const nodeImports = readdirSync(srcDir)
-      .filter((name) => name.endsWith(".ts") && !name.endsWith(".test.ts"))
-      .flatMap((name) => {
-        const source = readFileSync(path.join(srcDir, name), "utf8");
-        return source
-          .split("\n")
-          .filter((line) => line.includes('from "node:'))
-          .map((line) => `${name}: ${line.trim()}`);
-      });
-    expect(nodeImports.filter((entry) => entry.startsWith("live-realtime-session")
-      || entry.startsWith("worker-realtime")
-      || entry.startsWith("kuralle-realtime-agent"))).toEqual([]);
-  });
-});

package/src/live-session.test.ts

@@ -1,94 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { readFileSync, readdirSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-import { DeepgramSTTPlugin, DeepgramTTSPlugin } from "@kuralle-syrinx/deepgram";
-
-import {
-  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("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("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: 500, vad_events: true, utterance_end_ms: 1000, 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", () => {
-    expect(hasLiveSessionCredentials({
-      DEEPGRAM_API_KEY: "d",
-      OPENAI_API_KEY: "o",
-      VECTORIZE: mockVectorize,
-    })).toBe(true);
-    expect(hasLiveSessionCredentials({
-      OPENAI_API_KEY: "o",
-      VECTORIZE: mockVectorize,
-    })).toBe(false);
-  });
-});
-
-describe("cascade worker edge safety", () => {
-  it("live-session and worker stay free of Node-only primitives", () => {
-    const files = ["live-session.ts", "worker.ts", "kuralle-realtime-agent.ts"];
-    const banned = /\bBuffer\b|from "node:|process\./;
-    for (const file of files) {
-      const source = readFileSync(path.join(srcDir, file), "utf8");
-      for (const [index, line] of source.split("\n").entries()) {
-        expect(line, `${file}:${index + 1}`).not.toMatch(banned);
-      }
-    }
-  });
-
-  it("does not pull node: imports into the cascade worker src tree", () => {
-    const nodeImports = readdirSync(srcDir)
-      .filter((name) => name.endsWith(".ts") && !name.endsWith(".test.ts"))
-      .flatMap((name) => {
-        const source = readFileSync(path.join(srcDir, name), "utf8");
-        return source
-          .split("\n")
-          .filter((line) => line.includes('from "node:'))
-          .map((line) => `${name}: ${line.trim()}`);
-      });
-    expect(nodeImports.filter((entry) => entry.startsWith("live-session")
-      || entry.startsWith("worker.ts")
-      || entry.startsWith("kuralle-realtime-agent"))).toEqual([]);
-  });
-});

package/src/worker-runtime.test.ts

@@ -1,409 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { existsSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-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)), "..");
-
-type WorkersWebSocket = WebSocket & { accept(): void };
-
-const REPO_ROOT = fileURLToPath(new URL("../../../", import.meta.url));
-const TURN_DETECTION_FIXTURE = join(
-  REPO_ROOT,
-  "examples/02-hello-voice-headless/test/fixtures/gemini-turn-detection/02-reset-password.wav",
-);
-const WORKER_INPUT_RATE_HZ = 16000;
-
-loadRepoEnv();
-const liveEnv = {
-  DEEPGRAM_API_KEY: process.env["DEEPGRAM_API_KEY"]?.trim() ?? "",
-  OPENAI_API_KEY: process.env["OPENAI_API_KEY"]?.trim() ?? "",
-  VECTORIZE: {},
-};
-const hasLiveKeys = Boolean(liveEnv.DEEPGRAM_API_KEY && liveEnv.OPENAI_API_KEY);
-// The live turn hits paid, non-deterministic provider APIs, so it is opt-in
-// (SYRINX_LIVE_WORKER_TEST=1) rather than running on every `pnpm -r test`.
-// Run it with: pnpm --filter @kuralle-syrinx/server-workers test:live
-const liveTurnEnabled = hasLiveKeys && process.env["SYRINX_LIVE_WORKER_TEST"] === "1";
-
-const tempDirs: string[] = [];
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
-});
-
-async function buildWorker(): Promise<string> {
-  const tmp = await mkdtemp(join(tmpdir(), "syrinx-worker-"));
-  tempDirs.push(tmp);
-  await execFileAsync(
-    "npx",
-    ["wrangler", "deploy", "--dry-run", "--outdir", tmp, "-c", "wrangler.jsonc"],
-    { cwd: PKG_ROOT },
-  );
-  return readFile(join(tmp, "worker.js"), "utf8");
-}
-
-function newMiniflare(script: string, bindings: Record<string, unknown>): Miniflare {
-  return new Miniflare({
-    modules: true,
-    script,
-    compatibilityDate: "2026-06-01",
-    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" },
-    },
-    bindings,
-  });
-}
-
-describe("VoiceConversation worker runtime", () => {
-  // Deterministic, no provider keys: proves the edge bundle boots inside workerd
-  // and accepts a WebSocketPair upgrade before any provider session starts.
-  it("boots in workerd and accepts a WebSocket upgrade", async () => {
-    const script = await buildWorker();
-    const mf = newMiniflare(script, {});
-    try {
-      const health = await mf.dispatchFetch("http://localhost/health");
-      expect(health.status).toBe(200);
-      expect(await health.text()).toBe("ok");
-
-      const response = await mf.dispatchFetch("http://localhost/ws?sessionId=boot-smoke", {
-        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);
-
-  // Live: drives a real STT -> LLM -> TTS turn through real providers inside
-  // workerd. Skipped when provider keys are absent so offline CI stays green.
-  it.skipIf(!liveTurnEnabled)(
-    "drives a real audio turn through Deepgram STT + kuralle + Deepgram TTS in workerd",
-    async () => {
-      expect(existsSync(TURN_DETECTION_FIXTURE)).toBe(true);
-      const pcm16 = readWav16kMono(TURN_DETECTION_FIXTURE);
-      const script = await buildWorker();
-      const mf = newMiniflare(script, liveEnv);
-      try {
-        const response = await mf.dispatchFetch("http://localhost/ws?sessionId=live-turn", {
-          headers: { Upgrade: "websocket" },
-        });
-        expect(response.status).toBe(101);
-        const ws = (response as unknown as Response & { webSocket?: WorkersWebSocket }).webSocket;
-        expect(ws).toBeTruthy();
-
-        const messages: Array<string | ArrayBuffer> = [];
-        ws!.addEventListener("message", (event) => {
-          messages.push(event.data as string | ArrayBuffer);
-        });
-        ws!.accept();
-
-        // Wait for the session to come up (provider sockets connected) before audio.
-        // Surface a provider init error (e.g. bad key, unreachable socket) instead
-        // of a bare timeout.
-        try {
-          await waitFor(() => messages.some((m) => typeof m === "string" && m.includes('"type":"ready"')), 20_000);
-        } catch {
-          throw new Error(`session never became ready: ${firstSessionError(messages) ?? "no error reported"}`);
-        }
-
-        // Stream the fixture as 20ms PCM16 frames, base64 JSON audio messages.
-        const frameSamples = (WORKER_INPUT_RATE_HZ / 1000) * 20; // 320 samples = 640 bytes
-        let sequence = 0;
-        for (let offset = 0; offset < pcm16.length; offset += frameSamples) {
-          const frame = pcm16.subarray(offset, Math.min(offset + frameSamples, pcm16.length));
-          sequence += 1;
-          ws!.send(JSON.stringify({
-            type: "audio",
-            audio: int16ToBase64(frame),
-            sampleRateHz: WORKER_INPUT_RATE_HZ,
-            sequence,
-          }));
-          await sleep(20);
-        }
-
-        // Real Deepgram transcript for the "reset password" utterance.
-        await waitFor(
-          () => messages.some((m) => typeof m === "string" && m.includes('"type":"stt_output"')),
-          15_000,
-        );
-        // Real Deepgram TTS audio frames back from the kuralle reply.
-        await waitFor(
-          () => messages.some((m) => typeof m === "string" && m.includes('"type":"tts_chunk"')),
-          30_000,
-        );
-
-        const transcript = extractTranscript(messages);
-        expect(transcript.length).toBeGreaterThan(0);
-        expect(messages.some((m) => m instanceof ArrayBuffer && m.byteLength > 0)).toBe(true);
-
-        // eslint-disable-next-line no-console
-        console.log(`[live-turn] STT transcript: ${JSON.stringify(transcript)}`);
-        ws!.close();
-      } finally {
-        await mf.dispose();
-      }
-    },
-    90_000,
-  );
-});
-
-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;
-    try {
-      const parsed = JSON.parse(m) as { type?: string; message?: string };
-      if (parsed.type === "error" && typeof parsed.message === "string") return parsed.message;
-    } catch {
-      // not JSON — ignore
-    }
-  }
-  return null;
-}
-
-function extractTranscript(messages: ReadonlyArray<string | ArrayBuffer>): string {
-  for (const m of messages) {
-    if (typeof m !== "string") continue;
-    try {
-      const parsed = JSON.parse(m) as { type?: string; transcript?: string };
-      if (parsed.type === "stt_output" && typeof parsed.transcript === "string") return parsed.transcript;
-    } catch {
-      // not JSON — ignore
-    }
-  }
-  return "";
-}
-
-async function waitFor(predicate: () => boolean, timeoutMs: number): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (predicate()) return;
-    await sleep(25);
-  }
-  throw new Error("timed out waiting for worker websocket output");
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function int16ToBase64(samples: Int16Array): string {
-  const bytes = new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength);
-  return Buffer.from(bytes).toString("base64");
-}
-
-/** Minimal PCM16 WAV reader that returns samples resampled to 16 kHz mono. */
-function readWav16kMono(path: string): Int16Array {
-  const buf = readFileSync(path);
-  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-  let sampleRate = 24000;
-  let dataStart = -1;
-  let dataLen = 0;
-  let pos = 12; // skip RIFF/WAVE header
-  while (pos + 8 <= buf.byteLength) {
-    const id = String.fromCharCode(buf[pos]!, buf[pos + 1]!, buf[pos + 2]!, buf[pos + 3]!);
-    const size = view.getUint32(pos + 4, true);
-    if (id === "fmt ") sampleRate = view.getUint32(pos + 8 + 4, true);
-    if (id === "data") {
-      dataStart = pos + 8;
-      dataLen = size;
-      break;
-    }
-    pos += 8 + size + (size % 2);
-  }
-  if (dataStart < 0) throw new Error(`no data chunk in WAV: ${path}`);
-  const sampleCount = Math.floor(dataLen / 2);
-  const src = new Int16Array(sampleCount);
-  for (let i = 0; i < sampleCount; i += 1) src[i] = view.getInt16(dataStart + i * 2, true);
-  return sampleRate === WORKER_INPUT_RATE_HZ ? src : resampleLinear(src, sampleRate, WORKER_INPUT_RATE_HZ);
-}
-
-function resampleLinear(src: Int16Array, fromHz: number, toHz: number): Int16Array {
-  const outLen = Math.max(1, Math.round((src.length * toHz) / fromHz));
-  const out = new Int16Array(outLen);
-  const ratio = (src.length - 1) / Math.max(1, outLen - 1);
-  for (let i = 0; i < outLen; i += 1) {
-    const x = i * ratio;
-    const i0 = Math.floor(x);
-    const i1 = Math.min(src.length - 1, i0 + 1);
-    const frac = x - i0;
-    out[i] = Math.round(src[i0]! * (1 - frac) + src[i1]! * frac);
-  }
-  return out;
-}
-
-/** Load DEEPGRAM/OPENAI keys from the repo-root .env if not already set. */
-function loadRepoEnv(): void {
-  const envPath = join(REPO_ROOT, ".env");
-  if (!existsSync(envPath)) return;
-  for (const line of readFileSync(envPath, "utf8").split(/\r?\n/)) {
-    const match = /^([A-Z0-9_]+)\s*=\s*(.*)$/.exec(line.trim());
-    if (!match) continue;
-    const key = match[1]!;
-    if (process.env[key] !== undefined) continue;
-    let value = match[2]!.trim();
-    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1);
-    }
-    process.env[key] = value;
-  }
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "types": ["@cloudflare/workers-types"],
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitReturns": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}