@toren-run/core 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,9 @@
+# @toren-run/core
+
+The engine of [Toren](https://toren.run), the open-source runtime for long-running, durable AI agents. This package is the durability itself: the append-only Postgres event log, the agent task loop, the orchestrator with parallel waves, workers, leases, guardians, approvals, schedules, and sessions. A resumed run never re-pays for a completed model call; a CI kill matrix crashes the stack after every database write and asserts exactly-once billing.
+
+Most people want the CLI instead: `npm install toren-run` gives you `toren init`, `toren dev`, the HTTP API, and the web console, all built on this package. Reach for `@toren-run/core` directly when you embed the runtime in your own host process: `startRun`, `tick`, `LocalWorkerRuntime`, `defineTool`, and friends.
+
+Zero model SDKs in here. The core depends on `pg` and `zod`, nothing environment-specific; providers, queues, and sandboxes plug in behind interfaces.
+
+**Docs:** [toren.run/docs](https://toren.run/docs) (durability and architecture live under Concepts). Apache-2.0.

package/dist/loop.js

@@ -129,14 +129,24 @@ async function runTaskLoopImpl(args) {
             else {
                 // Crash window: call was issued but the response never landed. Re-issue (at-least-once).
                 ptr += 1;
-                response = await withSpan("toren.llm", { "gen_ai.request.model": request.model }, () => provider.complete(request));
+                response = await withSpan("toren.llm", { "gen_ai.request.model": request.model }, async (span) => {
+                    const r = await provider.complete(request);
+                    if (r.usage)
+                        span.setAttributes({ "gen_ai.usage.input_tokens": r.usage.inputTokens, "gen_ai.usage.output_tokens": r.usage.outputTokens });
+                    return r;
+                });
                 await append([ev("LlmCallCompleted", { stepId: next.payload.stepId, response, usage: response.usage })]);
             }
         }
         else {
             const stepId = `s${head + 1}`;
             await append([ev("LlmCallStarted", { stepId, requestDigest: digest, model: request.model })]);
-            response = await withSpan("toren.llm", { "gen_ai.request.model": request.model }, () => provider.complete(request));
+            response = await withSpan("toren.llm", { "gen_ai.request.model": request.model }, async (span) => {
+                const r = await provider.complete(request);
+                if (r.usage)
+                    span.setAttributes({ "gen_ai.usage.input_tokens": r.usage.inputTokens, "gen_ai.usage.output_tokens": r.usage.outputTokens });
+                return r;
+            });
             await append([ev("LlmCallCompleted", { stepId, response, usage: response.usage })]);
         }
         if (response.usage) {

package/dist/orchestrator.js

@@ -107,14 +107,15 @@ async function tickImpl(deps, runId) {
             const r = await deps.store.append(runId, "run", session.head, [ev("RunCompleted", { output })]);
             if (!r.ok)
                 throw new RunLeaseLostError("run stream advanced concurrently");
-            await deps.store.updateRun(runId, { status: "completed", output });
+            await deps.store.updateRun(runId, { status: "completed", output, error: null });
             await flush();
             return "completed";
         }
         catch (e) {
             if (e instanceof WorkflowBlocked) {
                 await flush();
-                await deps.store.updateRun(runId, { status: "running" });
+                // Parking cleanly is progress: a transient error recorded by a worker retry is stale now.
+                await deps.store.updateRun(runId, { status: "running", error: null });
                 return "blocked";
             }
             if (e instanceof RunLeaseLostError)

package/dist/providers/echo.d.ts

@@ -1,8 +1,4 @@
 import type { ModelProvider, ModelRequest, ModelResponse } from "../model.js";
-/**
- * Deterministic offline provider for demos, scaffolds, and tests: replies
- * `echo(<first user text>)`. Lets `toren init` output run with zero API keys.
- */
 export declare class EchoProvider implements ModelProvider {
     calls: Map<string, number>;
     complete(req: ModelRequest): Promise<ModelResponse>;

package/dist/providers/echo.js

@@ -1,10 +1,15 @@
 /**
  * Deterministic offline provider for demos, scaffolds, and tests: replies
  * `echo(<first user text>)`. Lets `toren init` output run with zero API keys.
+ * `mock/slow` is the same echo at three seconds per call, so the quickstart's
+ * kill test has something to murder without an API key.
  */
+const SLOW_CALL_MS = 3_000;
 export class EchoProvider {
     calls = new Map();
     async complete(req) {
+        if (req.model.endsWith("/slow"))
+            await new Promise((r) => setTimeout(r, SLOW_CALL_MS));
         const first = req.messages[0]?.content.find((b) => b.type === "text");
         const input = first && first.type === "text" ? first.text : "";
         this.calls.set(input, (this.calls.get(input) ?? 0) + 1);

package/dist/worker.d.ts

@@ -1,4 +1,6 @@
 import { type TickDeps } from "./orchestrator.js";
+/** Exponential backoff for task retries: 0.2s doubling per attempt, capped at 60s. */
+export declare const retryDelaySeconds: (attempt: number) => number;
 export interface WorkerOpts {
     concurrency?: number;
     visibilitySeconds?: number;

package/dist/worker.js

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 import { InvalidationStormError, runTaskLoop, TaskLeaseLostError } from "./loop.js";
 import { findTaskSpec, tick } from "./orchestrator.js";
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Exponential backoff for task retries: 0.2s doubling per attempt, capped at 60s. */
+export const retryDelaySeconds = (attempt) => Math.min(60, 0.2 * 2 ** Math.max(0, attempt - 1));
 /**
  * Local worker runtime: in-process pollers over the orchestrator and task
  * queues (local binding). One instance serves one agent or a whole
@@ -165,7 +167,18 @@ export class LocalWorkerRuntime {
                     await this.shared.queue.nack(d, { delaySeconds: 20 });
                     return;
                 }
-                await this.shared.queue.nack(d, { delaySeconds: 0.2 });
+                // An outside dependency failed (a provider, a tool, the network). The
+                // retry is durability doing its job; the reason must not vanish into
+                // it. Record it on the run so jobs/console answer "why is it stuck"
+                // while the retries continue; a later success clears it.
+                try {
+                    const reason = e instanceof Error ? e.message : String(e);
+                    await deps.store.updateRun(msg.runId, {
+                        error: `${reason}${msg.taskId ? ` (task ${msg.taskId}, attempt ${d.attempt})` : ""}`,
+                    });
+                }
+                catch { /* the store may be the thing that failed */ }
+                await this.shared.queue.nack(d, { delaySeconds: retryDelaySeconds(d.attempt) });
             }
             catch {
                 // Queue unreachable too: do nothing. The visibility timeout redelivers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toren-run/core",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "exports": {
     ".": {