@kuralle-syrinx/server-workers-mastra 2.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Kuralle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,49 @@
+# @kuralle-syrinx/server-workers-mastra
+
+A **dedicated Cloudflare Worker Durable Object** that runs a Mastra `Agent` for **human-in-the-loop suspend/resume** across voice turns. It pairs Mastra's own snapshot storage (`@mastra/cloudflare` `CloudflareDOStorage` on `ctx.storage.sql`) with a tiny `{contextId → runId}` pointer store and the [`ReasoningBridge`](../aisdk/README.md).
+
+This is **separate from** the lean AI-SDK product worker (`@kuralle-syrinx/server-workers`), which stays Mastra-free + edge-bundle-clean. Mastra (≈8 MB, `nodejs_compat`) is quarantined here.
+
+## How it works
+
+```
+turn 1 (/suspend):  agent.stream(...) → tool-call-suspended
+   ReasoningBridge → llm.done(question) + reasoning.suspended packet
+   DurableObjectRunStore.save(contextId, runId)          // pointer in reasoning_run_pointers
+   Mastra snapshot persisted in CloudflareDOStorage      // mastra_workflow_snapshot
+
+   ── DO may hibernate between turns ──
+
+turn 2 (/resume):  RunStore.takePending(contextId) → runId
+   bridge builds ReasonerTurn.resume → agent.resumeStream(data, {runId})
+   Mastra reloads the snapshot from ctx.storage.sql on a fresh instance → completes
+   RunStore.discard(contextId)
+```
+
+`DurableObjectRunStore` (`src/durable-run-store.ts`) implements the bridge's `RunStore` interface over `ctx.storage.sql` (`reasoning_run_pointers(context_id PK, run_id, created_at_ms)`), with TTL-GC via a DO alarm — mirroring `DurableObjectSessionStore`.
+
+## Deploy
+
+```bash
+pnpm --filter @kuralle-syrinx/server-workers-mastra exec wrangler deploy
+wrangler secret put OPENAI_API_KEY   # real model; absent → deterministic stub (tests)
+```
+
+`wrangler.toml` sets `compatibility_flags = ["nodejs_compat"]` + the `MastraAgentDO` SQLite DO binding. Endpoints: `/health`, `/suspend?contextId=`, `POST /resume?contextId=` (`{userText}`).
+
+## Requirements & gotchas
+
+- **`nodejs_compat`** — `@mastra/core` needs Node builtins; bundle via **wrangler** (it handles the `.wasm` + node polyfills), not raw esbuild.
+- **Workers Paid tier** — the bundle is ~8 MB (exceeds the 3 MiB Free limit; within the 10 MiB Paid limit). A bundle diet to reach Free is backlog (RFC §9, B-05).
+- **No filesystem on edge** — the Mastra agent must **not** use `fs`/workspace tools (`@mastra/core` bundles `fs`/`@ast-grep/napi`, but they fail on Workers if exercised).
+- **Mastra owns the checkpoint**, we own the pointer — cross-turn resume works because `CloudflareDOStorage` persists the snapshot durably in the DO's SQLite (proven across a fresh instance over the same SQL).
+
+## Tests
+
+The workerd two-turn suspend→resume test is opt-in (slow — spins `wrangler unstable_dev`):
+
+```bash
+SYRINX_MASTRA_EDGE_TEST=1 pnpm --filter @kuralle-syrinx/server-workers-mastra test
+```
+
+It uses a deterministic stub model (no network).

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@kuralle-syrinx/server-workers-mastra",
+  "version": "2.1.0",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "main": "./src/worker.ts",
+  "types": "./src/worker.ts",
+  "dependencies": {
+    "@ai-sdk/openai": "^3.0.67",
+    "@mastra/cloudflare": "^1.4.1",
+    "@mastra/core": "^1.41.0",
+    "zod": "^4.1.8",
+    "@kuralle-syrinx/core": "2.1.0",
+    "@kuralle-syrinx/mastra": "2.1.0",
+    "@kuralle-syrinx/aisdk": "2.1.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260601.0",
+    "miniflare": "^4.20260601.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0",
+    "wrangler": "^4.19.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:edge": "SYRINX_MASTRA_EDGE_TEST=1 vitest run",
+    "wrangler:dry-run": "wrangler deploy --dry-run"
+  }
+}

package/src/alarm-scheduler.ts

@@ -0,0 +1,67 @@
+// 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-run-store.ts

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+
+import type { RunPointer, RunStore } from "@kuralle-syrinx/aisdk";
+import type { DurableObjectAlarmScheduler } from "./alarm-scheduler.js";
+
+type SqlCursor<T> = Iterable<T>;
+
+interface SqlStorage {
+  exec(query: string, ...bindings: unknown[]): SqlCursor<Record<string, unknown>>;
+}
+
+export interface DurableRunStorage {
+  readonly sql: SqlStorage;
+}
+
+export const DEFAULT_RUN_POINTER_TTL_MS = 15 * 60 * 1000;
+
+export class DurableObjectRunStore implements RunStore {
+  constructor(
+    private readonly storage: DurableRunStorage,
+    private readonly scheduler: DurableObjectAlarmScheduler,
+    private readonly ttlMs = DEFAULT_RUN_POINTER_TTL_MS,
+  ) {
+    this.storage.sql.exec(
+      `CREATE TABLE IF NOT EXISTS reasoning_run_pointers (
+        context_id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        created_at_ms INTEGER NOT NULL
+      )`,
+    );
+  }
+
+  save(contextId: string, runId: string): void {
+    this.storage.sql.exec(
+      "INSERT OR REPLACE INTO reasoning_run_pointers (context_id, run_id, created_at_ms) VALUES (?, ?, ?)",
+      contextId,
+      runId,
+      Date.now(),
+    );
+    this.scheduler.schedule(`run.ttl:${contextId}`, this.ttlMs, () => {
+      this.discard(contextId);
+    });
+  }
+
+  takePending(contextId: string): RunPointer | null {
+    const [row] = [...this.storage.sql.exec(
+      "SELECT run_id FROM reasoning_run_pointers WHERE context_id = ?",
+      contextId,
+    )] as Array<{ run_id: string }>;
+    return row ? { runId: row.run_id } : null;
+  }
+
+  discard(contextId: string): void {
+    this.scheduler.cancel(`run.ttl:${contextId}`);
+    this.storage.sql.exec("DELETE FROM reasoning_run_pointers WHERE context_id = ?", contextId);
+  }
+}

package/src/mock-model.ts

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: MIT
+
+type SqlStorage = {
+  exec(query: string, ...bindings: unknown[]): Iterable<Record<string, unknown>>;
+};
+
+function nextModelCall(sql: SqlStorage, key: string): number {
+  sql.exec(
+    `CREATE TABLE IF NOT EXISTS spike_mock_calls (
+      key TEXT PRIMARY KEY,
+      count INTEGER NOT NULL
+    )`,
+  );
+  const [row] = [...sql.exec("SELECT count FROM spike_mock_calls WHERE key = ?", key)];
+  const current = typeof row?.count === "number" ? row.count : 0;
+  const next = current + 1;
+  sql.exec("INSERT OR REPLACE INTO spike_mock_calls (key, count) VALUES (?, ?)", key, next);
+  return next;
+}
+
+function toolCallStream(): ReadableStream<unknown> {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue({ type: "stream-start", warnings: [] });
+      controller.enqueue({
+        type: "response-metadata",
+        id: "id-0",
+        modelId: "mock",
+        timestamp: new Date(0),
+      });
+      controller.enqueue({
+        type: "tool-call",
+        toolCallId: "call-1",
+        toolName: "confirmAction",
+        input: '{"action":"deploy"}',
+        providerExecuted: false,
+      });
+      controller.enqueue({
+        type: "finish",
+        finishReason: "tool-calls",
+        usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },
+      });
+      controller.close();
+    },
+  });
+}
+
+function textStream(): ReadableStream<unknown> {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue({ type: "stream-start", warnings: [] });
+      controller.enqueue({
+        type: "response-metadata",
+        id: "id-1",
+        modelId: "mock",
+        timestamp: new Date(0),
+      });
+      controller.enqueue({ type: "text-start", id: "text-1" });
+      controller.enqueue({ type: "text-delta", id: "text-1", delta: "Deployed successfully." });
+      controller.enqueue({ type: "text-end", id: "text-1" });
+      controller.enqueue({
+        type: "finish",
+        finishReason: "stop",
+        usage: { inputTokens: 10, outputTokens: 20, totalTokens: 30 },
+      });
+      controller.close();
+    },
+  });
+}
+
+export function createSpikeMockModel(sql: SqlStorage, key = "mastra-session") {
+  return {
+    specificationVersion: "v2" as const,
+    provider: "spike-mock",
+    modelId: "spike-mock-v1",
+    supportedUrls: {},
+    doStream: async () => {
+      const callCount = nextModelCall(sql, key);
+      const stream = callCount === 1 ? toolCallStream() : textStream();
+      return {
+        stream,
+        rawCall: { rawPrompt: null, rawSettings: {} },
+        warnings: [],
+      };
+    },
+    doGenerate: async () => ({
+      content: [{ type: "text", text: "mock" }],
+      finishReason: "stop" as const,
+      usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+      rawCall: { rawPrompt: null, rawSettings: {} },
+      warnings: [],
+    }),
+  };
+}
+
+export function resetMockModelCalls(sql: SqlStorage, key = "mastra-session"): void {
+  sql.exec(
+    `CREATE TABLE IF NOT EXISTS spike_mock_calls (
+      key TEXT PRIMARY KEY,
+      count INTEGER NOT NULL
+    )`,
+  );
+  sql.exec("DELETE FROM spike_mock_calls WHERE key = ?", key);
+}

package/src/worker.test.ts

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: MIT
+
+import { existsSync } from "node:fs";
+import { mkdtemp, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { unstable_dev, type Unstable_DevWorker } from "wrangler";
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+
+const execFileAsync = promisify(execFile);
+const PACKAGE_ROOT = fileURLToPath(new URL("../", import.meta.url));
+const mastraEdgeEnabled = process.env["SYRINX_MASTRA_EDGE_TEST"] === "1";
+
+type SuspendBody = {
+  phase: string;
+  contextId: string;
+  runId: string | null;
+  suspended: boolean;
+  prompt: string | null;
+  pointer: { runId: string } | null;
+  mastraTables: string[];
+  packetKinds: string[];
+  error?: string;
+};
+
+type ResumeBody = {
+  phase: string;
+  contextId: string;
+  suspended: boolean;
+  text: string;
+  pointer: { runId: string } | null;
+  mastraTables: string[];
+  packetKinds: string[];
+  error?: string;
+};
+
+const tempDirs: string[] = [];
+let bundleOutdir = "";
+let bundleSizeKb = 0;
+let bundleLog = "";
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("voice-server-workers-mastra default suite", () => {
+  it("gates workerd two-turn test behind SYRINX_MASTRA_EDGE_TEST", () => {
+    expect(mastraEdgeEnabled || process.env["SYRINX_MASTRA_EDGE_TEST"] !== "1").toBe(true);
+  });
+});
+
+describe.skipIf(!mastraEdgeEnabled)("mastra edge suspend/resume", () => {
+  beforeAll(async () => {
+    const outdir = await mkdtemp(join(tmpdir(), "mastra-edge-bundle-"));
+    const wranglerBin = join(PACKAGE_ROOT, "node_modules/.bin/wrangler");
+    const { stdout, stderr } = await execFileAsync(
+      wranglerBin,
+      ["deploy", "--dry-run", "--outdir", outdir],
+      { cwd: PACKAGE_ROOT, env: process.env },
+    );
+    bundleLog = `${stdout}\n${stderr}`;
+    const workerPath = join(outdir, "worker.js");
+    if (!existsSync(workerPath)) {
+      throw new Error(`wrangler bundle missing worker.js\n${bundleLog}`);
+    }
+    bundleOutdir = outdir;
+    const bundleStat = await stat(workerPath);
+    bundleSizeKb = Math.round(bundleStat.size / 1024);
+  }, 120_000);
+
+  async function startDevWorker(): Promise<Unstable_DevWorker> {
+    return unstable_dev(join(PACKAGE_ROOT, "src/worker.ts"), {
+      config: join(PACKAGE_ROOT, "wrangler.toml"),
+      local: true,
+      compatibilityDate: "2026-06-01",
+      compatibilityFlags: ["nodejs_compat"],
+      experimental: { disableExperimentalWarning: true },
+    });
+  }
+
+  it("bundles @mastra/core + @mastra/cloudflare via wrangler (nodejs_compat)", () => {
+    expect(bundleOutdir).toBeTruthy();
+    expect(bundleSizeKb).toBeGreaterThan(0);
+    expect(bundleLog).not.toMatch(/Could not resolve|unresolved|ERROR/i);
+  }, 10_000);
+
+  it("suspend → fresh DO/same SQL → resume via ReasoningBridge + pointer RunStore", async () => {
+    const worker = await startDevWorker();
+    const fsHits: string[] = [];
+    const originalConsoleError = console.error;
+    console.error = (...args: unknown[]) => {
+      const line = args.map(String).join(" ");
+      if (/ENOENT|readFileSync|existsSync|fs\./i.test(line)) fsHits.push(line);
+      originalConsoleError(...args);
+    };
+
+    try {
+      const health = await worker.fetch("http://localhost/health");
+      expect(health.status).toBe(200);
+      expect(await health.text()).toBe("ok");
+
+      const suspendRes = await worker.fetch("http://localhost/suspend");
+      const suspendBody = await suspendRes.json() as SuspendBody | { error: string };
+      if ("error" in suspendBody) {
+        throw new Error(`suspend failed: ${suspendBody.error}`);
+      }
+
+      expect(suspendRes.status).toBe(200);
+      expect(suspendBody.phase).toBe("suspend");
+      expect(suspendBody.suspended).toBe(true);
+      expect(suspendBody.runId).toBeTruthy();
+      expect(suspendBody.pointer).toEqual({ runId: suspendBody.runId });
+      expect(suspendBody.packetKinds).toContain("reasoning.suspended");
+      expect(suspendBody.packetKinds).toContain("llm.done");
+      expect(suspendBody.mastraTables.some((name) => name.includes("mastra") || name.includes("workflow"))).toBe(true);
+
+      const resumeRes = await worker.fetch("http://localhost/resume", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ userText: "yes" }),
+      });
+      const resumeBody = await resumeRes.json() as ResumeBody | { error: string };
+      if ("error" in resumeBody) {
+        throw new Error(`resume failed: ${resumeBody.error}`);
+      }
+
+      expect(resumeRes.status).toBe(200);
+      expect(resumeBody.phase).toBe("resume");
+      expect(resumeBody.suspended).toBe(false);
+      expect(resumeBody.text).toContain("Deployed successfully");
+      expect(resumeBody.packetKinds).toContain("llm.done");
+      expect(resumeBody.pointer).toBeNull();
+
+      if (fsHits.length > 0) {
+        // eslint-disable-next-line no-console
+        console.log("[fs hits]", fsHits);
+      }
+    } finally {
+      console.error = originalConsoleError;
+      await worker.stop();
+    }
+  }, 120_000);
+});

package/src/worker.ts

@@ -0,0 +1,247 @@
+// SPDX-License-Identifier: MIT
+
+import { DurableObject } from "cloudflare:workers";
+import { CloudflareDOStorage } from "@mastra/cloudflare/do";
+import { Agent } from "@mastra/core/agent";
+import { Mastra } from "@mastra/core";
+import { createTool } from "@mastra/core/tools";
+import { createOpenAI } from "@ai-sdk/openai";
+import { z } from "zod";
+import { PipelineBusImpl, Route } from "@kuralle-syrinx/core";
+import type { EndOfSpeechPacket } from "@kuralle-syrinx/core";
+import { ReasoningBridge } from "@kuralle-syrinx/aisdk";
+import { fromMastraAgent, type MastraAgentLike } from "@kuralle-syrinx/mastra";
+import { DurableObjectAlarmScheduler } from "./alarm-scheduler.js";
+import { DurableObjectRunStore } from "./durable-run-store.js";
+import { createSpikeMockModel, resetMockModelCalls } from "./mock-model.js";
+
+export interface Env {
+  MASTRA_AGENT: DurableObjectNamespace;
+  /** When set, the agent uses a real OpenAI model (gpt-4.1-mini); else a deterministic stub (tests). */
+  OPENAI_API_KEY?: string;
+}
+
+const DEFAULT_CONTEXT_ID = "mastra-session";
+
+type SqlStorage = DurableObjectState["storage"]["sql"];
+
+function isConfirmed(resumeData: unknown): boolean {
+  if (typeof resumeData === "object" && resumeData !== null && "confirmed" in resumeData) {
+    return (resumeData as { confirmed?: boolean }).confirmed === true;
+  }
+  if (typeof resumeData === "string") {
+    const normalized = resumeData.trim().toLowerCase();
+    return normalized === "yes" || normalized === "confirm" || normalized === "confirmed";
+  }
+  return false;
+}
+
+const confirmTool = createTool({
+  id: "confirm-action",
+  description: "Confirms an action with the user",
+  inputSchema: z.object({ action: z.string() }),
+  suspendSchema: z.object({
+    action: z.string(),
+    reason: z.string().optional(),
+  }),
+  resumeSchema: z.object({
+    confirmed: z.boolean(),
+  }),
+  execute: async (input: { action: string }, context) => {
+    const ctx = context as {
+      resumeData?: unknown;
+      suspend?: (payload: { action: string; reason?: string }) => Promise<void>;
+      agent?: { resumeData?: unknown; suspend?: (payload: { action: string; reason?: string }) => Promise<void> };
+      workflow?: { resumeData?: unknown; suspend?: (payload: { action: string; reason?: string }) => Promise<void> };
+    } | undefined;
+    const resumeData = ctx?.resumeData ?? ctx?.agent?.resumeData ?? ctx?.workflow?.resumeData;
+    if (isConfirmed(resumeData)) {
+      return { result: `Action "${input.action}" confirmed`, resumed: true };
+    }
+    const suspend = ctx?.suspend ?? ctx?.agent?.suspend ?? ctx?.workflow?.suspend;
+    if (!suspend) throw new Error("suspend not available in tool context");
+    return await suspend({ action: input.action, reason: "Needs user confirmation" });
+  },
+});
+
+function toMastraAgentLike(agent: Agent): MastraAgentLike {
+  return {
+    stream: (messages, options) =>
+      agent.stream(messages as never, {
+        abortSignal: options?.abortSignal,
+        requireToolApproval: false,
+        autoResumeSuspendedTools: false,
+      }) as unknown as ReturnType<MastraAgentLike["stream"]>,
+    resumeStream: (resumeData, options) =>
+      agent.resumeStream(resumeData, {
+        runId: options.runId,
+        toolCallId: options.toolCallId,
+        abortSignal: options.abortSignal,
+        requireToolApproval: false,
+      }) as unknown as ReturnType<MastraAgentLike["resumeStream"]>,
+  };
+}
+
+function createMastra(sql: SqlStorage, apiKey?: string): { mastra: Mastra; agent: Agent } {
+  const storage = new CloudflareDOStorage({ sql });
+  // Real OpenAI model when a key is provided (live deploy); deterministic stub otherwise (tests).
+  const model = apiKey
+    ? (createOpenAI({ apiKey })("gpt-4.1-mini") as never)
+    : (createSpikeMockModel(sql) as never);
+  const agent = new Agent({
+    id: "support",
+    name: "Support Agent",
+    instructions:
+      "You confirm potentially destructive actions with the user before doing them. " +
+      "When asked to deploy, call the confirmAction tool to get confirmation first.",
+    model,
+    tools: { confirmAction: confirmTool },
+  });
+  const mastra = new Mastra({
+    agents: { support: agent },
+    storage,
+    logger: false,
+  });
+  return { mastra, agent };
+}
+
+function turnComplete(contextId: string, text: string): EndOfSpeechPacket {
+  return {
+    kind: "eos.turn_complete",
+    contextId,
+    timestampMs: Date.now(),
+    text,
+    transcripts: [],
+  };
+}
+
+function listMastraTables(sql: SqlStorage): string[] {
+  const rows = [...sql.exec(
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name",
+  )] as Array<{ name: string }>;
+  return rows.map((row) => row.name);
+}
+
+function readPointer(sql: SqlStorage, contextId: string): { runId: string } | null {
+  const [row] = [...sql.exec(
+    "SELECT run_id FROM reasoning_run_pointers WHERE context_id = ?",
+    contextId,
+  )] as Array<{ run_id: string }>;
+  return row ? { runId: row.run_id } : null;
+}
+
+async function driveTurn(
+  storage: DurableObjectState["storage"],
+  contextId: string,
+  userText: string,
+  apiKey?: string,
+): Promise<{
+  packets: Array<{ route: Route; packet: Record<string, unknown> }>;
+  pointer: { runId: string } | null;
+  mastraTables: string[];
+}> {
+  const scheduler = new DurableObjectAlarmScheduler(storage);
+  const runStore = new DurableObjectRunStore(storage, scheduler);
+  const { agent } = createMastra(storage.sql, apiKey);
+  const bridge = new ReasoningBridge(fromMastraAgent(toMastraAgentLike(agent)), {
+    runStore,
+    onResumeConflict: "restart",
+  });
+  const packets: Array<{ route: Route; packet: Record<string, unknown> }> = [];
+  const bus = new PipelineBusImpl({
+    onPacket: (route, packet) => {
+      packets.push({ route, packet: packet as unknown as Record<string, unknown> });
+    },
+  });
+  const drain = bus.start();
+  await bridge.initialize(bus, { timeout_ms: 30_000, max_history_turns: 12 });
+  bus.push(Route.Main, turnComplete(contextId, userText));
+
+  const deadline = Date.now() + 30_000;
+  while (Date.now() < deadline) {
+    const done = packets.some(({ packet }) =>
+      packet["kind"] === "llm.done" || packet["kind"] === "reasoning.suspended",
+    );
+    if (done) break;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+
+  bus.stop();
+  await drain;
+  await bridge.close();
+
+  return {
+    packets,
+    pointer: readPointer(storage.sql, contextId),
+    mastraTables: listMastraTables(storage.sql),
+  };
+}
+
+export class MastraAgentDO extends DurableObject<Env> {
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    const contextId = url.searchParams.get("contextId") ?? DEFAULT_CONTEXT_ID;
+
+    try {
+      if (url.pathname === "/health") {
+        return new Response("ok");
+      }
+
+      if (url.pathname === "/suspend") {
+        if (!this.env.OPENAI_API_KEY) resetMockModelCalls(this.ctx.storage.sql, contextId);
+        const result = await driveTurn(this.ctx.storage, contextId, "Deploy to production", this.env.OPENAI_API_KEY);
+        const suspended = result.packets.find(({ packet }) => packet["kind"] === "reasoning.suspended");
+        const llmDone = result.packets.find(({ packet }) => packet["kind"] === "llm.done");
+        return Response.json({
+          phase: "suspend",
+          contextId,
+          suspended: suspended !== undefined,
+          runId: suspended?.packet["runId"] ?? null,
+          prompt: suspended?.packet["prompt"] ?? llmDone?.packet["text"] ?? null,
+          pointer: result.pointer,
+          mastraTables: result.mastraTables,
+          packetKinds: result.packets.map(({ packet }) => packet["kind"]),
+        });
+      }
+
+      if (url.pathname === "/resume") {
+        const body = await request.json() as { userText?: string };
+        const userText = body.userText ?? "yes";
+        const result = await driveTurn(this.ctx.storage, contextId, userText, this.env.OPENAI_API_KEY);
+        const llmDone = result.packets.find(({ packet }) => packet["kind"] === "llm.done");
+        const suspended = result.packets.find(({ packet }) => packet["kind"] === "reasoning.suspended");
+        return Response.json({
+          phase: "resume",
+          contextId,
+          suspended: suspended !== undefined,
+          text: llmDone?.packet["text"] ?? "",
+          pointer: result.pointer,
+          mastraTables: result.mastraTables,
+          packetKinds: result.packets.map(({ packet }) => packet["kind"]),
+        });
+      }
+
+      return new Response("not found", { status: 404 });
+    } catch (error) {
+      const message = error instanceof Error ? `${error.name}: ${error.message}\n${error.stack ?? ""}` : String(error);
+      return Response.json({ error: message }, { status: 500 });
+    }
+  }
+
+  async alarm(): Promise<void> {
+    const scheduler = new DurableObjectAlarmScheduler(this.ctx.storage);
+    await scheduler.runDue();
+  }
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const url = new URL(request.url);
+    if (url.pathname === "/health") {
+      return new Response("ok");
+    }
+    const id = env.MASTRA_AGENT.idFromName("mastra-session");
+    const stub = env.MASTRA_AGENT.get(id);
+    return stub.fetch(request);
+  },
+};

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.toml

@@ -0,0 +1,13 @@
+name = "voice-server-workers-mastra"
+main = "src/worker.ts"
+compatibility_date = "2026-06-01"
+compatibility_flags = ["nodejs_compat"]
+
+[durable_objects]
+bindings = [
+  { name = "MASTRA_AGENT", class_name = "MastraAgentDO" }
+]
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["MastraAgentDO"]