@loopingai/core 0.5.0 → 0.6.0

package/dist/round/agent.d.ts

@@ -7,14 +7,13 @@ import type { SubagentClass } from "./subagent.js";
 import type { RoundPolicy } from "./policy.js";
 import { type RoundMode } from "./turn.js";
 /**
- * A **delegating** agent: the round loop, the durable Subtask DAG, and the
- * isolated subagent execution beneath it.
+ * A **delegating** agent: the round loop, the durable Subtasks it hands out, and
+ * the isolated subagent execution beneath them.
  *
  * Everything {@link LoopingAgent} gives every agent, plus the half that only a
  * delegating one needs — and it is all mechanism. A Workflow drives it through
- * native Cloudflare RPC (`runTaskTurn`, `skipBlockedSubtasks`,
- * `executeSubtaskChunk`, …), never HTTP: the DO is a private implementation
- * detail of the Worker.
+ * native Cloudflare RPC (`runTaskTurn`, `scanSubtasks`, `executeSubtaskChunk`,
+ * …), never HTTP: the DO is a private implementation detail of the Worker.
  *
  * ## Why core owns this
  *
@@ -73,8 +72,8 @@ export declare abstract class RoundAgentBase<TEnv extends Cloudflare.Env & AiEnv
     /** Age out this agent's subtask rows alongside the task rows. */
     protected cleanupAgentState(): void;
     /**
-     * One main-agent round: answer the user, or delegate a durable Subtask DAG and
-     * return the acknowledgment the user sees while it runs.
+     * One main-agent round: answer the user, or delegate a durable set of Subtasks
+     * and return the acknowledgment the user sees while it runs.
      *
      * This is the RPC boundary, so it is where the round's cost becomes a field. The
      * budget is created here, handed to {@link decideRound} to be spent, and read
@@ -120,29 +119,33 @@ export declare abstract class RoundAgentBase<TEnv extends Cloudflare.Env & AiEnv
      * Every round's branches for a Task, in stable ordinal order — what a round
      * needs to reunite each earlier `delegate` call with its result. Built inside
      * the DO and consumed here, so the 1 MiB Workflow-step cap that keeps
-     * {@link SubtaskNode} narrow does not apply.
+     * {@link SubtaskScan} down to ids does not apply.
      */
     private compositionBranches;
     /** A Task's Subtasks, every round, in stable ordinal order. */
     listSubtasks(taskId: string): Promise<Subtask[]>;
     /**
-     * The Workflow's per-wave scan for **one round's** DAG: report a cancellation,
-     * or skip every pending Subtask blocked by a dependency that did not succeed and
-     * return the refreshed DAG as scheduler {@link SubtaskNode}s.
+     * The Workflow's scan for **one round's** Subtasks: report a cancellation, or
+     * return the ids that still owe an outcome, in ordinal order.
      *
-     * Scoped to the round because dependency edges never cross one: an earlier
-     * round's rows are already terminal and irrelevant to this wave, and including
-     * them would only widen a projection that has a size cap.
+     * Scoped to the round because the Workflow drives one round at a time: an
+     * earlier round's rows are already terminal and would only widen a projection
+     * that has a size cap.
      *
-     * Skipping runs to a fixpoint because it propagates: a node skipped for a
-     * failed prerequisite blocks *its* dependents in turn. Bounded by the
-     * per-round maximum. Independent branches are untouched — one branch's failure
-     * never stops work that does not depend on it.
+     * `running` counts alongside `pending` on purpose. `executeSubtaskChunk`
+     * accepts a row that is either: the latter is its ambiguous-retry path, where a
+     * previous attempt crashed mid-execution and the managed child's fingerprint
+     * cache may still hold the terminal result that makes the retry free. So a row
+     * stranded `running` is re-runnable, and omitting it here would abandon it.
+     *
+     * Ordinal order comes from {@link listRound} and is not incidental: these ids
+     * become durable Workflow step names, so the traversal that produces them has
+     * to be deterministic.
      *
      * The cancellation verdict rides along rather than being probed separately, so
-     * a wave costs one round trip and cannot act on a stale answer.
+     * the scan costs one round trip and cannot act on a stale answer.
      */
-    skipBlockedSubtasks(taskId: string, round: number): Promise<SubtaskScan>;
+    scanSubtasks(taskId: string, round: number): Promise<SubtaskScan>;
     /** Parent cancellation: cancel every still-pending Subtask. Returns the count. */
     cancelPendingSubtasks(taskId: string): Promise<number>;
     /**
@@ -182,8 +185,9 @@ export declare abstract class RoundAgentBase<TEnv extends Cloudflare.Env & AiEnv
      *   delete; that now happens strictly later.
      *
      * Throws on a transient fault (the step retries and the child resumes from its
-     * checkpoint) and on scheduler-invariant violations — both are bugs, not
-     * outcomes.
+     * checkpoint) and when the row is in a status this cannot accept — a subtask
+     * that is neither `pending` nor `running` nor already terminal. Both are bugs,
+     * not outcomes.
      */
     executeSubtaskChunk(id: SubtaskId, chunk: number, push?: TurnPushContext): Promise<SubtaskChunkOutcome>;
     /**
@@ -230,14 +234,6 @@ export declare abstract class RoundAgentBase<TEnv extends Cloudflare.Env & AiEnv
     private abortChildQuietly;
     /** Persist a child's terminal outcome. Returns whether the guarded write applied. */
     private persistResult;
-    /**
-     * Load a Subtask's dependency results, in ordinal order.
-     *
-     * Order is semantic: it feeds the child's request fingerprint, so a retry must
-     * build the identical array or the cache misses. A dependency that has not
-     * completed means the scheduler ran this node too early.
-     */
-    private loadDependencyResults;
     /** Re-read a Subtask that must exist (it was just written). */
     private requireSubtask;
     /** Delete a managed child, swallowing failures (used on best-effort sweeps). */
@@ -248,7 +244,7 @@ export declare abstract class RoundAgentBase<TEnv extends Cloudflare.Env & AiEnv
      * Interrupt a canceled Task's live children: each `running` Subtask's managed
      * child gets `abortRun`, so a long recipe stops at its current model call
      * instead of at the next chunk boundary (up to `chunkSoftMs` later). A subtask
-     * that already finished (e.g. one branch of a wave completed while another was
+     * that already finished (e.g. one branch completed while another was
      * still running) is deliberately retained until the terminal-delivery sweep —
      * but a canceled Task never reaches delivery, so its idle child is deleted
      * here instead, or it would leak until the 30-day row cleanup regardless of
@@ -261,7 +257,15 @@ export declare abstract class RoundAgentBase<TEnv extends Cloudflare.Env & AiEnv
      * status. Bounded by `maxSubtasks`. Best-effort throughout: a child that
      * cannot be reached is logged, never fatal — cancellation must not fail
      * because cleanup did.
+     *
+     * The `pending` rows are transitioned here too, and that is not bookkeeping:
+     * it is the only thing that resolves them. Nothing else is coming back to a
+     * pending row once a Task is canceled — the Workflow's scheduler runs a
+     * single pass and does not re-scan, and `prepareChunk` reports a canceled
+     * Task's pending row as terminal *without* claiming it, so a branch whose RPC
+     * had not yet reached the claim when the cancellation landed simply returns.
+     * Left to the loop below, which only deletes the child, the row would sit
+     * non-terminal until the 30-day cleanup.
      */
     protected onTaskCanceled(taskId: string): Promise<void>;
 }
-//# sourceMappingURL=agent.d.ts.map

package/dist/round/agent.js

@@ -7,14 +7,13 @@ import { FINGERPRINT_MISMATCH, subagentName } from "../subagent/index.js";
 import { LoopingAgent } from "../host/agent.js";
 import { buildTurnInstructions, runTurn } from "./turn.js";
 /**
- * A **delegating** agent: the round loop, the durable Subtask DAG, and the
- * isolated subagent execution beneath it.
+ * A **delegating** agent: the round loop, the durable Subtasks it hands out, and
+ * the isolated subagent execution beneath them.
  *
  * Everything {@link LoopingAgent} gives every agent, plus the half that only a
  * delegating one needs — and it is all mechanism. A Workflow drives it through
- * native Cloudflare RPC (`runTaskTurn`, `skipBlockedSubtasks`,
- * `executeSubtaskChunk`, …), never HTTP: the DO is a private implementation
- * detail of the Worker.
+ * native Cloudflare RPC (`runTaskTurn`, `scanSubtasks`, `executeSubtaskChunk`,
+ * …), never HTTP: the DO is a private implementation detail of the Worker.
  *
  * ## Why core owns this
  *
@@ -75,8 +74,8 @@ export class RoundAgentBase extends LoopingAgent {
     // idempotent on its durable output, and execution recovers from either the
     // parent row or the child's cached result.
     /**
-     * One main-agent round: answer the user, or delegate a durable Subtask DAG and
-     * return the acknowledgment the user sees while it runs.
+     * One main-agent round: answer the user, or delegate a durable set of Subtasks
+     * and return the acknowledgment the user sees while it runs.
      *
      * This is the RPC boundary, so it is where the round's cost becomes a field. The
      * budget is created here, handed to {@link decideRound} to be spent, and read
@@ -154,12 +153,15 @@ export class RoundAgentBase extends LoopingAgent {
             types: this.runtime.types,
             maxSubtasks: this.config.maxSubtasks,
             maxOutputTokens: this.config.model.maxOutputTokens,
+            maxRetries: this.config.model.maxRetries,
             instructions: this.instructions,
             partialNote: policy.copy.partialNote,
             // The key carries the round so two rounds of one Task cannot collide on
             // the gateway, which a bare step index would.
             onContent: channel?.stream((step) => `r${round}:step:${step}`)
         });
+        // Terminal for this round with nothing to persist — the kind rides out with
+        // it, and the Workflow turns it into words.
         if (outcome.status === "failed")
             return outcome;
         // Cancelled while the model worked: persist nothing and publish nothing. The
@@ -182,7 +184,7 @@ export class RoundAgentBase extends LoopingAgent {
      * Every round's branches for a Task, in stable ordinal order — what a round
      * needs to reunite each earlier `delegate` call with its result. Built inside
      * the DO and consumed here, so the 1 MiB Workflow-step cap that keeps
-     * {@link SubtaskNode} narrow does not apply.
+     * {@link SubtaskScan} down to ids does not apply.
      */
     compositionBranches(taskId) {
         return this.db.subtasks.list(taskId).map((s) => ({
@@ -191,7 +193,6 @@ export class RoundAgentBase extends LoopingAgent {
             ordinal: s.ordinal,
             type: s.type,
             prompt: s.prompt,
-            dependsOn: s.dependsOn,
             params: s.params,
             status: s.status,
             resultParts: s.resultParts,
@@ -203,40 +204,34 @@ export class RoundAgentBase extends LoopingAgent {
         return this.db.subtasks.list(taskId);
     }
     /**
-     * The Workflow's per-wave scan for **one round's** DAG: report a cancellation,
-     * or skip every pending Subtask blocked by a dependency that did not succeed and
-     * return the refreshed DAG as scheduler {@link SubtaskNode}s.
+     * The Workflow's scan for **one round's** Subtasks: report a cancellation, or
+     * return the ids that still owe an outcome, in ordinal order.
      *
-     * Scoped to the round because dependency edges never cross one: an earlier
-     * round's rows are already terminal and irrelevant to this wave, and including
-     * them would only widen a projection that has a size cap.
+     * Scoped to the round because the Workflow drives one round at a time: an
+     * earlier round's rows are already terminal and would only widen a projection
+     * that has a size cap.
      *
-     * Skipping runs to a fixpoint because it propagates: a node skipped for a
-     * failed prerequisite blocks *its* dependents in turn. Bounded by the
-     * per-round maximum. Independent branches are untouched — one branch's failure
-     * never stops work that does not depend on it.
+     * `running` counts alongside `pending` on purpose. `executeSubtaskChunk`
+     * accepts a row that is either: the latter is its ambiguous-retry path, where a
+     * previous attempt crashed mid-execution and the managed child's fingerprint
+     * cache may still hold the terminal result that makes the retry free. So a row
+     * stranded `running` is re-runnable, and omitting it here would abandon it.
+     *
+     * Ordinal order comes from {@link listRound} and is not incidental: these ids
+     * become durable Workflow step names, so the traversal that produces them has
+     * to be deterministic.
      *
      * The cancellation verdict rides along rather than being probed separately, so
-     * a wave costs one round trip and cannot act on a stale answer.
+     * the scan costs one round trip and cannot act on a stale answer.
      */
-    async skipBlockedSubtasks(taskId, round) {
+    async scanSubtasks(taskId, round) {
         if (await this.isTaskCanceled(taskId))
             return { canceled: true };
-        const blocked = new Set(["failed", "skipped", "canceled"]);
-        for (;;) {
-            const current = this.db.subtasks.listRound(taskId, round);
-            const byId = new Map(current.map((s) => [s.id, s]));
-            const next = current.filter((s) => s.status === "pending" &&
-                s.dependsOn.some((dep) => {
-                    const parent = byId.get(dep);
-                    return parent !== undefined && blocked.has(parent.status);
-                }));
-            if (next.length === 0) {
-                return { canceled: false, nodes: current.map(toSubtaskNode) };
-            }
-            for (const s of next)
-                this.db.subtasks.skip(s.id);
-        }
+        const ids = this.db.subtasks
+            .listRound(taskId, round)
+            .filter((s) => s.status === "pending" || s.status === "running")
+            .map((s) => s.id);
+        return { canceled: false, ids };
     }
     /** Parent cancellation: cancel every still-pending Subtask. Returns the count. */
     async cancelPendingSubtasks(taskId) {
@@ -258,17 +253,17 @@ export class RoundAgentBase extends LoopingAgent {
         const subtask = this.db.subtasks.get(id);
         if (!subtask)
             return;
-        // `fail` is a guarded `running|pending -> failed`, and its verdict is the
-        // whole idempotency claim above. Dropping it made this method a no-op in
-        // *name* only: a late workflow failure that lost the race to a real result
-        // would still release the branch's runtime, abort its child and delete it —
-        // tearing down a branch that had already succeeded.
+        // `fail` is a guarded `running|pending -> failed`, and **its verdict is the
+        // whole idempotency claim above** — read it before tearing anything down. A
+        // late workflow failure that lost the race to a real result would otherwise
+        // still release the branch's runtime, abort its child and delete it, tearing
+        // down a branch that had already succeeded.
         //
-        // That is also precisely the teardown `executeSubtaskChunk` defers on the
-        // success path, because aborting a facet in the same tick its RPC returned
-        // makes telemetry record the success as a failure. Cleanup for an
-        // already-terminal row belongs to `sweepTaskChildren`, which runs after
-        // delivery and knows the whole task is done with.
+        // Cleanup for an already-terminal row belongs to `sweepTaskChildren`, which
+        // runs after delivery and knows the whole task is done with — the same
+        // teardown `executeSubtaskChunk` defers on its success path, because
+        // aborting a facet in the same tick its RPC returned makes telemetry record
+        // the success as a failure.
         if (!this.db.subtasks.fail(id, error))
             return;
         const name = subagentName(subtask.taskId, id);
@@ -300,8 +295,9 @@ export class RoundAgentBase extends LoopingAgent {
      *   delete; that now happens strictly later.
      *
      * Throws on a transient fault (the step retries and the child resumes from its
-     * checkpoint) and on scheduler-invariant violations — both are bugs, not
-     * outcomes.
+     * checkpoint) and when the row is in a status this cannot accept — a subtask
+     * that is neither `pending` nor `running` nor already terminal. Both are bugs,
+     * not outcomes.
      */
     async executeSubtaskChunk(id, chunk, push) {
         const prepared = await this.prepareChunk(id);
@@ -412,7 +408,6 @@ export class RoundAgentBase extends LoopingAgent {
             }
             return { kind: "terminal", subtask };
         }
-        const dependencyResults = this.loadDependencyResults(subtask);
         let recipe;
         let validated;
         try {
@@ -422,7 +417,8 @@ export class RoundAgentBase extends LoopingAgent {
         catch (err) {
             // An unknown/retired type or a disabled/soul-less Recipe is a
             // configuration bug, not a transient fault. Record it as a branch failure
-            // so the DAG's skip semantics apply to its dependents.
+            // so a later round can disclose the gap, rather than as a throw that would
+            // be retried forever.
             const recipeId = recipe?.key ?? subtask.type;
             const recipeVersion = recipe?.version ?? 0;
             const message = recipe
@@ -456,7 +452,6 @@ export class RoundAgentBase extends LoopingAgent {
             recipe: validated,
             prompt: subtask.prompt,
             references: subtask.references,
-            dependencyResults,
             params: subtask.params
         };
         return {
@@ -572,34 +567,6 @@ export class RoundAgentBase extends LoopingAgent {
             return this.db.subtasks.fail(id, `malformed result: ${String(err)}`);
         }
     }
-    /**
-     * Load a Subtask's dependency results, in ordinal order.
-     *
-     * Order is semantic: it feeds the child's request fingerprint, so a retry must
-     * build the identical array or the cache misses. A dependency that has not
-     * completed means the scheduler ran this node too early.
-     */
-    loadDependencyResults(subtask) {
-        if (subtask.dependsOn.length === 0)
-            return [];
-        const deps = this.db.subtasks
-            .list(subtask.taskId)
-            .filter((s) => subtask.dependsOn.includes(s.id));
-        if (deps.length !== subtask.dependsOn.length) {
-            throw new Error(`subtask ${subtask.id} has unknown dependencies`);
-        }
-        return deps.map((dep) => {
-            if (dep.status !== "completed" || !dep.resultParts) {
-                throw new Error(`subtask ${subtask.id} ran before dependency ${dep.id} completed ` +
-                    `(status=${dep.status})`);
-            }
-            return {
-                subtaskId: dep.id,
-                type: dep.type,
-                resultParts: dep.resultParts
-            };
-        });
-    }
     /** Re-read a Subtask that must exist (it was just written). */
     requireSubtask(id) {
         const row = this.db.subtasks.get(id);
@@ -628,7 +595,7 @@ export class RoundAgentBase extends LoopingAgent {
      * Interrupt a canceled Task's live children: each `running` Subtask's managed
      * child gets `abortRun`, so a long recipe stops at its current model call
      * instead of at the next chunk boundary (up to `chunkSoftMs` later). A subtask
-     * that already finished (e.g. one branch of a wave completed while another was
+     * that already finished (e.g. one branch completed while another was
      * still running) is deliberately retained until the terminal-delivery sweep —
      * but a canceled Task never reaches delivery, so its idle child is deleted
      * here instead, or it would leak until the 30-day row cleanup regardless of
@@ -641,8 +608,22 @@ export class RoundAgentBase extends LoopingAgent {
      * status. Bounded by `maxSubtasks`. Best-effort throughout: a child that
      * cannot be reached is logged, never fatal — cancellation must not fail
      * because cleanup did.
+     *
+     * The `pending` rows are transitioned here too, and that is not bookkeeping:
+     * it is the only thing that resolves them. Nothing else is coming back to a
+     * pending row once a Task is canceled — the Workflow's scheduler runs a
+     * single pass and does not re-scan, and `prepareChunk` reports a canceled
+     * Task's pending row as terminal *without* claiming it, so a branch whose RPC
+     * had not yet reached the claim when the cancellation landed simply returns.
+     * Left to the loop below, which only deletes the child, the row would sit
+     * non-terminal until the 30-day cleanup.
      */
     async onTaskCanceled(taskId) {
+        // First, and outside the loop: `cancelPending` is one guarded bulk
+        // `pending -> canceled`, so it cannot be skipped by a best-effort teardown
+        // below throwing partway through, and a branch that won the claim a moment
+        // ago is left alone to resolve through `cancelRunning` on its own path.
+        this.db.subtasks.cancelPending(taskId);
         for (const subtask of this.db.subtasks.list(taskId)) {
             const name = subagentName(taskId, subtask.id);
             if (subtask.status !== "running") {
@@ -679,13 +660,3 @@ export class RoundAgentBase extends LoopingAgent {
         }
     }
 }
-/** Project a durable row to the scheduler's view. */
-function toSubtaskNode(s) {
-    return {
-        id: s.id,
-        ordinal: s.ordinal,
-        status: s.status,
-        dependsOn: s.dependsOn
-    };
-}
-//# sourceMappingURL=agent.js.map

package/dist/round/index.d.ts

@@ -4,8 +4,8 @@
  * A round agent answers the user or hands work to isolated subagents, waits for
  * their durable results, and decides again. This subpath ships the whole
  * mechanism of that: the round loop and its primary→fallback→repair ladder
- * ({@link runTurn}), the durable Workflow orchestration with its DAG wave
- * scheduler ({@link runHandleTask}), the Durable Object body ({@link
+ * ({@link runTurn}), the durable Workflow orchestration that runs a round's
+ * subtasks concurrently ({@link runHandleTask}), the Durable Object body ({@link
  * RoundAgentBase}), and the subagent facet host ({@link RecipeSubagentHost}).
  *
  * **Opt-in, and its own subpath on purpose.** An agent whose turn is a single
@@ -21,5 +21,5 @@ export type { RoundPolicy } from "./policy.js";
 export { RoundAgentBase } from "./agent.js";
 export { RecipeSubagentHost, type SubagentClass } from "./subagent.js";
 export { runHandleTask, type HandleTaskDeps, type HandleTaskParams } from "./workflow.js";
+export type { NonRecoverableKind, RoundFailureKind } from "../agent/inference.js";
 export { buildTurnInstructions, joinSuccessfulBranches, renderTurnMessages, runTurn, type RoundMode, type RunTurnArgs, type RunTurnOutcome, type TurnInstructions } from "./turn.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/round/index.js

@@ -4,8 +4,8 @@
  * A round agent answers the user or hands work to isolated subagents, waits for
  * their durable results, and decides again. This subpath ships the whole
  * mechanism of that: the round loop and its primary→fallback→repair ladder
- * ({@link runTurn}), the durable Workflow orchestration with its DAG wave
- * scheduler ({@link runHandleTask}), the Durable Object body ({@link
+ * ({@link runTurn}), the durable Workflow orchestration that runs a round's
+ * subtasks concurrently ({@link runHandleTask}), the Durable Object body ({@link
  * RoundAgentBase}), and the subagent facet host ({@link RecipeSubagentHost}).
  *
  * **Opt-in, and its own subpath on purpose.** An agent whose turn is a single
@@ -21,4 +21,3 @@ export { RoundAgentBase } from "./agent.js";
 export { RecipeSubagentHost } from "./subagent.js";
 export { runHandleTask } from "./workflow.js";
 export { buildTurnInstructions, joinSuccessfulBranches, renderTurnMessages, runTurn } from "./turn.js";
-//# sourceMappingURL=index.js.map

package/dist/round/policy.d.ts

@@ -2,8 +2,8 @@ import type { AgentLimits } from "../config.js";
 /**
  * Everything about a round loop that is **yours**, not core's.
  *
- * The round loop in this subpath is mechanism: the DAG wave scheduler, chunked
- * subagent execution, cancellation ordering, idempotent recovery, the
+ * The round loop in this subpath is mechanism: concurrent subtask execution,
+ * chunked subagent runs, cancellation ordering, idempotent recovery, the
  * primary→fallback→repair ladder. None of it varies between agents, and every
  * place it *did* vary between two agents in one repo turned out to be a bug.
  *
@@ -96,4 +96,3 @@ export interface RoundPolicy {
         partialNote: string;
     };
 }
-//# sourceMappingURL=policy.d.ts.map

package/dist/round/policy.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=policy.js.map

package/dist/round/subagent.d.ts

@@ -1,6 +1,7 @@
 import type { AgentPlugin } from "../contract/plugin.js";
-import type { CoreConfigOverrides } from "../config.js";
+import type { CoreConfigOverrides, ModelConfig } from "../config.js";
 import type { AiEnv } from "../env.js";
+import type { ModelRuntime } from "../agent/model.js";
 import { RecipeSubagentBase, type SubagentRuntime } from "../subagent/index.js";
 import type { PluginHost } from "../host/plugin-host.js";
 /**
@@ -54,6 +55,23 @@ export declare abstract class RecipeSubagentHost<TEnv extends Cloudflare.Env & A
      * that an implementation building anything expensive should memoize its own.
      */
     protected subagentRuntime(): SubagentRuntime;
+    /**
+     * Which provider this facet's chunks run on. Mirrors
+     * {@link file://../host/agent.ts LoopingAgent.modelRuntime}, and **must be
+     * overridden to match it** — a facet that keeps the Workers AI default while
+     * its parent runs on Claude would silently execute every subtask on a
+     * different model than the round that delegated it.
+     *
+     * The two seams take the same arguments precisely so that keeping them in step
+     * needs no discipline: write the provider once as a
+     * {@link file://../agent/model.ts ModelRuntimeFactory} and have both return
+     * it. Two hand-copied `createAnthropicModelRuntime({...})` bodies is what this
+     * shape exists to stop, because nothing type-checks their agreement.
+     *
+     * Takes the model config rather than reading `this.config`, because the facet
+     * resolves its config inside `buildRuntime` and this is called from there.
+     */
+    protected modelRuntime(model: ModelConfig): ModelRuntime;
     private buildRuntime;
 }
 /**
@@ -64,4 +82,3 @@ export declare abstract class RecipeSubagentHost<TEnv extends Cloudflare.Env & A
  * typed as this: any named subclass below it.
  */
 export type SubagentClass = new (...args: ConstructorParameters<typeof RecipeSubagentBase>) => RecipeSubagentBase;
-//# sourceMappingURL=subagent.d.ts.map

package/dist/round/subagent.js

@@ -1,5 +1,5 @@
 import { createAgentRuntime } from "../runtime/index.js";
-import { createModelRuntime } from "../agent/model.js";
+import { workersAIModels } from "../agent/workers-ai/index.js";
 import { RecipeSubagentBase } from "../subagent/index.js";
 /**
  * The host half of a subagent facet: the same plugins as its parent, assembled
@@ -50,6 +50,25 @@ export class RecipeSubagentHost extends RecipeSubagentBase {
     subagentRuntime() {
         return (this._rt ??= this.buildRuntime());
     }
+    /**
+     * Which provider this facet's chunks run on. Mirrors
+     * {@link file://../host/agent.ts LoopingAgent.modelRuntime}, and **must be
+     * overridden to match it** — a facet that keeps the Workers AI default while
+     * its parent runs on Claude would silently execute every subtask on a
+     * different model than the round that delegated it.
+     *
+     * The two seams take the same arguments precisely so that keeping them in step
+     * needs no discipline: write the provider once as a
+     * {@link file://../agent/model.ts ModelRuntimeFactory} and have both return
+     * it. Two hand-copied `createAnthropicModelRuntime({...})` bodies is what this
+     * shape exists to stop, because nothing type-checks their agreement.
+     *
+     * Takes the model config rather than reading `this.config`, because the facet
+     * resolves its config inside `buildRuntime` and this is called from there.
+     */
+    modelRuntime(model) {
+        return workersAIModels(this.env, model);
+    }
     buildRuntime() {
         const config = this.agentConfig();
         const runtime = createAgentRuntime({
@@ -73,17 +92,14 @@ export class RecipeSubagentHost extends RecipeSubagentBase {
         return {
             policy: runtime.policy,
             types: runtime.types,
-            models: createModelRuntime({
-                ai: this.env.AI,
-                config: runtime.config.model
-            }),
+            models: this.modelRuntime(runtime.config.model),
             toolFamilies: runtime.toolFamilies,
             toolOutputWindow: runtime.config.toolOutputWindow,
             maxOutputTokens: runtime.config.model.maxOutputTokens,
+            maxRetries: runtime.config.model.maxRetries,
             // Always defined: the plugin that declared a backend, or core's in-memory
             // fallback. So this needs no null check.
             workspaceBacking: runtime.workspaceBacking
         };
     }
 }
-//# sourceMappingURL=subagent.js.map

package/dist/round/turn.d.ts

@@ -3,7 +3,7 @@ import type { SessionMessage } from "agents/experimental/memory/session";
 import type { AgentLimits } from "../config.js";
 import type { SubtaskTypeRegistry } from "../subtasks/subtask-types.js";
 import { type SessionLike } from "../agent/session.js";
-import { type OnContent } from "../agent/inference.js";
+import { type OnContent, type RoundFailureKind } from "../agent/inference.js";
 import { type TurnBudget } from "../agent/budget.js";
 import type { ModelPair } from "../agent/model.js";
 import { type ReferenceCatalogEntry } from "../subtasks/catalog.js";
@@ -14,7 +14,7 @@ import type { RoundPolicy } from "./policy.js";
  * Session that ends in one of two decisions — answer the user, or delegate.
  *
  * This is the whole task pipeline's control point. The Workflow runs rounds in a
- * loop: a round that delegates gets its Subtask DAG executed and is followed by
+ * loop: a round that delegates gets its Subtasks executed and is followed by
  * another round; a round that answers ends the Task. So "compose" is not a
  * separate phase with its own rules — it is simply the round in which the model
  * decides it has enough to answer.
@@ -43,12 +43,8 @@ import type { RoundPolicy } from "./policy.js";
  * delegating twice is allowed.
  *
  * What *is* forced is that the round end in a control call at all —
- * `toolChoice: "required"`, with both endings declared as tools. Plain text used to
- * be an outcome, and it made narration indistinguishable from an answer: a model
- * that wrote "I'll start the game" and emitted no call ended the Task successfully
- * having done nothing. Two named tools is also a much easier discrimination for a
- * small model than prose-versus-tool, which is what the weaker fallback models
- * consistently got wrong.
+ * `toolChoice: "required"`, with both endings declared as tools. Prose is not an
+ * outcome: see {@link file://../agent/final-reply.ts final-reply.ts} for why not.
  *
  * Narration survived that fix by moving house. A round whose results have just come
  * back can still announce its next step *inside* a `final_reply` — "now sending the
@@ -179,6 +175,8 @@ export interface RunTurnArgs {
     maxSubtasks: number;
     /** `CoreConfig.model.maxOutputTokens`. */
     maxOutputTokens: number;
+    /** `CoreConfig.model.maxRetries` — retries on *this* model before the fallback. */
+    maxRetries: number;
     /** The prompt suffixes, memoized by the DO. See {@link buildTurnInstructions}. */
     instructions: TurnInstructions;
     /** The note a deterministic join appends when it has to disclose gaps. */
@@ -187,10 +185,17 @@ export interface RunTurnArgs {
     onContent?: OnContent;
 }
 /**
- * Terminal outcome of one round. `failed` means both models produced unusable
- * output *and* there was no durable work to fall back on — the parent Task fails
- * rather than running a synthesized subtask nobody asked for. Transient faults
- * throw instead (the Workflow step retries).
+ * Terminal outcome of one round. `failed` means the round produced no answer and
+ * there was no durable work to fall back on — the parent Task fails rather than
+ * running a synthesized subtask nobody asked for. Transient faults throw instead
+ * (the Workflow step retries).
+ *
+ * `kind` is *why*, not a second outcome. The round is over either way and the
+ * Task it delivers has the same shape; what the kind decides is what a human is
+ * told — `exhausted` is "the models could not do it", a credential kind is "a
+ * human must fix the deployment". Both were once separate statuses, and every
+ * consumer promptly bundled them back together to do the same three things. See
+ * {@link RoundFailureKind}.
  *
  * What the round cost is not here: it is in the caller's `TurnBudget`, which every
  * exit has already charged — including the ones that failed. A round that burned
@@ -206,6 +211,7 @@ export type RunTurnOutcome = {
     drafts: SubtaskDraft[];
 } | {
     status: "failed";
+    kind: RoundFailureKind;
     error: string;
 };
 /**
@@ -225,7 +231,19 @@ export type RunTurnOutcome = {
  * Throws only on a transient platform fault (for the Workflow step to retry).
  * A deterministic failure that outlasts every repair on both slots, with durable
  * work behind it, degrades to {@link joinSuccessfulBranches} rather than discarding
- * completed branches; with nothing behind it, it resolves to `{ status: "failed" }`.
+ * completed branches; with nothing behind it, it resolves to
+ * `{ status: "failed", kind: "exhausted" }`.
+ *
+ * The third failure is neither, and it short-circuits the *model* recoveries
+ * above: a {@link nonRecoverableKind} error ends the round from wherever it
+ * happens, carrying that kind — without repairing and **without reaching the
+ * fallback slot**, both of which would only present the same dead credential
+ * again. See that function for why the transient/deterministic split cannot
+ * express it.
+ *
+ * It does **not** skip the deterministic join. That path needs no credential —
+ * it is string concatenation over rows that are already durable — so completed
+ * branches are still delivered, and the credential fault reaches the operator
+ * through the log rather than by throwing away finished work.
  */
 export declare function runTurn(args: RunTurnArgs): Promise<RunTurnOutcome>;
-//# sourceMappingURL=turn.d.ts.map