@kuralle-syrinx/server-workers 2.1.0

package/src/test-storage.ts

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+
+interface SessionRow {
+  id: string;
+  current_context_id: string;
+  last_sequence: number | null;
+  retained_until_ms: number;
+  connection_count: number;
+  updated_at_ms: number;
+}
+
+interface TaskRow {
+  key: string;
+  deadline_ms: number;
+}
+
+export class MemoryDurableStorage {
+  readonly sessions = new Map<string, SessionRow>();
+  readonly tasks = new Map<string, TaskRow>();
+  alarm: number | null = null;
+
+  readonly sql = {
+    exec: (query: string, ...bindings: unknown[]): Iterable<Record<string, unknown>> => {
+      const normalized = query.replace(/\s+/g, " ").trim();
+      if (normalized.startsWith("CREATE TABLE")) return [];
+      if (normalized.startsWith("INSERT OR REPLACE INTO scheduled_tasks")) {
+        const key = String(bindings[0]);
+        this.tasks.set(key, { key, deadline_ms: Number(bindings[1]) });
+        return [];
+      }
+      if (normalized.startsWith("DELETE FROM scheduled_tasks WHERE key")) {
+        this.tasks.delete(String(bindings[0]));
+        return [];
+      }
+      if (normalized.startsWith("SELECT key FROM scheduled_tasks")) {
+        const now = Number(bindings[0]);
+        return [...this.tasks.values()]
+          .filter((row) => row.deadline_ms <= now)
+          .sort((a, b) => a.deadline_ms - b.deadline_ms) as unknown as Record<string, unknown>[];
+      }
+      if (normalized.startsWith("SELECT deadline_ms FROM scheduled_tasks")) {
+        const next = [...this.tasks.values()].sort((a, b) => a.deadline_ms - b.deadline_ms)[0];
+        return (next ? [{ deadline_ms: next.deadline_ms }] : []) as Record<string, unknown>[];
+      }
+      if (normalized.startsWith("INSERT OR REPLACE INTO sessions")) {
+        const row: SessionRow = {
+          id: String(bindings[0]),
+          current_context_id: String(bindings[1]),
+          last_sequence: bindings[2] === null ? null : Number(bindings[2]),
+          retained_until_ms: Number(bindings[3]),
+          connection_count: Number(bindings[4]),
+          updated_at_ms: Number(bindings[5]),
+        };
+        this.sessions.set(row.id, row);
+        return [];
+      }
+      if (normalized.startsWith("DELETE FROM sessions WHERE id")) {
+        this.sessions.delete(String(bindings[0]));
+        return [];
+      }
+      if (normalized.startsWith("DELETE FROM sessions")) {
+        this.sessions.clear();
+        return [];
+      }
+      if (normalized.startsWith("SELECT * FROM sessions WHERE id")) {
+        const row = this.sessions.get(String(bindings[0]));
+        return (row ? [row] : []) as unknown as Record<string, unknown>[];
+      }
+      throw new Error(`Unsupported test SQL: ${normalized}`);
+    },
+  };
+
+  async setAlarm(scheduledTime: number | Date): Promise<void> {
+    this.alarm = scheduledTime instanceof Date ? scheduledTime.getTime() : scheduledTime;
+  }
+
+  async deleteAlarm(): Promise<void> {
+    this.alarm = null;
+  }
+}

package/src/worker-realtime.ts

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+
+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,
+  type RealtimeSessionEnv,
+} from "./live-realtime-session.js";
+
+export interface Env extends RealtimeSessionEnv {
+  readonly REALTIME_VOICE_CONVERSATIONS: DurableObjectNamespace;
+}
+
+const INPUT_SAMPLE_RATE_HZ = 16000;
+const OUTPUT_SAMPLE_RATE_HZ = 16000;
+
+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 !== "/ws") return new Response("not found", { status: 404 });
+    const sessionId = url.searchParams.get("sessionId") ?? crypto.randomUUID();
+    const id = env.REALTIME_VOICE_CONVERSATIONS.idFromName(sessionId);
+    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;
+  }
+}

package/src/worker-runtime.test.ts

@@ -0,0 +1,265 @@
+// 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";
+
+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 },
+    },
+    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,
+  );
+});
+
+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/src/worker.ts

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: MIT
+
+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";
+
+export interface Env extends LiveSessionEnv {
+  VOICE_CONVERSATIONS: DurableObjectNamespace;
+  /** Optional: when bound, full call audio is recorded to this bucket. */
+  RECORDINGS?: R2Bucket;
+}
+
+const INPUT_SAMPLE_RATE_HZ = 16000;
+const OUTPUT_SAMPLE_RATE_HZ = 16000;
+
+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 });
+    }
+    const sessionId = url.searchParams.get("sessionId") ?? crypto.randomUUID();
+    const id = env.VOICE_CONVERSATIONS.idFromName(sessionId);
+    return await env.VOICE_CONVERSATIONS.get(id).fetch(request);
+  },
+};
+
+/** 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");
+  if (!env.RECORDINGS || !sessionId) return new Response("not found", { status: 404 });
+  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/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "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"]
+}

package/wrangler.jsonc

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

package/wrangler.realtime-gemini.jsonc

@@ -0,0 +1,28 @@
+{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "syrinx-voice-realtime-gemini",
+  "main": "src/worker-realtime.ts",
+  "compatibility_date": "2026-06-01",
+  "compatibility_flags": ["nodejs_compat"],
+  "vars": { "REALTIME_FRONT": "gemini" },
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "REALTIME_VOICE_CONVERSATIONS",
+        "class_name": "RealtimeVoiceConversation"
+      }
+    ]
+  },
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_sqlite_classes": ["RealtimeVoiceConversation"]
+    }
+  ],
+  "vectorize": [
+    {
+      "binding": "VECTORIZE",
+      "index_name": "kuralle-university-kb"
+    }
+  ]
+}

package/wrangler.realtime.jsonc

@@ -0,0 +1,27 @@
+{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "syrinx-voice-realtime-workers",
+  "main": "src/worker-realtime.ts",
+  "compatibility_date": "2026-06-01",
+  "compatibility_flags": ["nodejs_compat"],
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "REALTIME_VOICE_CONVERSATIONS",
+        "class_name": "RealtimeVoiceConversation"
+      }
+    ]
+  },
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_sqlite_classes": ["RealtimeVoiceConversation"]
+    }
+  ],
+  "vectorize": [
+    {
+      "binding": "VECTORIZE",
+      "index_name": "kuralle-university-kb"
+    }
+  ]
+}