@kuralle-syrinx/server-workers-mastra 2.1.1 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuralle-syrinx/server-workers-mastra",
-  "version": "2.1.1",
+  "version": "3.1.0",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -11,9 +11,9 @@
     "@mastra/cloudflare": "^1.4.1",
     "@mastra/core": "^1.41.0",
     "zod": "^4.1.8",
-    "@kuralle-syrinx/core": "2.1.1",
-    "@kuralle-syrinx/aisdk": "2.1.1",
-    "@kuralle-syrinx/mastra": "2.1.1"
+    "@kuralle-syrinx/core": "3.1.0",
+    "@kuralle-syrinx/aisdk": "3.1.0",
+    "@kuralle-syrinx/mastra": "3.1.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20260601.0",

package/src/durable-run-store.ts

@@ -1,7 +1,11 @@
 // SPDX-License-Identifier: MIT
+//
+// RunStore for the mastra HITL suspend/resume flow, backed by the Durable Object's
+// SQLite (the storage Mastra's own CloudflareDOStorage uses). Stale run pointers
+// expire lazily on read — no scheduled-alarm cleanup needed, so the DO does not
+// re-implement a task scheduler.
 
 import type { RunPointer, RunStore } from "@kuralle-syrinx/aisdk";
-import type { DurableObjectAlarmScheduler } from "./alarm-scheduler.js";
 
 type SqlCursor<T> = Iterable<T>;
 
@@ -18,7 +22,6 @@ 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(
@@ -37,21 +40,23 @@ export class DurableObjectRunStore implements RunStore {
       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 = ?",
+      "SELECT run_id, created_at_ms FROM reasoning_run_pointers WHERE context_id = ?",
       contextId,
-    )] as Array<{ run_id: string }>;
-    return row ? { runId: row.run_id } : null;
+    )] as Array<{ run_id: string; created_at_ms: number }>;
+    if (!row) return null;
+    // Lazy TTL: a pointer past its window is treated as absent and swept on read.
+    if (Date.now() - Number(row.created_at_ms) > this.ttlMs) {
+      this.discard(contextId);
+      return null;
+    }
+    return { runId: row.run_id };
   }
 
   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/worker.ts

@@ -11,7 +11,6 @@ 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";
 
@@ -140,8 +139,7 @@ async function driveTurn(
   pointer: { runId: string } | null;
   mastraTables: string[];
 }> {
-  const scheduler = new DurableObjectAlarmScheduler(storage);
-  const runStore = new DurableObjectRunStore(storage, scheduler);
+  const runStore = new DurableObjectRunStore(storage);
   const { agent } = createMastra(storage.sql, apiKey);
   const bridge = new ReasoningBridge(fromMastraAgent(toMastraAgentLike(agent)), {
     runStore,
@@ -227,11 +225,6 @@ export class MastraAgentDO extends DurableObject<Env> {
       return Response.json({ error: message }, { status: 500 });
     }
   }
-
-  async alarm(): Promise<void> {
-    const scheduler = new DurableObjectAlarmScheduler(this.ctx.storage);
-    await scheduler.runDue();
-  }
 }
 
 export default {

package/src/alarm-scheduler.ts

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