@toren-run/core 0.1.0

package/dist/workflow.js

@@ -0,0 +1,210 @@
+import { canonicalDigest } from "./digest.js";
+import { ev } from "./events.js";
+export class WorkflowBlocked extends Error {
+    reason;
+    constructor(reason) {
+        super(`workflow blocked: ${reason}`);
+        this.reason = reason;
+    }
+}
+export class WaveFailedError extends Error {
+}
+export class RunLeaseLostError extends Error {
+}
+export function foldRunStream(eff) {
+    const state = { sideEffects: [], waves: [], timers: [], started: false };
+    for (const e of eff) {
+        switch (e.type) {
+            case "RunStarted":
+                state.started = true;
+                break;
+            case "SideEffectRecorded":
+                state.sideEffects.push(e);
+                break;
+            case "WavePlanned":
+                state.waves.push({
+                    seq: e.seq,
+                    waveId: String(e.payload.waveId),
+                    index: Number(e.payload.index),
+                    name: String(e.payload.name),
+                    tasks: e.payload.tasks,
+                    planDigest: String(e.payload.planDigest),
+                    dispatched: false,
+                    settledTasks: new Map(),
+                    settled: false,
+                });
+                break;
+            case "WaveDispatched": {
+                const w = state.waves.find((x) => x.waveId === e.payload.waveId);
+                if (w)
+                    w.dispatched = true;
+                break;
+            }
+            case "WaveTaskSettled": {
+                const w = state.waves.find((x) => x.waveId === e.payload.waveId);
+                if (w) {
+                    w.settledTasks.set(String(e.payload.taskId), {
+                        taskId: String(e.payload.taskId),
+                        status: e.payload.status,
+                        output: e.payload.output,
+                        error: e.payload.error,
+                    });
+                }
+                break;
+            }
+            case "WaveSettled": {
+                const w = state.waves.find((x) => x.waveId === e.payload.waveId);
+                if (w)
+                    w.settled = true;
+                break;
+            }
+            case "TimerSet":
+                state.timers.push({ seq: e.seq, timerId: String(e.payload.timerId), fireAt: Number(e.payload.fireAt), fired: false });
+                break;
+            case "TimerFired": {
+                const t = state.timers.find((x) => x.timerId === e.payload.timerId);
+                if (t)
+                    t.fired = true;
+                break;
+            }
+            case "RunCompleted":
+                state.terminal = { status: "completed", output: e.payload.output };
+                break;
+            case "RunFailed":
+                state.terminal = { status: "failed", error: e.payload.error };
+                break;
+            case "RunCancelled":
+                state.terminal = { status: "cancelled" };
+                break;
+            default: break;
+        }
+    }
+    return state;
+}
+export function makeSession(store, runId, input, raw, eff, parkedTasks = new Set()) {
+    return {
+        store, runId, input,
+        head: raw.at(-1)?.seq ?? 0,
+        folded: foldRunStream(eff),
+        seCursor: 0, waveCursor: 0, timerCursor: 0,
+        invalidated: false,
+        pendingDispatch: [],
+        parkedTasks,
+    };
+}
+export function createWorkflowCtx(s) {
+    async function append(events) {
+        const r = await s.store.append(s.runId, "run", s.head, events);
+        if (!r.ok)
+            throw new RunLeaseLostError(`run stream advanced concurrently (expected ${s.head}, actual ${r.actualSeq})`);
+        s.head = r.lastSeq;
+    }
+    async function invalidateFrom(fromSeq, reason) {
+        await append([ev("StreamInvalidated", { fromSeq, reason })]);
+        s.invalidated = true; // all remaining recorded entries are void (consumption is seq-ordered)
+    }
+    async function sideEffect(kind, generate) {
+        const rec = s.invalidated ? undefined : s.folded.sideEffects[s.seCursor];
+        if (rec) {
+            if (rec.payload.kind !== kind) {
+                await invalidateFrom(rec.seq, `side effect kind changed (recorded ${String(rec.payload.kind)}, expected ${kind})`);
+            }
+            else {
+                s.seCursor += 1;
+                return Number(rec.payload.value);
+            }
+        }
+        const value = generate();
+        await append([ev("SideEffectRecorded", { stepId: `s${s.head + 1}`, kind, value })]);
+        return value;
+    }
+    function enqueueTaskMessages(w) {
+        for (const t of w.tasks) {
+            if (!w.settledTasks.has(t.taskId) && !s.parkedTasks.has(t.taskId)) {
+                s.pendingDispatch.push({ queue: "tasks-short", msg: { kind: "task", runId: s.runId, taskId: t.taskId, dedupeKey: `${s.runId}:${t.taskId}` } });
+            }
+        }
+    }
+    return {
+        input: s.input,
+        task: (agentRef, input) => ({ agentRef, input }),
+        now: () => sideEffect("now", () => Date.now()),
+        random: () => sideEffect("random", () => Math.random()),
+        async sleep(ms) {
+            const rec = s.invalidated ? undefined : s.folded.timers[s.timerCursor];
+            if (rec) {
+                s.timerCursor += 1;
+                if (rec.fired)
+                    return;
+                if (Date.now() >= rec.fireAt) {
+                    await append([ev("TimerFired", { timerId: rec.timerId })]);
+                    return;
+                }
+                s.pendingDispatch.push({
+                    queue: "orchestrator",
+                    msg: { kind: "tick", runId: s.runId, dedupeKey: `timer-${rec.timerId}` },
+                    delaySeconds: Math.max(0.05, (rec.fireAt - Date.now()) / 1000),
+                });
+                throw new WorkflowBlocked(`timer ${rec.timerId}`);
+            }
+            const base = await this.now();
+            const fireAt = base + ms;
+            const timerId = `tm${s.head + 1}`;
+            await append([ev("TimerSet", { timerId, fireAt })]);
+            if (Date.now() >= fireAt) {
+                await append([ev("TimerFired", { timerId })]);
+                return;
+            }
+            s.pendingDispatch.push({
+                queue: "orchestrator",
+                msg: { kind: "tick", runId: s.runId, dedupeKey: `timer-${timerId}` },
+                delaySeconds: Math.max(0.05, ms / 1000),
+            });
+            throw new WorkflowBlocked(`timer ${timerId}`);
+        },
+        async wave(name, tasks, opts) {
+            const planDigest = canonicalDigest({ name, tasks });
+            let w = s.invalidated ? undefined : s.folded.waves[s.waveCursor];
+            if (w && w.planDigest !== planDigest) {
+                await invalidateFrom(w.seq, `wave plan changed (${name})`);
+                w = undefined;
+            }
+            if (!w) {
+                const index = s.waveCursor;
+                const waveId = `w${index}`;
+                w = {
+                    seq: s.head + 1, waveId, index, name,
+                    tasks: tasks.map((t, i) => ({ taskId: `${waveId}t${i}`, agentRef: t.agentRef, input: t.input })),
+                    planDigest, dispatched: false, settledTasks: new Map(), settled: false,
+                };
+                await append([ev("WavePlanned", { waveId, index, name, tasks: w.tasks, planDigest })]);
+                await append([ev("WaveDispatched", { waveId })]);
+                w.dispatched = true;
+                // task hints are enqueued once below, by the unsettled branch
+            }
+            s.waveCursor += 1;
+            const allSettled = w.tasks.every((t) => w.settledTasks.has(t.taskId));
+            if (!allSettled) {
+                // Messages are hints: re-nudge outstanding tasks so a lost
+                // dispatch self-heals on the next tick; duplicates no-op at the worker.
+                enqueueTaskMessages(w);
+                throw new WorkflowBlocked(`wave ${name} unsettled`);
+            }
+            const results = w.tasks.map((t) => w.settledTasks.get(t.taskId));
+            if (!w.settled) {
+                const coverage = {
+                    dispatched: w.tasks.length,
+                    completed: results.filter((r) => r.status === "completed").length,
+                    failed: results.filter((r) => r.status === "failed").length,
+                };
+                await append([ev("WaveSettled", { waveId: w.waveId, coverage })]);
+                w.settled = true;
+            }
+            if ((opts?.onTaskFailure ?? "fail") === "fail" && results.some((r) => r.status === "failed")) {
+                const failed = results.filter((r) => r.status === "failed").map((r) => `${r.taskId}: ${r.error ?? "unknown"}`);
+                throw new WaveFailedError(`wave ${name} failed: ${failed.join("; ")}`);
+            }
+            return { name, results };
+        },
+    };
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@toren-run/core",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "pg": "^8.13.0",
+    "zod": "^3.23.0",
+    "zod-to-json-schema": "^3.23.0",
+    "@opentelemetry/api": "^1.9.0",
+    "croner": "^8.1.0"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.11.0",
+    "@opentelemetry/sdk-trace-node": "^2.0.0",
+    "@opentelemetry/sdk-trace-base": "^2.0.0"
+  },
+  "description": "Durable agent runtime core: append-only Postgres event log, token replay, leases, workflows, approvals.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toren-run/toren.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://toren.run",
+  "bugs": "https://github.com/toren-run/toren/issues",
+  "keywords": [
+    "agents",
+    "ai",
+    "durable-execution",
+    "workflow",
+    "postgres",
+    "anthropic",
+    "llm"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json"
+  }
+}