@bastani/atomic 0.9.40-alpha.2 → 0.9.41-alpha.1

package/dist/builtin/workflows/src/index.js

@@ -823,6 +823,13 @@ function registerRunJournalConformance(runner, name, open, observeRead) {
 }
 // dist/builtin/workflows/src/durable/journal/internal.ts
 var JOURNAL_READ_PAGE_SIZE = 256;
+var versionReaders = new WeakMap;
+function registerRunJournalVersions(journal, versions) {
+  versionReaders.set(journal, versions);
+}
+function runJournalVersions(journal) {
+  return versionReaders.get(journal);
+}
 
 // dist/builtin/workflows/src/durable/journal/lease-expiry.ts
 function isWorkflowLeaseExpired(renewedAt, staleAfterMs, now = Date.now()) {
@@ -1107,6 +1114,10 @@ var LEGACY_COLUMNS = {
 var PENDING_LEGACY_RUNS = `SELECT ${JOURNAL_COLUMNS.runId}, ${JOURNAL_COLUMNS.headerJson}, ${JOURNAL_COLUMNS.status} FROM ${JOURNAL_TABLES.runs}
 	WHERE ${JOURNAL_COLUMNS.runId} NOT IN (SELECT ${JOURNAL_COLUMNS.runId} FROM ${CURRENT.runs})
 	AND ${JOURNAL_COLUMNS.runId} NOT IN (SELECT ${JOURNAL_COLUMNS.runId} FROM ${CURRENT.legacyDeleted})`;
+function latestEventColumns(events, runs) {
+  const latest = (column) => `COALESCE((SELECT ${column} FROM ${events} AS latest WHERE latest.${JOURNAL_COLUMNS.runId} = ${runs}.${JOURNAL_COLUMNS.runId} ORDER BY latest.${JOURNAL_COLUMNS.seq} DESC LIMIT 1), 0) AS ${column}`;
+  return `${latest(JOURNAL_COLUMNS.seq)}, ${latest(JOURNAL_COLUMNS.at)}`;
+}
 async function hasLegacyTable(tx, table) {
   const columns = await tx.all("SELECT name FROM pragma_table_info(?)", JOURNAL_TABLES[table]);
   const names = new Set(columns.map((column) => column.name));
@@ -1140,6 +1151,9 @@ class LegacyJournalRuns {
   async find(executor, runId) {
     return executor.get(`${PENDING_LEGACY_RUNS} AND ${JOURNAL_COLUMNS.runId} = ?`, runId);
   }
+  async versions(executor) {
+    return executor.all(`SELECT pending.${JOURNAL_COLUMNS.runId}, ${latestEventColumns(JOURNAL_TABLES.events, "pending")} FROM (${PENDING_LEGACY_RUNS}) AS pending`);
+  }
   async events(executor, runId, fromSeq, limit) {
     return executor.all(`SELECT ${LEGACY_COLUMNS.events.join(", ")} FROM ${JOURNAL_TABLES.events} WHERE ${JOURNAL_COLUMNS.runId} = ? AND ${JOURNAL_COLUMNS.seq} >= ? ORDER BY ${JOURNAL_COLUMNS.seq} LIMIT ?`, runId, fromSeq, limit);
   }
@@ -1190,6 +1204,10 @@ class SqlRunJournal {
     this.database = database;
     this.tables = tables;
     this.legacy = legacy;
+    registerRunJournalVersions(this, {
+      changeToken: () => this.changeToken(),
+      runVersions: () => this.runVersions()
+    });
   }
   static async open(database, options = {}) {
     const t = renderStorageIdentifiers2("journal", JOURNAL_TABLES, options.prefix);
@@ -1288,6 +1306,27 @@ class SqlRunJournal {
       return [...rows, ...legacy].map((row) => ({ ...JSON.parse(row[JOURNAL_COLUMNS.headerJson]), status: row[JOURNAL_COLUMNS.status] })).sort((left, right) => left.runId < right.runId ? -1 : left.runId > right.runId ? 1 : 0);
     });
   }
+  async changeToken() {
+    this.assertOpen();
+    return this.operation(async () => {
+      const row = await this.database.get(`SELECT data_version, total_changes() AS changes,
+					(SELECT count(*) FROM ${this.tables.runs}) AS runs,
+					(SELECT max(rowid) FROM ${this.tables.events}) AS last_event
+				FROM pragma_data_version`);
+      return JSON.stringify(Object.values(row ?? {}).map(String));
+    });
+  }
+  async runVersions() {
+    this.assertOpen();
+    return this.operation(async () => {
+      const rows = await this.database.all(`SELECT runs.${JOURNAL_COLUMNS.runId}, ${latestEventColumns(this.tables.events, "runs")} FROM ${this.tables.runs} AS runs`);
+      const legacy = await this.legacy?.versions(this.database) ?? [];
+      return new Map([...rows, ...legacy].map((row) => [
+        row[JOURNAL_COLUMNS.runId],
+        { seq: journalCounter(row[JOURNAL_COLUMNS.runId], "seq", row[JOURNAL_COLUMNS.seq]), at: Number(row[JOURNAL_COLUMNS.at]) }
+      ]));
+    });
+  }
   async requireRun(tx, runId) {
     if (await tx.get(`SELECT ${JOURNAL_COLUMNS.runId} FROM ${this.tables.runs} WHERE ${JOURNAL_COLUMNS.runId} = ?`, runId))
       return;
@@ -1669,6 +1708,7 @@ import { join as join3 } from "node:path";
 import {
   isStaleExtensionContextError,
   ModelRuntime,
+  noOpUIContext,
   resolveRestoredModelReference
 } from "@bastani/atomic";
 
@@ -4978,7 +5018,14 @@ function stripWorkflowOnlyOptions(options) {
   if (!options)
     return options;
   const maybeWorkflowOptions = options;
-  const { schema: _schema, mcp: _mcp, fallbackModels, group: _group, ...sessionOptions } = maybeWorkflowOptions;
+  const {
+    schema: _schema,
+    schemaTimeoutMs: _schemaTimeoutMs,
+    mcp: _mcp,
+    fallbackModels,
+    group: _group,
+    ...sessionOptions
+  } = maybeWorkflowOptions;
   return fallbackModels?.length === 0 ? { ...sessionOptions, fallbackModels: [] } : sessionOptions;
 }
 function emitLateIntercomRoute(pi, meta, messages, options, batch) {
@@ -5095,6 +5142,7 @@ function makeStageExtensionUiContext(ui, meta, broker, inheritedBindingRevision,
     notify: ui.notify ?? (() => {
       return;
     }),
+    requestRender: noOpUIContext.requestRender,
     onTerminalInput: ui.onTerminalInput ?? (() => () => {
       return;
     }),
@@ -5154,7 +5202,7 @@ function makeStageExtensionUiContext(ui, meta, broker, inheritedBindingRevision,
     getEditorComponent: ui.getEditorComponent ?? (() => {
       return;
     }),
-    theme: ui.theme,
+    theme: ui.theme ?? noOpUIContext.theme,
     getAllThemes: ui.getAllThemes ?? (() => []),
     getTheme: ui.getTheme ?? (() => {
       return;
@@ -5164,9 +5212,8 @@ function makeStageExtensionUiContext(ui, meta, broker, inheritedBindingRevision,
     setToolsExpanded: ui.setToolsExpanded ?? (() => {
       return;
     }),
-    getChatRenderSettings: ui.getChatRenderSettings ?? (() => {
-      return;
-    })
+    getFooterDataProvider: noOpUIContext.getFooterDataProvider,
+    getChatRenderSettings: ui.getChatRenderSettings ?? noOpUIContext.getChatRenderSettings
   };
 }
 function findStageModel(runtime, reference) {
@@ -6331,6 +6378,10 @@ function schemaIsRequired(schema) {
 
 // dist/builtin/workflows/src/runs/shared/validate-inputs.ts
 import { Value as Value2 } from "typebox/value";
+function firstSchemaError(def, value, kind) {
+  const first = [...Value2.Errors(def, value)][0];
+  return first === undefined ? `does not match ${kind} schema` : first.message;
+}
 function validateInputs(schema, inputs) {
   const errors = [];
   for (const key of Object.keys(inputs)) {
@@ -6359,12 +6410,16 @@ function validateInputs(schema, inputs) {
         if (typeof value !== "number" || !Number.isFinite(value)) {
           errors.push({ key, reason: `expected finite number, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
+        } else if (!Value2.Check(def, value)) {
+          errors.push({ key, reason: firstSchemaError(def, value, kind) });
         }
         break;
       case "integer":
         if (typeof value !== "number" || !Number.isInteger(value)) {
           errors.push({ key, reason: `expected integer, got ${workflowSerializableTypeName(value)}` });
           hasTypeError = true;
+        } else if (!Value2.Check(def, value)) {
+          errors.push({ key, reason: firstSchemaError(def, value, kind) });
         }
         break;
       case "boolean":
@@ -9492,6 +9547,8 @@ class JournalDurableBackend {
   persistent;
   projection = createJournalProjection();
   sequences = new Map;
+  foldedAt = new Map;
+  catalogToken;
   leases = new Map;
   executions = new Map;
   executionContext = new AsyncLocalStorage2;
@@ -9535,7 +9592,7 @@ class JournalDurableBackend {
     try {
       this.ensureOpen();
       if (requiresActiveExecution)
-        this.assertExecutionActive(runId);
+        this.assertExecutionActive();
     } catch (error) {
       return Promise.reject(error);
     }
@@ -9588,6 +9645,7 @@ class JournalDurableBackend {
         this.projection.applyWorkflowSnapshot({ ...handle, pendingStageMessages: messages });
     }
     this.sequences.set(entry.runId, entry.seq);
+    this.foldedAt.set(entry.runId, entry.at);
   }
   *entries(runId, fromSeq) {
     return yield* invoke(async () => {
@@ -9601,6 +9659,7 @@ class JournalDurableBackend {
     const entries = yield* this.entries(runId);
     this.projection.deleteWorkflow(runId);
     this.sequences.delete(runId);
+    this.foldedAt.delete(runId);
     this.prompts.delete(runId);
     for (const entry of entries)
       this.fold(entry);
@@ -9613,7 +9672,7 @@ class JournalDurableBackend {
   }
   *current(runId) {
     this.ensureOpen();
-    this.assertExecutionActive(runId, true);
+    this.assertExecutionActive(true);
     yield* this.refresh(runId);
     if (this.projection.getWorkflow(runId) === undefined)
       return;
@@ -9632,14 +9691,14 @@ class JournalDurableBackend {
     if (this.state === "closed" || this.state === "closing" && !this.mutationContext.getStore())
       throw new JournalBackendClosedError;
   }
-  assertExecutionActive(runId, admitted = false) {
+  assertExecutionActive(admitted = false) {
     for (const [executionRunId, execution] of this.executionContext.getStore() ?? [])
       if (execution.retired && !(admitted && this.mutationContext.getStore()?.has(execution)))
-        throw new JournalExecutionRetiredError(typeof runId === "string" ? runId : executionRunId);
+        throw new JournalExecutionRetiredError(executionRunId);
   }
   *ownership(runId) {
     this.ensureOpen();
-    this.assertExecutionActive(runId, true);
+    this.assertExecutionActive(true);
     const lost = this.lost.get(runId);
     if (lost)
       throw lost;
@@ -9699,7 +9758,7 @@ class JournalDurableBackend {
     return this.serialize(input.workflowId, () => this.register(input));
   }
   *register(input) {
-    this.assertExecutionActive(input.workflowId, true);
+    this.assertExecutionActive(true);
     this.ensureOpen();
     const header = {
       runId: input.workflowId,
@@ -9923,11 +9982,36 @@ class JournalDurableBackend {
   }
   hydrateResumableWorkflows() {
     return this.serialize(this.catalogQueue, () => invoke(async () => {
-      const runs = await this.journal.listRuns();
-      for (const runId of new Set([...this.sequences.keys(), ...runs.map((run) => run.runId)]))
-        await this.hydrateWorkflow(runId);
+      const journal = runJournalVersions(this.journal);
+      if (journal === undefined) {
+        const runs = await this.journal.listRuns();
+        for (const runId of new Set([...this.sequences.keys(), ...runs.map((run) => run.runId)]))
+          await this.hydrateWorkflow(runId);
+        return;
+      }
+      const token = await journal.changeToken();
+      if (token === this.catalogToken)
+        return;
+      const versions = await journal.runVersions();
+      for (const runId of new Set([...this.sequences.keys(), ...versions.keys()]))
+        await this.serialize(runId, () => this.catchUp(runId, versions.get(runId)), false);
+      this.catalogToken = token;
     }));
   }
+  *catchUp(runId, version) {
+    const folded = this.sequences.get(runId) ?? 0;
+    if (version !== undefined && version.seq === folded && version.at === (this.foldedAt.get(runId) ?? 0))
+      return;
+    if (version !== undefined && folded > 0 && version.seq > folded) {
+      const entries = yield* this.entries(runId, folded);
+      if (entries[0]?.seq === folded && entries[0].at === this.foldedAt.get(runId)) {
+        for (const entry of entries)
+          this.fold(entry);
+        return;
+      }
+    }
+    yield* this.rebuild(runId);
+  }
   async prepareWorkflowCatalog() {
     await this.hydrateResumableWorkflows();
     return this.projection.prepareWorkflowCatalog();
@@ -9945,6 +10029,7 @@ class JournalDurableBackend {
     }
     this.leases.delete(runId);
     this.sequences.delete(runId);
+    this.foldedAt.delete(runId);
     this.prompts.delete(runId);
     this.projection.deleteWorkflow(runId);
   }
@@ -10037,7 +10122,7 @@ class JournalDurableBackend {
   }
   async withWorkflowLease(runId, action) {
     this.ensureOpen();
-    this.assertExecutionActive(runId);
+    this.assertExecutionActive();
     const context = this.executionContext.getStore();
     const active = this.executions.get(runId);
     if (active !== undefined && context?.get(runId) !== active)
@@ -10072,7 +10157,7 @@ class JournalDurableBackend {
     return this.serialize(runId, () => this.release(runId, execution), false);
   }
   releaseWorkflow(runId) {
-    this.assertExecutionActive(runId);
+    this.assertExecutionActive();
     return this.serialize(runId, () => this.release(runId));
   }
   *release(runId, execution) {
@@ -12574,7 +12659,12 @@ async function mapParallelSteps(steps, concurrency, failFast, mapper, onFirstFai
       if (selectedFailure !== undefined)
         throw selectedFailure;
     }
-    throw new AggregateError(failures.map((failure) => failure.error), `atomic-workflows: ${failures.length} parallel ${failures.length === 1 ? "step" : "steps"} failed`);
+    const aggregate = new AggregateError(failures.map((failure) => failure.error), `atomic-workflows: ${failures.length} parallel ${failures.length === 1 ? "step" : "steps"} failed`);
+    if (failFastEnabled)
+      throw aggregate;
+    const failedIndexes = new Set(failures.map((failure) => failure.index));
+    const partialResults = Array.from({ length: steps.length }, (_, index) => failedIndexes.has(index) ? undefined : results[index]);
+    throw Object.assign(aggregate, { partialResults });
   }
   return results;
 }
@@ -14374,13 +14464,24 @@ class ConcurrencyLimiter {
   get queued() {
     return this._queue.length;
   }
-  acquire() {
+  acquire(signal) {
+    if (signal?.aborted)
+      return Promise.reject(signal.reason);
     if (this._running < this.limit) {
       this._running++;
       return Promise.resolve();
     }
-    return new Promise((resolve) => {
-      this._queue.push(resolve);
+    return new Promise((resolve, reject) => {
+      const grant = () => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      };
+      const onAbort = () => {
+        this._queue.splice(this._queue.indexOf(grant), 1);
+        reject(signal?.reason);
+      };
+      this._queue.push(grant);
+      signal?.addEventListener("abort", onAbort, { once: true });
     });
   }
   release() {
@@ -14391,8 +14492,8 @@ class ConcurrencyLimiter {
       this._running--;
     }
   }
-  async run(fn) {
-    await this.acquire();
+  async run(fn, signal) {
+    await this.acquire(signal);
     try {
       return await fn();
     } finally {
@@ -15355,6 +15456,22 @@ function createChildWorkflowRunner(input) {
     }
   };
 }
+// dist/builtin/workflows/src/shared/error-with-causes.ts
+var MAX_CAUSE_DEPTH = 5;
+function describeErrorWithCauses(error) {
+  const messages = [];
+  const visited = new Set;
+  let current = error;
+  for (let depth = 0;current !== undefined && depth < MAX_CAUSE_DEPTH && !visited.has(current); depth++) {
+    visited.add(current);
+    const message = current instanceof Error ? current.message : String(current);
+    if (!messages.includes(message))
+      messages.push(message);
+    current = current instanceof Error ? current.cause : undefined;
+  }
+  return messages.join(": ");
+}
+
 // dist/builtin/workflows/src/shared/returned-run-status.ts
 var RETURNED_BLOCKED_STATUSES = new Set([
   "blocked",
@@ -15452,12 +15569,22 @@ function stringResultField(result, key) {
 
 // dist/builtin/workflows/src/engine/run-durable-finalize.ts
 async function finalizeDurableTerminalStatus(input) {
+  try {
+    await commitDurableTerminalStatus(input);
+  } catch (error) {
+    if (input.store !== undefined)
+      recordDurableEndingFailure(input.store, input.runSnapshot, error);
+    throw error;
+  }
+}
+async function commitDurableTerminalStatus(input) {
   if (!input.isRoot)
     return;
   const status = effectiveRunStatus(input.runSnapshot);
   const isExitTerminal = input.runSnapshot.exited === true && status !== "running";
   const isBlocked = status === "blocked" && (input.runSnapshot.endedAt !== undefined || input.runSnapshot.blockedAt !== undefined);
-  if (status !== "failed" && status !== "killed" && !isExitTerminal && !isBlocked)
+  const isUncommittedCompletion = status === "completed" && input.terminalStatusCommitted === false;
+  if (status !== "failed" && status !== "killed" && !isExitTerminal && !isBlocked && !isUncommittedCompletion)
     return;
   const durableStatus = toDurableStatus(status);
   if (durableStatus !== undefined) {
@@ -15467,7 +15594,7 @@ async function finalizeDurableTerminalStatus(input) {
       if (input.runSnapshot.result !== undefined)
         throw error;
     }
-    if (durableStatus === "failed" || durableStatus === "blocked") {
+    if (durableStatus === "failed" || durableStatus === "blocked" || isUncommittedCompletion) {
       await recordRunTimingCheckpointAsync(input.durableBackend, input.runSnapshot);
     }
     const failure = durableStatus === "failed" ? {
@@ -15485,6 +15612,16 @@ async function finalizeDurableTerminalStatus(input) {
     await input.durableBackend.commitWorkflowStatus(input.runId, durableStatus, undefined, input.runSnapshot.resumable, failure);
   }
 }
+function recordDurableEndingFailure(store, runSnapshot, error) {
+  const detail = describeErrorWithCauses(error);
+  store.recordNotice({
+    id: `workflow-durable-ending-failed:${runSnapshot.id}`,
+    runId: runSnapshot.id,
+    level: "error",
+    message: `Workflow "${runSnapshot.name}" ended ${runSnapshot.status}, but its final state could not be saved to the workflow journal: ${detail}. Readers of the journal may report it as crashed.`,
+    createdAt: Date.now()
+  });
+}
 function toDurableStatus(status) {
   switch (status) {
     case "completed":
@@ -18760,7 +18897,9 @@ import { createStructuredOutputCapture, runCallback as runCallback2 } from "@bas
 import {
   AutoRoutingInferenceError,
   convertToLlm,
+  isExtensionStartupFailure,
   isModelRoutingDebugEnabled,
+  isTransientExtensionStartupFailure,
   parseModelConstraints,
   setsProviders
 } from "@bastani/atomic";
@@ -19031,6 +19170,23 @@ class StageDeliveryActivity {
   }
 }
 
+// dist/builtin/workflows/src/runs/foreground/stage-routing.ts
+var STAGE_ROUTING_CONCURRENCY = 8;
+var STAGE_ROUTING_DEADLINE_MS = 300000;
+var routingLimiter = new ConcurrencyLimiter(STAGE_ROUTING_CONCURRENCY);
+async function routeStageModel(route, input) {
+  const deadline = new AbortController;
+  const timer = setTimeout(() => deadline.abort(new Error("stage routing deadline")), STAGE_ROUTING_DEADLINE_MS);
+  try {
+    return await route({
+      ...input,
+      inference: { deadline: deadline.signal, limit: (run, signal) => routingLimiter.run(run, signal) }
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // dist/builtin/workflows/src/runs/foreground/stage-runner-artifact-capture.ts
 class StageArtifactCapture {
   session;
@@ -19521,6 +19677,7 @@ async function stripWorkflowOnlyOptions2(options, defaultSessionDir, meta, pendi
   }
   const {
     schema: _schema,
+    schemaTimeoutMs: _schemaTimeoutMs,
     mcp: _mcp,
     fallbackModels,
     modelConstraints: _modelConstraints,
@@ -19768,6 +19925,15 @@ class StageSessionReplacement {
     this.previous = undefined;
     await Promise.allSettled([...previous ? [disposeStageSession(previous)] : [], ...this.cleanups]);
   }
+  async disposeRetired() {
+    const previous = this.previous;
+    this.previous = undefined;
+    if (!previous)
+      return;
+    await disposeStageSession(previous).catch((error) => {
+      console.error("atomic-workflows: retired stage session disposal failed", error);
+    });
+  }
   async disposeAfterIdle(session) {
     const agent = session.agent;
     if (typeof agent?.waitForIdle === "function")
@@ -19894,7 +20060,7 @@ class WorkflowStructuredOutputContractError extends Error {
   }
 }
 function isStructuredOutputContractFailure(message) {
-  return message.startsWith(STRUCTURED_OUTPUT_MISSING_ERROR) || message.startsWith('Validation failed for tool "structured_output":') || message.startsWith("Invalid structured output: response does not match the decision schema.") || message.startsWith("Invalid structured output: non-JSON decision.") || message.startsWith("Structured output requires one structured_output call.") || message.startsWith("Structured output requires exactly one structured_output call and no provider fallback.") || message === "Structured output requires complete judgment instructions." || message === "Structured output requires a nonempty named state object containing the task and relevant context text." || message === "Structured output inputs must be finite, acyclic JSON data." || message === "Structured output inputs must be plain JSON objects." || message === "structured_output tool call failed schema validation.";
+  return message.startsWith(STRUCTURED_OUTPUT_MISSING_ERROR) || message.startsWith('Validation failed for tool "structured_output":') || message.startsWith("Invalid structured output: response does not match the decision schema.") || message.startsWith("Invalid structured output: non-JSON decision.") || message.startsWith("Invalid structured output: tool call arguments were not valid JSON.") || message.startsWith("Structured output requires one structured_output call.") || message.startsWith("Structured output requires exactly one structured_output call and no provider fallback.") || message === "Structured output requires complete judgment instructions." || message === "Structured output requires a nonempty named state object containing the task and relevant context text." || message === "Structured output inputs must be finite, acyclic JSON data." || message === "Structured output inputs must be plain JSON objects." || message === "structured_output tool call failed schema validation.";
 }
 var STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
 function toolResultText(content) {
@@ -19946,7 +20112,8 @@ function stageOptionsWithStructuredOutput(options, capture, executionCapture) {
     return options;
   const structuredOutputTool = createStructuredOutputTool({
     schema: options.schema,
-    capture
+    capture,
+    ...options.schemaTimeoutMs === undefined ? {} : { timeoutMs: options.schemaTimeoutMs }
   });
   const executeStructuredOutput = structuredOutputTool.execute;
   const capturedStructuredOutputTool = {
@@ -20036,6 +20203,16 @@ function waitForStageStartup(operation, signal) {
 // dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts
 var WORKFLOW_STAGE_CLOSED_FOR_GOOD_STATE = "atomic:workflow-stage-closed-for-good";
 var WORKFLOW_STAGE_END_CHILDREN_STATE = "atomic:workflow-stage-end-children";
+function isRetryableSameCandidateFailure(error) {
+  if (isExtensionStartupFailure(error))
+    return isTransientExtensionStartupFailure(error);
+  return isRetryableSameModelFailure(error);
+}
+function mayAdvanceToNextCandidate(error) {
+  if (isExtensionStartupFailure(error))
+    return isTransientExtensionStartupFailure(error);
+  return isRetryableModelFailure(error);
+}
 function hasMeaningfulUsage(usage) {
   if (usage === undefined)
     return false;
@@ -20287,7 +20464,7 @@ class StageSessionController {
       return;
     if (!this.routingPromise) {
       this.beginStartup();
-      this.routingPromise = (async () => {
+      const routing = (async () => {
         const route = this.modelCatalog?.routeModel;
         if (!route)
           throw new Error("Workflow stage auto routing requires a routing-capable model catalog.");
@@ -20299,7 +20476,7 @@ class StageSessionController {
           ...thinking === undefined ? [] : [{ allowedEfforts: [thinking] }]
         ].filter((c) => c !== undefined);
         try {
-          this.modelRoute = await route({
+          this.modelRoute = await routeStageModel(route, {
             task: text,
             stageName: this.opts.stageName,
             constraints,
@@ -20320,7 +20497,17 @@ class StageSessionController {
         this.modelRoute.assertCurrent();
         this.meta.stageOptions = { ...options, model: this.modelRoute.modelOverride };
         this.opts.onModelFallbackMetaChange?.(this.currentModelFallbackMeta());
-      })();
+      })().catch((error) => {
+        if (this.routingPromise === routing) {
+          this.routingPromise = undefined;
+          this.modelRoute = undefined;
+        }
+        if (this.startupWait.signal.aborted || this.opts.signal?.aborted)
+          throw error;
+        this.settleStartup(true);
+        throw new Error(`atomic-workflows: stage "${this.opts.stageName}" failed during startup phase model-resolution: ${errorMessage2(error)}`);
+      });
+      this.routingPromise = routing;
     }
     await this.routingPromise;
   }
@@ -21075,7 +21262,7 @@ class StageSessionController {
         const errorSettingsManager = retrySettingsManagerFromError(error);
         if (errorSettingsManager !== undefined)
           this.sessionSettingsManager = errorSettingsManager;
-        const decision = isWorkflowPendingStageDeliveryFailure(error) ? undefined : nextRetryDecision(this.retrySettings(), retryAttempt, isRetryableSameModelFailure(error));
+        const decision = isWorkflowPendingStageDeliveryFailure(error) ? undefined : nextRetryDecision(this.retrySettings(), retryAttempt, isRetryableSameCandidateFailure(error));
         if (decision === undefined || this.disposed || this.opts.signal?.aborted === true || this.startupWait.signal.aborted || this.capturedStructuredOutputForAttempt()) {
           throw error;
         }
@@ -21487,10 +21674,11 @@ class StageSessionController {
       ...usage === undefined ? {} : { usage },
       error: message
     });
-    if (this.opts.signal?.aborted || this.startupWait.signal.aborted || terminalStageDelivery || !isRetryableModelFailure(err) || index === candidates.length - 1) {
+    if (this.opts.signal?.aborted || this.startupWait.signal.aborted || terminalStageDelivery || !mayAdvanceToNextCandidate(err) || index === candidates.length - 1) {
       this.modelWarnings.push(...this.pendingFallbackWarnings);
       this.pendingFallbackWarnings.length = 0;
       this.notifyModelFallbackMetaChange();
+      await this.replacement.disposeRetired();
       return "throw";
     }
     const nextCandidate = candidates[index + 1];
@@ -22612,13 +22800,13 @@ class EngineRuntime {
 
 // dist/builtin/workflows/src/engine/session-closed-error.ts
 import { isStaleExtensionContextError as isStaleExtensionContextError2 } from "@bastani/atomic";
-var MAX_CAUSE_DEPTH = 8;
+var MAX_CAUSE_DEPTH2 = 8;
 function reportsClosedSession(error) {
   return "code" in error && error.code === "SessionClosed" || isStaleExtensionContextError2(error);
 }
 function isSessionClosedError(error) {
   let current = error;
-  for (let depth = 0;depth < MAX_CAUSE_DEPTH && current !== undefined; depth++) {
+  for (let depth = 0;depth < MAX_CAUSE_DEPTH2 && current !== undefined; depth++) {
     try {
       if (reportsClosedSession(current))
         return true;
@@ -23255,6 +23443,7 @@ async function executeRun(def, resolvedInputs, opts) {
   };
   const runtimeSettled = Promise.withResolvers();
   let durableRootAdmitted = false;
+  let terminalStatusCommitted = false;
   let pausePersistence;
   let resumePersistence;
   let controlSettlements = Promise.resolve();
@@ -23444,6 +23633,7 @@ async function executeRun(def, resolvedInputs, opts) {
       await recordRunResultCheckpointAsync(durableBackend, runSnapshot);
     }
     await durableBackend.commitWorkflowStatus(runId, returned.status, undefined, returned.metadata?.resumable);
+    terminalStatusCommitted = true;
     await appendRunEndWhenRecorded(opts.persistence, recorded, {
       runId,
       status: returned.status,
@@ -23565,7 +23755,9 @@ async function executeRun(def, resolvedInputs, opts) {
           runId,
           runSnapshot,
           isRoot: opts.parentRun === undefined,
-          durableBackend
+          durableBackend,
+          terminalStatusCommitted,
+          store: activeStore
         });
       }
     } finally {

package/dist/builtin/workflows/src/shared/authoring-contract-stage.d.ts

@@ -1,5 +1,5 @@
 /** Workflow authoring primitives, stage/session contracts, and task option types. */
-import type { AgentSession, AgentSessionEvent, ModelConstraints, ModelRoute, ModelRouterOutput, TaskNeeds } from "@bastani/atomic";
+import type { AgentSession, AgentSessionEvent, ModelConstraints, ModelRoute, ModelRouterOutput, RoutingInferenceBounds, TaskNeeds } from "@bastani/atomic";
 import type { Static, TSchema } from "typebox";
 export type { Static, TSchema };
 export type WorkflowSerializablePrimitive = string | number | boolean | null;
@@ -91,6 +91,8 @@ export interface WorkflowModelCatalogPort {
         taskNeeds?: TaskNeeds;
         /** The stage's own constraints set a provider list, replacing the user's provider settings. */
         overrideProviderSettings?: boolean;
+        /** Deadline and concurrency limit the stage owns for routing inference. */
+        inference?: RoutingInferenceBounds;
     }): Promise<ModelRoute>;
     readonly currentModel?: WorkflowModelValue;
     readonly preferredProvider?: string;
@@ -126,6 +128,13 @@ export interface WorkflowScopedModel {
 export interface StageOptions<TSchemaDef extends TSchema | undefined = TSchema | undefined> extends WorkflowModelFallbackFields {
     /** Optional structured final-answer schema. When set, the stage receives a schema-specific final-answer tool. */
     readonly schema?: TSchemaDef;
+    /**
+     * Wall-clock limit in milliseconds for each `structured_output` decision of a schema-backed stage, covering
+     * every repair attempt, transport retry and model fallback together. Defaults to the session's
+     * `httpIdleTimeoutMs` setting (10 minutes unless changed). A decision that overruns fails with an error naming
+     * the deadline. Ignored without `schema`.
+     */
+    readonly schemaTimeoutMs?: number;
     readonly model?: WorkflowModelValue;
     /** Hard restrictions for automatic model selection and its execution fallbacks. */
     readonly modelConstraints?: ModelConstraints;
@@ -376,6 +385,13 @@ export interface WorkflowParallelOptions extends WorkflowSharedTaskDefaults {
     /** Static discovery only: literal conservative stage names/globs for an otherwise opaque step array. */
     readonly possibleStageNames?: readonly string[];
 }
+/**
+ * Error thrown by `ctx.parallel(..., { failFast: false })` after every step has settled and at least one
+ * failed. `partialResults` has one entry per step in step order; a step that failed or never ran is `undefined`.
+ */
+export interface WorkflowParallelFailure<TResult = WorkflowTaskResult> extends AggregateError {
+    readonly partialResults: readonly (TResult | undefined)[];
+}
 export type WorkflowTaskSessionOptions = StageOptions & WorkflowTaskSessionFields;
 export interface WorkflowRunChildOptions<TInputs extends WorkflowInputValues = WorkflowInputValues> {
     readonly inputs?: TInputs;

package/dist/cli/credential-print.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"credential-print.d.ts","sourceRoot":"","sources":["../../src/cli/credential-print.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,cAAc,CAAC;AAE7D,8EAA8E;AAC9E,eAAO,MAAM,kCAAkC,QAAc,CAAC;AAE9D;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GACjC,OAAO,GACP,wBAAwB,GACxB,mBAAmB,GACnB,4BAA4B,GAC5B,eAAe,GACf,wBAAwB,GACxB,kBAAkB,GAClB,sBAAsB,GACtB,qBAAqB,CAAC;AAEzB;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,wBAAwB,EAAE,MAAM,CAU/D,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,wBAAwB,CAEtE,CAAC;AAEF,qBAAa,oBAAqB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,YAAY,IAAI,EAAE,wBAAwB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAKzF;CACD;AAED;;;;;;;;;;GAUG;AACH,qBAAa,MAAM;;IAGlB,YAAY,KAAK,EAAE,MAAM,EAExB;IAED,qEAAqE;IACrE,IAAI,IAAI,MAAM,CAOb;IAED,QAAQ,IAAI,KAAK,CAEhB;IAED,MAAM,IAAI,KAAK,CAEd;IAED,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,KAAK,CAE5B;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAEzB;CACD;AAED,iGAAiG;AACjG,MAAM,WAAW,oBAAoB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAmChH;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,CAO3E;AA6BD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAiB5D;AAED,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,6BAA6B,CAAC;AAEtE;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,qBAAqB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,GAAG,oBAAoB,CAe7E;AAiDD;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC9C,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,mBAAmB,EACzB,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,CA6GjB"}
+{"version":3,"file":"credential-print.d.ts","sourceRoot":"","sources":["../../src/cli/credential-print.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,cAAc,CAAC;AAE7D,8EAA8E;AAC9E,eAAO,MAAM,kCAAkC,QAAc,CAAC;AAE9D;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GACjC,OAAO,GACP,wBAAwB,GACxB,mBAAmB,GACnB,4BAA4B,GAC5B,eAAe,GACf,wBAAwB,GACxB,kBAAkB,GAClB,sBAAsB,GACtB,qBAAqB,CAAC;AAEzB;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,wBAAwB,EAAE,MAAM,CAU/D,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,wBAAwB,CAEtE,CAAC;AAEF,qBAAa,oBAAqB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,YAAY,IAAI,EAAE,wBAAwB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAKzF;CACD;AAED;;;;;;;;;;GAUG;AACH,qBAAa,MAAM;;IAGlB,YAAY,KAAK,EAAE,MAAM,EAExB;IAED,qEAAqE;IACrE,IAAI,IAAI,MAAM,CAOb;IAED,QAAQ,IAAI,KAAK,CAEhB;IAED,MAAM,IAAI,KAAK,CAEd;IAED,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,KAAK,CAE5B;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAEzB;CACD;AAED,iGAAiG;AACjG,MAAM,WAAW,oBAAoB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAmChH;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,CAO3E;AA6BD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAiB5D;AAED,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,6BAA6B,CAAC;AAEtE;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,qBAAqB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,GAAG,oBAAoB,CAmB7E;AAiDD;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC9C,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,mBAAmB,EACzB,WAAW,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,CA6GjB"}

package/dist/cli/credential-print.js

@@ -275,7 +275,7 @@ export function classifyOAuthFailure(error) {
         return new CredentialPrintError("MinValidityUnreachable", `The provider refreshed the token but it still expires sooner than requested: ${detail}`, { cause: error });
     }
     if (error.message.startsWith(OAUTH_REFRESH_FAILED_PHRASE)) {
-        return new CredentialPrintError("RefreshFailed", `${detail} (the stored credential was left untouched)`, {
+        return new CredentialPrintError("RefreshFailed", `${detail} (the stored credential changes only if the provider completes this refresh later)`, {
             cause: error,
         });
     }