@toren-run/core 0.1.1 → 0.1.2

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/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.1",
+  "version": "0.1.2",
   "type": "module",
   "exports": {
     ".": {