@loopingai/core 0.5.0 → 0.6.0

package/dist/agent/inference.js

@@ -1,4 +1,7 @@
 import { APICallError, RetryError } from "ai";
+// Type-only would not work: this is a runtime guard. `errors.ts` is the neutral
+// sibling of `model.ts` and imports nothing, so this reaches no provider.
+import { CredentialRejectedError } from "./errors.js";
 /** Workers-AI error codes and message fragments that mean "try again later". */
 const TRANSIENT_MESSAGE_FRAGMENTS = [
     "3040",
@@ -32,6 +35,12 @@ function isRetryableStatus(status) {
  * error codes, which arrive as prose on a plain `Error`.
  */
 export function isTransientAiError(err) {
+    // Checked first because a rejected credential's message can carry "rate
+    // limit"-adjacent prose the fragment scan below would misread as transient.
+    // Note that `false` alone does not protect the fallback slot — see
+    // {@link nonRecoverableKind}, which is what actually stops the ladder.
+    if (nonRecoverableKind(err) !== undefined)
+        return false;
     if (APICallError.isInstance(err)) {
         if (err.isRetryable)
             return true;
@@ -45,6 +54,41 @@ export function isTransientAiError(err) {
     const message = err.message.toLowerCase();
     return TRANSIENT_MESSAGE_FRAGMENTS.some((fragment) => message.includes(fragment));
 }
+/**
+ * Whether an error is one that **no** further attempt can clear, and the reason.
+ *
+ * This is the third classification, and the one the other two cannot express.
+ * {@link isTransientAiError} splits failures into "retry the step" (`true`) and
+ * "burn this slot, try the fallback" (`false`) — and for a rejected credential
+ * *both* are wrong. Retrying spends the Workflow's budget on a request that can
+ * never succeed; falling back spends the second slot presenting the *same* dead
+ * token. Returning `false` from the transient check only avoids the first.
+ *
+ * So the attempt ladders check this **before** entering the fallback slot and
+ * stop there, and `runHandleTask` ends the Task with copy the host supplies.
+ * Nothing is retried and nothing is spent proving the obvious twice.
+ *
+ * Keyed on {@link file://./errors.ts CredentialRejectedError}, which is neutral
+ * and structurally matched — so a provider outside core raises one and gets this
+ * handling with nothing here to change.
+ */
+export function nonRecoverableKind(err) {
+    if (!CredentialRejectedError.isInstance(err))
+        return undefined;
+    switch (err.source) {
+        case "provider":
+            return "credential";
+        case "gateway":
+            return "gateway-credential";
+        case "proxy":
+            return "proxy-credential";
+        // Includes an error that crossed a realm boundary carrying no `source` at
+        // all: `isInstance` is structural, so that is reachable, and "unknown" is
+        // the honest reading of it.
+        default:
+            return "unknown-credential";
+    }
+}
 /** A step is "intermediate" when it makes tool calls — more content follows. */
 function isIntermediateStep(step) {
     return step.finishReason === "tool-calls";
@@ -76,4 +120,3 @@ export function buildIntermediateContentHandler(onContent, terminalToolNames = [
             await onContent(content, i);
     };
 }
-//# sourceMappingURL=inference.js.map

package/dist/agent/model.d.ts

@@ -1,12 +1,24 @@
 import type { LanguageModel } from "ai";
 import type { ModelConfig } from "../config.js";
 /**
- * The Workers-AI model pair every loop runs on, built per agent instance.
+ * The provider contract every loop runs against — and nothing that implements
+ * it.
  *
- * The predecessor read `env.AI` and five config constants as module-level
- * imports. Neither survives packaging: `env` does not exist at module scope on
- * Workers, and a module constant cannot be overridden by a consumer. So this is
- * a factory over an injected binding and an injected {@link ModelConfig}.
+ * {@link ModelRuntime} is the whole seam: an agent that returns one runs every
+ * loop in core unchanged, because nothing downstream — the round loop, the
+ * control-tool repair ladder, the Session's compaction, the Workflow — ever sees
+ * more than a `LanguageModel` from `ai`. It never learns which provider produced
+ * it.
+ *
+ * The implementations are siblings under `agent/`, one directory each:
+ * {@link file://./workers-ai/index.ts `./workers-ai`} is core's default, and
+ * {@link file://./anthropic/index.ts `./anthropic`} is Claude behind an optional
+ * peer dependency. A third provider is a third directory exporting one
+ * {@link ModelRuntimeFactory}; nothing here has to change to admit it.
+ *
+ * Which is why this file has no runtime imports at all. The Workers AI factory
+ * used to live in it, and a contract that ships one implementation inline reads
+ * as *the* runtime with an escape hatch, rather than as one of N.
  */
 /**
  * Custom metadata attached to the AI Gateway log for every call a pair makes.
@@ -22,15 +34,16 @@ export interface ModelOverrides {
     /** Test override for the fallback slot. */
     fallbackModel?: LanguageModel;
     /**
-     * Workers-AI id for the primary slot (a recipe's, already code-validated
-     * against the allowlist by `validateRecipe`). Defaults to the configured
+     * The provider's model id for the primary slot. Defaults to the configured
      * `chatModelId`.
+     *
+     * The subagent path passes `ValidatedRecipe.primaryModelId`, which is the
+     * host's own configured id — `validateRecipe` copies the pair on, and a recipe
+     * has no field to name a model with. So this parameterizes the pair without
+     * ever widening which models are reachable.
      */
     primaryModelId?: string;
-    /**
-     * Workers-AI id for the fallback slot (already code-validated). Defaults to
-     * the configured `fallbackChatModelId`.
-     */
+    /** The provider's model id for the fallback slot. See {@link primaryModelId}. */
     fallbackModelId?: string;
     /** AI Gateway log metadata for correlation — see {@link GatewayMetadata}. */
     metadata?: GatewayMetadata;
@@ -45,24 +58,27 @@ export interface ModelPair {
 export interface ModelRuntime {
     /**
      * Lazily build + memoize a primary/fallback model pair (overridable in tests,
-     * id-parameterized for recipes). No allowlisting happens here —
-     * `validateRecipe` is the single validation owner for recipe-supplied ids.
+     * id-parameterized so a subagent can run the pair its validated recipe
+     * carries). Nothing is checked here — the ids reaching this can only be the
+     * host's own, which `resolveConfig` has already proven non-empty and distinct.
      */
     createModelPair(overrides?: ModelOverrides): ModelPair;
 }
-export interface ModelRuntimeDeps {
-    /** The `AI` binding. Read lazily — see {@link createModelRuntime}. */
-    ai: Ai;
-    config: ModelConfig;
-}
 /**
- * Build the model runtime for one agent instance.
+ * How a provider is supplied to an agent: given the Worker env and the agent's
+ * *resolved* model config, return a runtime.
+ *
+ * Both base-class seams — `LoopingAgent.modelRuntime` and
+ * `RecipeSubagentHost.modelRuntime` — take this shape, which is the point of it.
+ * A provider written as one of these is defined once and referenced from the
+ * agent and its subagent facet, instead of being spelled out twice in two class
+ * bodies that nothing keeps in step. See
+ * {@link file://./workers-ai/runtime.ts workersAIModels} for core's own.
  *
- * The provider is constructed on first *use*, not here. During `wrangler deploy`
- * Cloudflare evaluates module scope to validate the new version, and bindings
- * are not populated at that point — constructing eagerly makes `createWorkersAI`
- * throw "you must provide either a binding or credentials". The same laziness
- * protects a consumer who builds their runtime early.
+ * Config arrives as an argument rather than being read off `this`: the facet
+ * resolves its config inside `buildRuntime` and calls the seam from there, so
+ * there is no `this.config` to read at that point — and a factory that cannot
+ * reach for one cannot disagree with its caller about which gateway the agent
+ * is on.
  */
-export declare function createModelRuntime(deps: ModelRuntimeDeps): ModelRuntime;
-//# sourceMappingURL=model.d.ts.map
+export type ModelRuntimeFactory<TEnv> = (env: TEnv, config: ModelConfig) => ModelRuntime;

package/dist/agent/model.js

@@ -1,49 +1 @@
-import { createWorkersAI } from "workers-ai-provider";
-/**
- * Build the model runtime for one agent instance.
- *
- * The provider is constructed on first *use*, not here. During `wrangler deploy`
- * Cloudflare evaluates module scope to validate the new version, and bindings
- * are not populated at that point — constructing eagerly makes `createWorkersAI`
- * throw "you must provide either a binding or credentials". The same laziness
- * protects a consumer who builds their runtime early.
- */
-export function createModelRuntime(deps) {
-    const { config } = deps;
-    let provider;
-    const workersai = () => (provider ??= createWorkersAI({
-        binding: deps.ai,
-        gateway: { id: config.aiGatewayId }
-    }));
-    /**
-     * Per-model Workers-AI settings: pin the gateway id (so per-call metadata does
-     * not drop the gateway route), attach correlation metadata when supplied, and
-     * set the reasoning budget.
-     *
-     * Always returns a settings object, even with no metadata: `reasoning_effort`
-     * has to reach the binding on every call, and an `undefined` return drops it.
-     */
-    const chatSettings = (metadata) => ({
-        gateway: { id: config.aiGatewayId, ...(metadata ? { metadata } : {}) },
-        reasoning_effort: config.reasoningEffort
-    });
-    return {
-        createModelPair(overrides = {}) {
-            const primaryId = overrides.primaryModelId ?? config.chatModelId;
-            const fallbackId = overrides.fallbackModelId ?? config.fallbackChatModelId;
-            let primary;
-            let fallback;
-            const settings = chatSettings(overrides.metadata);
-            return {
-                primary: () => (primary ??= overrides.model ?? workersai()(primaryId, settings)),
-                fallback: () => (fallback ??=
-                    overrides.fallbackModel ??
-                        overrides.model ??
-                        workersai()(fallbackId, settings)),
-                primaryId: () => primaryId,
-                fallbackId: () => fallbackId
-            };
-        }
-    };
-}
-//# sourceMappingURL=model.js.map
+export {};

package/dist/agent/session.d.ts

@@ -3,9 +3,8 @@ import { Session } from "agents/experimental/memory/session";
 import type { SessionMessage } from "agents/experimental/memory/session";
 import { createCompactFunction } from "agents/experimental/memory/utils";
 /**
- * The one continuous {@link Session} an agent Durable Object owns. Ported from
- * the looping-gateway admin agent's `shared/session.ts` (single Session per DO —
- * soul + memory + compaction).
+ * The one continuous {@link Session} an agent Durable Object owns: soul + memory
+ * + compaction, one Session per DO.
  *
  * Compaction is the one **lossy** thing this module does, so it is also the one
  * thing it announces: `onMessagesDisplaced` hands over the raw messages a
@@ -27,7 +26,7 @@ export interface SessionLike {
      * Read one message by id, or null. Reads the **raw stored row**, so it is
      * unaffected by compaction overlays — a message folded into a summary is still
      * readable here. That is what makes {@link appendOnce}'s read-back a reliable
-     * recovery path for a phase whose Workflow step re-ran.
+     * recovery path for a round whose Workflow step re-ran.
      */
     getMessage(id: string): Promise<SessionMessage | null>;
     refreshSystemPrompt(): Promise<string>;
@@ -40,13 +39,13 @@ export interface SessionLike {
  * is **durably stored** under that id.
  *
  * `Session.appendMessage` is already idempotent by id: appending an id that
- * exists is a no-op. The read-back is what matters for a re-run phase — if the
- * step crashed after appending and the retry re-inferred a *different* reply, the
+ * exists is a no-op. The read-back is what matters for a re-run step — if it
+ * crashed after appending and the retry re-inferred a *different* reply, the
  * append no-ops and this returns the original, durable text. The Session and the
  * value the caller goes on to deliver therefore never disagree.
  *
  * Falls back to the message's own text if the read-back returns null (it cannot,
- * having just been appended) rather than failing a phase over a missing echo.
+ * having just been appended) rather than failing a round over a missing echo.
  */
 export declare function appendOnce(session: SessionLike, message: SessionMessage): Promise<string>;
 export interface AgentSessionOptions {
@@ -99,4 +98,3 @@ export declare function notifyingCompaction(base: CompactFn, onMessagesDisplaced
  */
 export declare function buildAgentSession(agent: SessionHost, model: LanguageModel, opts: AgentSessionOptions): Session;
 export {};
-//# sourceMappingURL=session.d.ts.map

package/dist/agent/session.js

@@ -7,13 +7,13 @@ import { sessionText } from "./history.js";
  * is **durably stored** under that id.
  *
  * `Session.appendMessage` is already idempotent by id: appending an id that
- * exists is a no-op. The read-back is what matters for a re-run phase — if the
- * step crashed after appending and the retry re-inferred a *different* reply, the
+ * exists is a no-op. The read-back is what matters for a re-run step — if it
+ * crashed after appending and the retry re-inferred a *different* reply, the
  * append no-ops and this returns the original, durable text. The Session and the
  * value the caller goes on to deliver therefore never disagree.
  *
  * Falls back to the message's own text if the read-back returns null (it cannot,
- * having just been appended) rather than failing a phase over a missing echo.
+ * having just been appended) rather than failing a round over a missing echo.
  */
 export async function appendOnce(session, message) {
     await session.appendMessage(message);
@@ -80,4 +80,3 @@ export function buildAgentSession(agent, model, opts) {
         .onCompaction(compact)
         .compactAfter(opts.compactAfterTokens);
 }
-//# sourceMappingURL=session.js.map

package/dist/agent/workers-ai/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Workers AI — core's default model provider.
+ *
+ * A sibling of {@link file://../anthropic/index.ts `./anthropic`}, and like it a
+ * provider rather than a capability: it ships no tools, no prompt copy and no
+ * policy; it satisfies {@link file://../model.ts ModelRuntime} and stops.
+ *
+ * It differs from that sibling in two ways, both deliberate:
+ *
+ * **No `LanguageModel` adapter.** `workers-ai-provider` ships one, so this
+ * directory is a factory and nothing else. The Anthropic side hand-builds the
+ * adapter — the prompt mapping, the cache control, the error taxonomy — which is
+ * why it is five files and this is one.
+ *
+ * **No package subpath.** `/anthropic` has one because `@anthropic-ai/sdk` is an
+ * *optional* peer and an agent on Workers AI must not pay for a provider it
+ * never calls. That argument does not apply here: `workers-ai-provider` is a
+ * required peer, and this is the default every un-overridden seam reaches
+ * through `LoopingAgent` itself, so it is in every consumer's module graph
+ * already. It is exported from `@loopingai/core/agent` — one symbol, one import
+ * path.
+ */
+export { createWorkersAIModelRuntime, workersAIModels, type WorkersAIRuntimeDeps } from "./runtime.js";

package/dist/agent/workers-ai/index.js

@@ -0,0 +1,23 @@
+/**
+ * Workers AI — core's default model provider.
+ *
+ * A sibling of {@link file://../anthropic/index.ts `./anthropic`}, and like it a
+ * provider rather than a capability: it ships no tools, no prompt copy and no
+ * policy; it satisfies {@link file://../model.ts ModelRuntime} and stops.
+ *
+ * It differs from that sibling in two ways, both deliberate:
+ *
+ * **No `LanguageModel` adapter.** `workers-ai-provider` ships one, so this
+ * directory is a factory and nothing else. The Anthropic side hand-builds the
+ * adapter — the prompt mapping, the cache control, the error taxonomy — which is
+ * why it is five files and this is one.
+ *
+ * **No package subpath.** `/anthropic` has one because `@anthropic-ai/sdk` is an
+ * *optional* peer and an agent on Workers AI must not pay for a provider it
+ * never calls. That argument does not apply here: `workers-ai-provider` is a
+ * required peer, and this is the default every un-overridden seam reaches
+ * through `LoopingAgent` itself, so it is in every consumer's module graph
+ * already. It is exported from `@loopingai/core/agent` — one symbol, one import
+ * path.
+ */
+export { createWorkersAIModelRuntime, workersAIModels } from "./runtime.js";

package/dist/agent/workers-ai/runtime.d.ts

@@ -0,0 +1,42 @@
+import type { ModelConfig } from "../../config.js";
+import type { AiEnv } from "../../env.js";
+import type { ModelRuntime, ModelRuntimeFactory } from "../model.js";
+/**
+ * The Workers-AI model pair every loop runs on by default, built per agent
+ * instance.
+ *
+ * The predecessor read `env.AI` and five config constants as module-level
+ * imports. Neither survives packaging: `env` does not exist at module scope on
+ * Workers, and a module constant cannot be overridden by a consumer. So this is
+ * a factory over an injected binding and an injected {@link ModelConfig}.
+ */
+export interface WorkersAIRuntimeDeps {
+    /** The `AI` binding. Read lazily — see {@link createWorkersAIModelRuntime}. */
+    ai: Ai;
+    config: ModelConfig;
+}
+/**
+ * Build the Workers AI model runtime for one agent instance.
+ *
+ * The provider is constructed on first *use*, not here. During `wrangler deploy`
+ * Cloudflare evaluates module scope to validate the new version, and bindings
+ * are not populated at that point — constructing eagerly makes `createWorkersAI`
+ * throw "you must provide either a binding or credentials". The same laziness
+ * protects a consumer who builds their runtime early.
+ */
+export declare function createWorkersAIModelRuntime(deps: WorkersAIRuntimeDeps): ModelRuntime;
+/**
+ * Core's default provider — what every {@link ModelRuntimeFactory} seam lands on
+ * when an agent does not override it.
+ *
+ * One definition rather than one per base class. The body used to be written
+ * twice, once in {@link file://../../host/agent.ts LoopingAgent.modelRuntime}
+ * and once in
+ * {@link file://../../round/subagent.ts RecipeSubagentHost.modelRuntime}, which
+ * is the same duplication the seam exists to let a *consumer* avoid.
+ *
+ * Typed on {@link AiEnv} rather than a caller's full `Env`: a factory that
+ * accepts the narrow shape is callable with any env that satisfies it, so both
+ * base classes pass `this.env` straight through.
+ */
+export declare const workersAIModels: ModelRuntimeFactory<AiEnv>;

package/dist/agent/workers-ai/runtime.js

@@ -0,0 +1,63 @@
+import { createWorkersAI } from "workers-ai-provider";
+/**
+ * Build the Workers AI model runtime for one agent instance.
+ *
+ * The provider is constructed on first *use*, not here. During `wrangler deploy`
+ * Cloudflare evaluates module scope to validate the new version, and bindings
+ * are not populated at that point — constructing eagerly makes `createWorkersAI`
+ * throw "you must provide either a binding or credentials". The same laziness
+ * protects a consumer who builds their runtime early.
+ */
+export function createWorkersAIModelRuntime(deps) {
+    const { config } = deps;
+    let provider;
+    const workersai = () => (provider ??= createWorkersAI({
+        binding: deps.ai,
+        gateway: { id: config.aiGatewayId }
+    }));
+    /**
+     * Per-model Workers-AI settings: pin the gateway id (so per-call metadata does
+     * not drop the gateway route), attach correlation metadata when supplied, and
+     * set the reasoning budget.
+     *
+     * Always returns a settings object, even with no metadata: `reasoning_effort`
+     * has to reach the binding on every call, and an `undefined` return drops it.
+     */
+    const chatSettings = (metadata) => ({
+        gateway: { id: config.aiGatewayId, ...(metadata ? { metadata } : {}) },
+        reasoning_effort: config.reasoningEffort
+    });
+    return {
+        createModelPair(overrides = {}) {
+            const primaryId = overrides.primaryModelId ?? config.chatModelId;
+            const fallbackId = overrides.fallbackModelId ?? config.fallbackChatModelId;
+            let primary;
+            let fallback;
+            const settings = chatSettings(overrides.metadata);
+            return {
+                primary: () => (primary ??= overrides.model ?? workersai()(primaryId, settings)),
+                fallback: () => (fallback ??=
+                    overrides.fallbackModel ??
+                        overrides.model ??
+                        workersai()(fallbackId, settings)),
+                primaryId: () => primaryId,
+                fallbackId: () => fallbackId
+            };
+        }
+    };
+}
+/**
+ * Core's default provider — what every {@link ModelRuntimeFactory} seam lands on
+ * when an agent does not override it.
+ *
+ * One definition rather than one per base class. The body used to be written
+ * twice, once in {@link file://../../host/agent.ts LoopingAgent.modelRuntime}
+ * and once in
+ * {@link file://../../round/subagent.ts RecipeSubagentHost.modelRuntime}, which
+ * is the same duplication the seam exists to let a *consumer* avoid.
+ *
+ * Typed on {@link AiEnv} rather than a caller's full `Env`: a factory that
+ * accepts the narrow shape is callable with any env that satisfies it, so both
+ * base classes pass `this.env` straight through.
+ */
+export const workersAIModels = (env, config) => createWorkersAIModelRuntime({ ai: env.AI, config });

package/dist/config.d.ts

@@ -1,16 +1,3 @@
-/**
- * The shapes of everything an agent tunes, plus a working set of defaults.
- *
- * In the predecessor repos this file held bare `export const`s that ~12 modules
- * imported directly. That is what this package cannot do: a module-level constant
- * read at import time is not overridable by a consumer, and it freezes the value
- * into the module graph before `env` exists. So core owns the *shapes* and a
- * baseline; a consuming agent passes overrides to {@link resolveConfig} once, at
- * DO start, and the resolved object is threaded through explicitly.
- *
- * The distinction against {@link file://./platform.ts} stays sharp: nothing here
- * is a platform fact, and nothing there is tunable.
- */
 /** Model ids and per-call generation settings. */
 export interface ModelConfig {
     /**
@@ -40,6 +27,21 @@ export interface ModelConfig {
     fallbackChatModelId: string;
     /** AI Gateway slug; `"default"` auto-provisions on first request. */
     aiGatewayId: string;
+    /**
+     * The segment after the gateway slug in `.../{gateway}/{provider}` — either a
+     * provider-native path like `"anthropic"` or a
+     * [custom provider](https://developers.cloudflare.com/ai-gateway/configuration/custom-providers/)
+     * slug. Core never reads it; a `ModelRuntime` that builds its own base URL
+     * does.
+     *
+     * Config rather than a literal at that call site because the parent agent and
+     * its subagent facet resolve their config independently, and a value that
+     * drifts between them routes delegated subtasks through a different provider
+     * than the round that delegated them — silently, since both satisfy
+     * `ModelRuntime`. Which path to pick, and why, belongs with the agent that
+     * picks it.
+     */
+    aiGatewayProvider: string;
     /**
      * Output-token ceiling for every chat call. Left unset, the binding applies a
      * per-model default which a reasoning model spends on `reasoning_content`
@@ -49,6 +51,38 @@ export interface ModelConfig {
     maxOutputTokens: number;
     /** Reasoning budget forwarded on the binding's `inputs` by workers-ai-provider. */
     reasoningEffort: "low" | "medium" | "high";
+    /**
+     * How many times a single model call is retried **on the same model** before
+     * the round gives up on that slot and moves to the fallback.
+     *
+     * This was hardcoded to `0` for a long time, with a reason that was right for
+     * one case and wrong for the other. The reason: primary→fallback recovery is
+     * ours, so provider-level backoff only adds latency and duplicates it. True
+     * when the two slots are different vendors, which is what
+     * {@link fallbackChatModelId} advises — a 429 on one says nothing about the
+     * other, so falling straight through is the fastest correct move.
+     *
+     * It is false for a rate limit on an agent whose slots share a credential. A
+     * coder running Opus with Sonnet as its step-down burns the fallback proving
+     * the same 429 twice, then throws, then the Workflow retries the whole round
+     * and does it again. Waiting the `retry-after` the provider actually sent is
+     * both cheaper and far more likely to work.
+     *
+     * The AI SDK does the waiting, and it does it properly:
+     * `retryWithExponentialBackoffRespectingRetryHeaders` honours `retry-after-ms`
+     * and `retry-after` and falls back to exponential backoff. It only fires for
+     * an `APICallError` carrying `isRetryable`, which is why
+     * {@link file://./agent/anthropic/language-model.ts} maps provider errors into
+     * that shape rather than rethrowing them raw.
+     *
+     * Bounded at 4 by `resolveConfig`. The retries happen *inside*
+     * `step.do("turn:<round>")`, and the SDK caps a single honoured `retry-after`
+     * at 60s, so the worst case is roughly `maxRetries` minutes of waiting before
+     * the round has spent a token of its own — against
+     * {@link file://./platform.ts STEP_TIMEOUT_MS}, which is where that ceiling is
+     * stated and the only place it should be read from.
+     */
+    maxRetries: number;
 }
 /**
  * An execution budget, in the only two currencies that mean anything: **turns**
@@ -126,8 +160,8 @@ export interface CoreConfig {
     toolOutputWindow: number;
     /**
      * Upper bound on subtasks per **round** — a core invariant: a delegating round
-     * emits `1..maxSubtasks` subtasks, which is also what bounds its fan-out (all
-     * dependency-ready subtasks run concurrently, with no other concurrency cap).
+     * emits `1..maxSubtasks` subtasks, which is also what bounds its fan-out (they
+     * all run concurrently, with no other concurrency cap).
      *
      * Not a budget but a shape: it is what the delegation schema offers the model,
      * and the data layer re-checks it as the durable guard.
@@ -181,4 +215,3 @@ export declare class ConfigError extends Error {
  * reads the same object.
  */
 export declare function resolveConfig(overrides: CoreConfigOverrides): CoreConfig;
-//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -11,6 +11,15 @@
  * The distinction against {@link file://./platform.ts} stays sharp: nothing here
  * is a platform fact, and nothing there is tunable.
  */
+import { STEP_TIMEOUT_MS } from "./platform.js";
+/**
+ * Ceiling on {@link ModelConfig.maxRetries}.
+ *
+ * Derived, not chosen: each honoured `retry-after` can be up to 60s and they all
+ * run inside one `step.do`, so this holds the worst case to a small fraction of
+ * {@link STEP_TIMEOUT_MS} and leaves the round its own time to actually work.
+ */
+const MAX_MODEL_RETRIES = 4;
 /**
  * A working baseline. Every value is overridable; none is a ceiling. These are
  * the values both predecessor agents converged on in production, so they are a
@@ -23,8 +32,16 @@ export const DEFAULT_CORE_CONFIG = {
         // Not a model: an AI Gateway slug, and `"default"` is Cloudflare's own
         // auto-provision behaviour rather than a choice core is making for anyone.
         aiGatewayId: "default",
+        // The provider-native Anthropic endpoint, which is what a deployment with
+        // no custom provider registered has. Agents that must own the credential
+        // themselves override this with their `custom-*` slug.
+        aiGatewayProvider: "anthropic",
         maxOutputTokens: 16_384,
-        reasoningEffort: "medium"
+        reasoningEffort: "medium",
+        // Two, which is the AI SDK's own default and enough to ride out the kind of
+        // rate limit that clears in seconds. Raising it trades round latency for
+        // resilience; see {@link ModelConfig.maxRetries} for the ceiling and why.
+        maxRetries: 2
     },
     mainAgentLimits: { maxTurns: 20, maxWallMs: 60 * 60_000 },
     subagentLimits: { maxTurns: 20, maxWallMs: 30 * 60_000 },
@@ -99,6 +116,18 @@ export function resolveConfig(overrides) {
     positive(config.toolOutputWindow, "toolOutputWindow");
     positive(config.maxSubtasks, "maxSubtasks");
     positive(config.model.maxOutputTokens, "model.maxOutputTokens");
+    // Zero is legal (it opts out), so this is not `positive`. The ceiling is the
+    // step timeout: retries happen inside `step.do("turn:<round>")`, and the AI
+    // SDK honours a `retry-after` of up to 60s per attempt — so `maxRetries`
+    // minutes of waiting inside one step, before the round has spent a single
+    // token of its own. The message below reads the real number off `platform.ts`.
+    if (!Number.isInteger(config.model.maxRetries) ||
+        config.model.maxRetries < 0 ||
+        config.model.maxRetries > MAX_MODEL_RETRIES) {
+        throw new ConfigError(`model.maxRetries must be an integer between 0 and ${MAX_MODEL_RETRIES}, got ` +
+            `${config.model.maxRetries} — retries run inside one Workflow step, and each ` +
+            `honoured retry-after can be up to 60s against a ${STEP_TIMEOUT_MS / 60_000}-minute step timeout`);
+    }
     // See SessionConfig.compactTailTokens — below this gap the fixed floor eats
     // the headroom and compaction fires on nearly every append.
     const headroom = config.session.compactAfterTokens - config.session.compactTailTokens;
@@ -108,4 +137,3 @@ export function resolveConfig(overrides) {
     }
     return config;
 }
-//# sourceMappingURL=config.js.map

package/dist/contract/index.d.ts

@@ -7,4 +7,3 @@
 export { PLUGIN_CONTRACT_VERSION, definePlugin, type AgentPlugin, type EmitProgress, type EnrichResultContext, type MainAgentToolContext, type PluginRequirements, type RecipeToolSet, type ResolveRuntimeContext, type ToolFamilyBuilder, type ToolFamilyContext, type TurnGateContext } from "./plugin.js";
 export type { DelegationNames, RecipeLimits, ResolvedRecipe, SubtaskParams, SubtaskParamsSchema, SubtaskParamsShape, SubtaskTypeSpec, ValidatedRecipe } from "./recipe.js";
 export { RecipeValidationError, resolveLimits, validateRecipe, type RecipePolicy } from "./validation.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/contract/index.js

@@ -6,4 +6,3 @@
  */
 export { PLUGIN_CONTRACT_VERSION, definePlugin } from "./plugin.js";
 export { RecipeValidationError, resolveLimits, validateRecipe } from "./validation.js";
-//# sourceMappingURL=index.js.map