@loopingai/core 0.5.0 → 0.6.0

package/dist/subtasks/delegate.d.ts

@@ -41,8 +41,22 @@ export declare function makeDelegateTool(types: SubtaskTypeRegistry, maxSubtasks
 /**
  * The call's id, derived from the parent Task and the round that emitted it —
  * deterministic and replay-safe, the same discipline as the Session message ids
- * it sits alongside (see {@link file://../history.ts}). Later rounds rebuild it
+ * it sits alongside (see {@link file://../agent/history.ts}). Later rounds rebuild it
  * rather than storing it.
+ *
+ * **Underscores, not colons, and this is load-bearing.** Unlike a Session message
+ * id, this one is sent to a provider as a `tool_use.id`, and Anthropic validates
+ * that field against `^[a-zA-Z0-9_-]+$`. The colon-separated form this used to
+ * return failed every round from the first delegation onwards — round 0 was fine
+ * because the model authors its own ids, and round 1 reconstructs this one, so
+ * the request 400d deterministically on both the primary and the fallback until
+ * the deterministic join fired. Workers AI never validated the field, which is
+ * why it took a Claude-backed agent to surface it.
+ *
+ * Nothing persists this: both halves of the pair are rebuilt together on every
+ * request, so changing the shape needs no migration. See
+ * {@link file://../agent/anthropic/prompt.ts providerSafeToolCallId} for the
+ * backstop that catches the next one of these.
  */
 export declare function delegateToolCallId(taskId: string, round: number): string;
 /**
@@ -71,8 +85,12 @@ export type DelegateSubtaskOutcome = {
  * `referenceIndexes` is omitted rather than faked: this round's references were
  * snapshotted verbatim onto the rows when it ran, and the catalog they were
  * chosen from is long gone.
+ *
+ * A subtask proposal carries no identifier of its own, so the model pairs each
+ * entry here with its outcome **by position**: both arrays are built from the
+ * same ordinal-ordered `branches`, and the outcome additionally repeats `type`
+ * and carries the durable `subtaskId`.
  */
 export declare function delegateCallInput(reply: string, branches: CompositionBranch[]): DecompositionProposal;
 /** Rebuild one round's call result from its durable rows, in stable ordinal order. */
 export declare function delegateCallOutput(branches: CompositionBranch[]): DelegateSubtaskOutcome[];
-//# sourceMappingURL=delegate.d.ts.map

package/dist/subtasks/delegate.js

@@ -47,23 +47,25 @@ export function makeDelegateTool(types, maxSubtasks) {
 /**
  * The call's id, derived from the parent Task and the round that emitted it —
  * deterministic and replay-safe, the same discipline as the Session message ids
- * it sits alongside (see {@link file://../history.ts}). Later rounds rebuild it
+ * it sits alongside (see {@link file://../agent/history.ts}). Later rounds rebuild it
  * rather than storing it.
- */
-export function delegateToolCallId(taskId, round) {
-    return `task:${taskId}:round:${round}:delegate`;
-}
-/**
- * The draft-local key a reconstructed call uses for a durable Subtask.
  *
- * A row does not keep the `localKey` its round's model chose — the data layer
- * resolved it to a SQLite id and dropped it. So reconstruction derives a stable
- * key from that id instead: the *same* id the matching outcome carries in
- * {@link DelegateSubtaskOutcome}, so the model can line each result up with the
- * work that produced it.
+ * **Underscores, not colons, and this is load-bearing.** Unlike a Session message
+ * id, this one is sent to a provider as a `tool_use.id`, and Anthropic validates
+ * that field against `^[a-zA-Z0-9_-]+$`. The colon-separated form this used to
+ * return failed every round from the first delegation onwards — round 0 was fine
+ * because the model authors its own ids, and round 1 reconstructs this one, so
+ * the request 400d deterministically on both the primary and the fallback until
+ * the deterministic join fired. Workers AI never validated the field, which is
+ * why it took a Claude-backed agent to surface it.
+ *
+ * Nothing persists this: both halves of the pair are rebuilt together on every
+ * request, so changing the shape needs no migration. See
+ * {@link file://../agent/anthropic/prompt.ts providerSafeToolCallId} for the
+ * backstop that catches the next one of these.
  */
-function localKeyForId(id) {
-    return `s${id}`;
+export function delegateToolCallId(taskId, round) {
+    return `task_${taskId}_round_${round}_delegate`;
 }
 /**
  * Rebuild one round's call input from its durable rows, in stable ordinal order.
@@ -74,15 +76,18 @@ function localKeyForId(id) {
  * `referenceIndexes` is omitted rather than faked: this round's references were
  * snapshotted verbatim onto the rows when it ran, and the catalog they were
  * chosen from is long gone.
+ *
+ * A subtask proposal carries no identifier of its own, so the model pairs each
+ * entry here with its outcome **by position**: both arrays are built from the
+ * same ordinal-ordered `branches`, and the outcome additionally repeats `type`
+ * and carries the durable `subtaskId`.
  */
 export function delegateCallInput(reply, branches) {
     return {
         reply,
         subtasks: branches.map((branch) => ({
-            localKey: localKeyForId(branch.subtaskId),
             type: branch.type,
             prompt: branch.prompt,
-            dependsOn: branch.dependsOn.map(localKeyForId),
             // Reconstructed verbatim from the row: a later round must see the same
             // params the call really carried, or it cannot reason about what ran.
             params: branch.params
@@ -100,4 +105,3 @@ export function delegateCallOutput(branches) {
             : null
     }));
 }
-//# sourceMappingURL=delegate.js.map

package/dist/subtasks/index.d.ts

@@ -1,11 +1,9 @@
 /**
  * `@loopingai/core/subtasks` — the delegation layer: what a round may hand out,
- * how a proposal becomes durable drafts, and which of them may run next.
+ * and how a proposal becomes durable drafts.
  */
 export { makeSubtaskTypes, SubtaskParamsError, type SubtaskTypeRegistry } from "./subtask-types.js";
 export { DecompositionValidationError, makeDecompositionProposalSchema, nonBlank, resolveDecomposition } from "./decomposition.js";
 export { DELEGATE_TOOL_NAME, makeDelegateTool, delegateToolCallId, delegateCallInput, delegateCallOutput, type DelegateSubtaskOutcome } from "./delegate.js";
-export { selectWave, type WaveDecision } from "./scheduler.js";
 export { isCatalogEligible, type ReferenceCatalogEntry } from "./catalog.js";
 export * from "./types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/subtasks/index.js

@@ -1,11 +1,9 @@
 /**
  * `@loopingai/core/subtasks` — the delegation layer: what a round may hand out,
- * how a proposal becomes durable drafts, and which of them may run next.
+ * and how a proposal becomes durable drafts.
  */
 export { makeSubtaskTypes, SubtaskParamsError } from "./subtask-types.js";
 export { DecompositionValidationError, makeDecompositionProposalSchema, nonBlank, resolveDecomposition } from "./decomposition.js";
 export { DELEGATE_TOOL_NAME, makeDelegateTool, delegateToolCallId, delegateCallInput, delegateCallOutput } from "./delegate.js";
-export { selectWave } from "./scheduler.js";
 export { isCatalogEligible } from "./catalog.js";
 export * from "./types.js";
-//# sourceMappingURL=index.js.map

package/dist/subtasks/subtask-types.d.ts

@@ -78,14 +78,6 @@ export interface SubtaskTypeRegistry {
     paramProperties(): Record<string, z.ZodType<string | undefined>>;
     /** The type catalogue as the delegating model is shown it. */
     renderTypes(): string;
-    /**
-     * Every type's {@link SubtaskTypeSpec.capability}, for the main agent's soul.
-     *
-     * Returns `""` when no type declares one, and that case is worth naming: it is
-     * what lets each call site append unconditionally instead of emitting a
-     * separator around nothing.
-     */
-    renderCapabilities(): string;
     /** Every type's {@link SubtaskTypeSpec.delegationGuidance}, for the round contract. */
     renderDelegationGuidance(names: DelegationNames): string;
 }
@@ -97,4 +89,3 @@ export interface SubtaskTypeRegistry {
  * routed to the wrong domain.
  */
 export declare function makeSubtaskTypes(specs: readonly SubtaskTypeSpec[]): SubtaskTypeRegistry;
-//# sourceMappingURL=subtask-types.d.ts.map

package/dist/subtasks/subtask-types.js

@@ -91,13 +91,6 @@ export function makeSubtaskTypes(specs) {
             })
                 .join("\n");
         },
-        renderCapabilities() {
-            const blocks = [];
-            for (const s of specs)
-                if (s.capability)
-                    blocks.push(s.capability);
-            return blocks.join("\n\n");
-        },
         renderDelegationGuidance(names) {
             const sections = [];
             for (const s of specs) {
@@ -108,4 +101,3 @@ export function makeSubtaskTypes(specs) {
         }
     };
 }
-//# sourceMappingURL=subtask-types.js.map

package/dist/subtasks/types.d.ts

@@ -1,5 +1,6 @@
 import type { ResolvedRecipe, SubtaskParams } from "../contract/recipe.js";
-export type SubtaskStatus = "pending" | "running" | "completed" | "failed" | "skipped" | "canceled";
+import type { RoundFailureKind } from "../agent/inference.js";
+export type SubtaskStatus = "pending" | "running" | "completed" | "failed" | "canceled";
 /** A per-caller, SQLite-assigned, monotonically increasing Subtask identifier. */
 export type SubtaskId = number;
 /**
@@ -22,18 +23,15 @@ export interface SubtaskResultPart {
     text: string;
 }
 /**
- * Creation input for one Subtask, before it is persisted. `dependsOn` uses
- * draft-local keys (not yet-unknown {@link SubtaskId}s); the data layer resolves
- * them to SQLite-assigned ids when the decomposition is created. `ordinal` is
- * derived from the draft's position in the decomposition array.
+ * Creation input for one Subtask, before it is persisted. `ordinal` is derived
+ * from the draft's position in the decomposition array, which is the only thing
+ * that distinguishes one draft of a decomposition from another — they carry no
+ * identity of their own until the data layer assigns a {@link SubtaskId}.
  */
 export interface SubtaskDraft {
-    localKey: string;
     type: string;
     prompt: string;
     references: SubtaskReference[];
-    /** Draft-local keys of prerequisite drafts. */
-    dependsOn: string[];
     /** The type's required inputs, already validated for shape. */
     params: SubtaskParams;
 }
@@ -93,24 +91,11 @@ export interface SubtaskChunkOutcome {
     status: SubtaskStatus;
     progress: ProgressEvent[];
 }
-/**
- * Generated output of one completed prerequisite Subtask, loaded by the parent
- * from its durable row for a dependent's invocation. `type` is the
- * prerequisite's semantic type — used only to label the rendered section;
- * dependency output is always presented as generated, never as conversation
- * evidence.
- */
-export interface DependencyResult {
-    subtaskId: SubtaskId;
-    type: string;
-    resultParts: SubtaskResultPart[];
-}
 /**
  * RPC-safe input for one isolated `RecipeSubagent` execution, assembled by the
  * parent at execution start: the already-resolved (and code-validated) Recipe,
- * the Subtask's non-session prompt, its verbatim reference snapshots, and the
- * generated results of its completed dependencies. The child re-validates the
- * Recipe defensively but never resolves one itself.
+ * the Subtask's non-session prompt, and its verbatim reference snapshots. The
+ * child re-validates the Recipe defensively but never resolves one itself.
  */
 export interface RecipeExecutionRequest {
     taskId: string;
@@ -124,7 +109,6 @@ export interface RecipeExecutionRequest {
     recipe: ResolvedRecipe;
     prompt: string;
     references: SubtaskReference[];
-    dependencyResults: DependencyResult[];
     /**
      * The Subtask's validated params. Part of the execution's identity — two plays
      * of different games are different work — so this IS fingerprinted, unlike
@@ -154,11 +138,9 @@ export type RecipeExecutionResult = {
  * One Subtask as the delegating model emits it. The model selects references
  * by **catalog index only** — it never emits reference text, and application code
  * snapshots the catalog entry's exact role+text onto the Subtask (see
- * `agent/subtasks/decomposition.ts`). `dependsOn` uses draft-local keys, resolved
- * to SQLite-assigned {@link SubtaskId}s by the data layer.
+ * `agent/subtasks/decomposition.ts`).
  */
 export interface SubtaskProposal {
-    localKey: string;
     type: string;
     prompt: string;
     /**
@@ -167,8 +149,6 @@ export interface SubtaskProposal {
      * *reconstructed* historical call, whose references were resolved rounds ago.
      */
     referenceIndexes?: number[];
-    /** Draft-local keys of prerequisite proposals. */
-    dependsOn: string[];
     /** The type's required inputs; omitted for a type that takes none. */
     params?: SubtaskParams;
 }
@@ -188,18 +168,19 @@ export interface DecompositionProposal {
  *
  * `replied` is the terminal answer — the round chose to answer the user rather
  * than delegate, and the Workflow delivers it. `delegated` means the round's
- * Subtask rows are durable and Phase 2 should run them, after which another round
- * begins. `failed` means both models produced unusable output; no Subtask is ever
- * synthesized to cover for it. `canceled` means the caller cancelled during the
- * round: nothing was persisted and nothing was published. Transient platform
- * faults are not results: they throw so the enclosing Workflow step can retry
- * (mirrors {@link RecipeExecutionResult}).
+ * Subtask rows are durable and the Workflow should execute them, after which
+ * another round begins. `failed` means the round produced no answer, with
+ * {@link RoundFailureKind} carrying why; no Subtask is ever synthesized to cover
+ * for it. `canceled` means the caller cancelled during the round: nothing was
+ * persisted and nothing was published. Transient platform faults are not
+ * results: they throw so the enclosing Workflow step can retry (mirrors
+ * {@link RecipeExecutionResult}).
  *
  * `turns` is what this round cost, which the Workflow meters against the Task's
  * budget. This is the **only** type that carries it, and it carries it because the
  * count has to cross an RPC boundary to reach a Workflow in another isolate;
- * everything inside the DO shares one mutable {@link file://../budget.ts TurnBudget}
- * instead. The field is attached in a single place — see `runTaskTurn` — so no
+ * everything inside the DO shares one mutable
+ * {@link file://../agent/budget.ts TurnBudget} instead. The field is attached in a single place — see `runTaskTurn` — so no
  * branch can drop it and no branch can invent it.
  *
  * The idempotent recovery paths — a round replayed from durable rows rather than
@@ -220,8 +201,17 @@ export type TurnTaskResult = {
     reply: string;
     subtasks: Subtask[];
     turns: number;
-} | {
+}
+/**
+ * `kind` distinguishes a round that spent both models and got nothing usable
+ * (`exhausted`) from one that stopped on a fault no attempt could clear —
+ * where the fallback was deliberately *not* tried, and the kind is what lets
+ * the host say why in words an operator can act on. Same terminal Task either
+ * way; only the words differ.
+ */
+ | {
     status: "failed";
+    kind: RoundFailureKind;
     error: string;
     turns: number;
 } | {
@@ -243,15 +233,13 @@ export type TurnVerdict = WithoutTurns<TurnTaskResult>;
 /**
  * One branch's outcome as a later round sees it — a plain, RPC-safe subset of the
  * durable {@link Subtask} row, loaded across **every** round in stable ordinal
- * order. Completed, failed, and skipped branches are all included so the reply
- * can use available successes and disclose relevant failures.
+ * order. Completed and failed branches are both included so the reply can use
+ * available successes and disclose relevant failures.
  *
- * Carries `round`, `prompt` and `dependsOn` — not for composing, but for
- * reconstructing the per-round `delegate` call that produced these branches (see
- * `agent/subtasks/delegate.ts`). Unlike {@link SubtaskNode}, this projection is
- * built inside the DO and returns only a reply, so the 1 MiB Workflow-step cap
- * that keeps the scheduler's view narrow does not apply. `references` still stays
- * out: it is unbounded history text, and the call's shape does not need it.
+ * Carries `round` and `prompt` — not for composing, but for reconstructing the
+ * per-round `delegate` call that produced these branches (see
+ * `agent/subtasks/delegate.ts`). `references` stays out: it is unbounded history
+ * text, and the call's shape does not need it.
  */
 export interface CompositionBranch {
     subtaskId: SubtaskId;
@@ -259,41 +247,29 @@ export interface CompositionBranch {
     ordinal: number;
     type: string;
     prompt: string;
-    dependsOn: SubtaskId[];
     params: SubtaskParams;
     status: SubtaskStatus;
     resultParts: SubtaskResultPart[] | null;
     error: string | null;
 }
 /**
- * The `scan:<n>` wave projection (RPC-safe): either the caller cancelled, or the
- * refreshed DAG after blocked branches were skipped. Returning the verdict with
- * the nodes is what lets the Workflow drop its separate cancellation probe — one
- * round trip, and no gap between asking and acting.
+ * The `scan:<round>` projection (RPC-safe): either the caller cancelled, or the
+ * ids of the round's Subtasks that still owe an outcome, in ordinal order.
+ * Returning the verdict with the ids is what lets the Workflow drop its separate
+ * cancellation probe — one round trip, and no gap between asking and acting.
+ *
+ * Ids and nothing else, deliberately: a Workflow step return is capped at 1 MiB
+ * and a Subtask carries verbatim history snapshots bounded only by
+ * `MAX_INBOUND_TEXT_BYTES`, so a scan returning rows would overflow on a large
+ * task. The durable rows are the source of truth; the Workflow carries
+ * references to them and re-reads through the parent when it needs more.
  */
 export type SubtaskScan = {
     canceled: true;
 } | {
     canceled: false;
-    nodes: SubtaskNode[];
+    ids: SubtaskId[];
 };
-/**
- * The scheduler's view of one Subtask (Phase 2) — everything needed to pick the
- * next dependency-ready wave, and nothing else.
- *
- * Deliberately excludes `prompt`, `references`, and `resultParts`: a Workflow
- * step return is capped at 1 MiB, and a reference is a verbatim history snapshot
- * bounded only by `MAX_INBOUND_TEXT_BYTES`, so a wave scan returning full rows
- * would overflow on a large task. The durable rows — not Workflow state — are the
- * source of truth, so the Workflow carries ids and statuses and re-reads the rest
- * through the parent when it actually needs it.
- */
-export interface SubtaskNode {
-    id: SubtaskId;
-    ordinal: number;
-    status: SubtaskStatus;
-    dependsOn: SubtaskId[];
-}
 /** Durable state owned by the main agent for one delegated unit of work. */
 export interface Subtask {
     id: SubtaskId;
@@ -307,7 +283,6 @@ export interface Subtask {
     recipeVersion: number | null;
     prompt: string;
     references: SubtaskReference[];
-    dependsOn: SubtaskId[];
     /** The type's required inputs, validated at delegation time. */
     params: SubtaskParams;
     status: SubtaskStatus;
@@ -318,4 +293,3 @@ export interface Subtask {
     completedAt: number | null;
 }
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/subtasks/types.js

@@ -13,4 +13,3 @@
 export function runtimeAs(runtime) {
     return runtime;
 }
-//# sourceMappingURL=types.js.map

package/dist/testing/auth.d.ts

@@ -32,4 +32,3 @@ export interface GatewayTokenOptions {
 export declare const TEST_TENANT = "main";
 /** Sign a short-lived EdDSA gateway JWT using the test gateway key. */
 export declare function makeGatewayToken(options?: GatewayTokenOptions): Promise<string>;
-//# sourceMappingURL=auth.d.ts.map

package/dist/testing/auth.js

@@ -33,4 +33,3 @@ export async function makeGatewayToken(options = {}) {
         .setExpirationTime(options.expiresIn ?? "5m")
         .sign(privateKey));
 }
-//# sourceMappingURL=auth.js.map

package/dist/testing/do.d.ts

@@ -27,4 +27,3 @@ export declare function doStorage(instance: unknown): DurableObjectStorage;
  * ```
  */
 export declare function makeDoHelpers(ns: DurableObjectNamespace, defaults?: AgentDBOptions): DoTestHelpers;
-//# sourceMappingURL=do.d.ts.map

package/dist/testing/do.js

@@ -23,4 +23,3 @@ export function makeDoHelpers(ns, defaults = { maxSubtasks: 8 }) {
         }
     };
 }
-//# sourceMappingURL=do.js.map

package/dist/testing/fake-session.d.ts

@@ -24,4 +24,3 @@ export declare class FakeSession implements SessionLike {
     tools(): Promise<ToolSet>;
     getCompactions(): Promise<unknown[]>;
 }
-//# sourceMappingURL=fake-session.d.ts.map

package/dist/testing/fake-session.js

@@ -35,4 +35,3 @@ export class FakeSession {
         return this.compactions;
     }
 }
-//# sourceMappingURL=fake-session.js.map

package/dist/testing/fixtures.d.ts

@@ -62,4 +62,3 @@ export declare function testStatus(state: TaskState, message?: Message): NonNull
 export declare function testAgentMessage(messageId: string, text: string, contextId?: string, taskId?: string): Message;
 /** A complete v1.0 `Task` in the given state. */
 export declare function testTask(id: string, contextId: string, state: TaskState, message?: Message): Task;
-//# sourceMappingURL=fixtures.d.ts.map

package/dist/testing/fixtures.js

@@ -102,4 +102,3 @@ export function testTask(id, contextId, state, message) {
         metadata: undefined
     };
 }
-//# sourceMappingURL=fixtures.js.map

package/dist/testing/harness.d.ts

@@ -95,4 +95,3 @@ export interface AgentHarness {
     readonly callbacks: CapturedCallback[];
 }
 export declare function createAgentHarness<TEnv>(options: AgentHarnessOptions<TEnv>): AgentHarness;
-//# sourceMappingURL=harness.d.ts.map

package/dist/testing/harness.js

@@ -136,4 +136,3 @@ export function createAgentHarness(options) {
         }
     };
 }
-//# sourceMappingURL=harness.js.map

package/dist/testing/index.d.ts

@@ -29,4 +29,3 @@ export { makeGatewayToken, type GatewayTokenOptions } from "./auth.js";
 export { AGENT_ORIGIN, GATEWAY_ORIGIN, TEST_AGENT_PRIVATE_JWK, TEST_GATEWAY_PRIVATE_JWK, TEST_MODELS, gatewayPublicJwks, testAgentMessage, testStatus, testTask } from "./fixtures.js";
 export { doStorage, makeDoHelpers, type DoTestHelpers } from "./do.js";
 export { createAgentHarness, type AgentHarness, type AgentHarnessOptions, type CapturedCallback, type HarnessWorker } from "./harness.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.js

@@ -29,4 +29,3 @@ export { makeGatewayToken } from "./auth.js";
 export { AGENT_ORIGIN, GATEWAY_ORIGIN, TEST_AGENT_PRIVATE_JWK, TEST_GATEWAY_PRIVATE_JWK, TEST_MODELS, gatewayPublicJwks, testAgentMessage, testStatus, testTask } from "./fixtures.js";
 export { doStorage, makeDoHelpers } from "./do.js";
 export { createAgentHarness } from "./harness.js";
-//# sourceMappingURL=index.js.map

package/dist/testing/mock-model.d.ts

@@ -40,4 +40,38 @@ export declare function finalReply(text: string, opts?: {
  * last step.
  */
 export declare function mockModel(...steps: MockStep[]): MockLanguageModelV3;
-//# sourceMappingURL=mock-model.d.ts.map
+/**
+ * A model whose every call throws, and a count of how many times it was asked.
+ *
+ * The count is the point. Several of the attempt ladder's rules are about a call
+ * that must *not* happen — a fallback slot left unspent, a repair not attempted
+ * — and those are invisible to an assertion on the returned outcome alone, which
+ * can be right for the wrong reason.
+ */
+export declare function throwingModel(error: unknown): {
+    model: MockLanguageModelV3;
+    calls: () => number;
+};
+/** {@link mockModel}, plus the same call count {@link throwingModel} reports. */
+export declare function countingModel(...steps: MockStep[]): {
+    model: MockLanguageModelV3;
+    calls: () => number;
+};
+/**
+ * A model that fails the first `failures` calls with a retryable `APICallError`,
+ * then behaves like {@link mockModel}.
+ *
+ * Exists for the one behaviour a scripted-outcome assertion cannot see: whether
+ * a rate limit was *waited out on the same model* or fell straight through to
+ * the fallback. Only the call count distinguishes them — both produce a
+ * successful round.
+ *
+ * `retry-after: 0` is deliberate. The AI SDK honours the header and its own
+ * backoff opens at two seconds, which would spend real seconds asserting
+ * something that has nothing to do with duration. Zero exercises the identical
+ * path — header parsed, preferred over the exponential delay, waited — for free.
+ */
+export declare function rateLimitedModel(failures: number, ...steps: MockStep[]): {
+    model: MockLanguageModelV3;
+    calls: () => number;
+};

package/dist/testing/mock-model.js

@@ -1,4 +1,9 @@
 import { MockLanguageModelV3 } from "ai/test";
+// From `ai`, not `@ai-sdk/provider`. `ai` re-exports the class and is a declared
+// peer; reaching for the provider package directly makes this module — which is
+// on the published `/testing` subpath every consumer loads — depend on a package
+// core does not declare and only resolves today by hoisting.
+import { APICallError } from "ai";
 /**
  * Test doubles for the LLM. Lets the tool-loop / executor specs run the real
  * `generateText` machinery (tool execution, multi-step, fallback) against a
@@ -59,4 +64,73 @@ export function mockModel(...steps) {
         doGenerate: async () => stepResult(steps[Math.min(i++, steps.length - 1)])
     });
 }
-//# sourceMappingURL=mock-model.js.map
+/**
+ * A model whose every call throws, and a count of how many times it was asked.
+ *
+ * The count is the point. Several of the attempt ladder's rules are about a call
+ * that must *not* happen — a fallback slot left unspent, a repair not attempted
+ * — and those are invisible to an assertion on the returned outcome alone, which
+ * can be right for the wrong reason.
+ */
+export function throwingModel(error) {
+    let calls = 0;
+    return {
+        model: new MockLanguageModelV3({
+            doGenerate: async () => {
+                calls += 1;
+                throw error;
+            }
+        }),
+        calls: () => calls
+    };
+}
+/** {@link mockModel}, plus the same call count {@link throwingModel} reports. */
+export function countingModel(...steps) {
+    let calls = 0;
+    let i = 0;
+    return {
+        model: new MockLanguageModelV3({
+            doGenerate: async () => {
+                calls += 1;
+                return stepResult(steps[Math.min(i++, steps.length - 1)]);
+            }
+        }),
+        calls: () => calls
+    };
+}
+/**
+ * A model that fails the first `failures` calls with a retryable `APICallError`,
+ * then behaves like {@link mockModel}.
+ *
+ * Exists for the one behaviour a scripted-outcome assertion cannot see: whether
+ * a rate limit was *waited out on the same model* or fell straight through to
+ * the fallback. Only the call count distinguishes them — both produce a
+ * successful round.
+ *
+ * `retry-after: 0` is deliberate. The AI SDK honours the header and its own
+ * backoff opens at two seconds, which would spend real seconds asserting
+ * something that has nothing to do with duration. Zero exercises the identical
+ * path — header parsed, preferred over the exponential delay, waited — for free.
+ */
+export function rateLimitedModel(failures, ...steps) {
+    let calls = 0;
+    let i = 0;
+    return {
+        model: new MockLanguageModelV3({
+            doGenerate: async () => {
+                calls += 1;
+                if (calls <= failures) {
+                    throw new APICallError({
+                        message: "429 Wholesale Rate limited",
+                        url: "anthropic:messages:test",
+                        requestBodyValues: {},
+                        statusCode: 429,
+                        responseHeaders: { "retry-after": "0" }
+                    });
+                }
+                return stepResult(steps[Math.min(i++, steps.length - 1)]);
+            }
+        }),
+        calls: () => calls
+    };
+}

package/dist/testing/node.d.ts

@@ -54,4 +54,3 @@
 export { createVcr, recordFromEnv, closeVcr, type Vcr, type VcrOptions, type VcrRequest, type VcrRequestHeaders, type VcrOutboundService } from "./vcr.js";
 export { Cassette, requestKey, replayable, type CassetteEntry, type CassetteOptions, type RecordedRequest, type RecordedResponse, type ReplayableResponse } from "./vcr-store.js";
 export { VCR_CONTROL_ORIGIN, VCR_MARKER_HEADER, CASSETTE_NAME_RE, type VcrReleaseResult } from "./vcr-shared.js";
-//# sourceMappingURL=node.d.ts.map

package/dist/testing/node.js

@@ -54,4 +54,3 @@
 export { createVcr, recordFromEnv, closeVcr } from "./vcr.js";
 export { Cassette, requestKey, replayable } from "./vcr-store.js";
 export { VCR_CONTROL_ORIGIN, VCR_MARKER_HEADER, CASSETTE_NAME_RE } from "./vcr-shared.js";
-//# sourceMappingURL=node.js.map

package/dist/testing/vcr-global-setup.d.ts

@@ -6,10 +6,7 @@
  * Belt and braces rather than load-bearing — each cassette is already flushed
  * when its test releases it, so a run that ends normally has nothing left to do
  * here, and a run that dies mid-test keeps everything recorded up to that point.
- * (Under the old undici recorder this step was mandatory: it held real sockets
- * and a self-refreshing auto-flush timer open, and a `RECORD=1` run hung on
- * "close timed out" without it. Neither exists now.)
+ * The recorder holds no sockets and no timers, so nothing here has to close.
  */
 export declare function setup(): void;
 export declare function teardown(): Promise<void>;
-//# sourceMappingURL=vcr-global-setup.d.ts.map

package/dist/testing/vcr-global-setup.js

@@ -7,12 +7,9 @@ import { closeVcr } from "./vcr.js";
  * Belt and braces rather than load-bearing — each cassette is already flushed
  * when its test releases it, so a run that ends normally has nothing left to do
  * here, and a run that dies mid-test keeps everything recorded up to that point.
- * (Under the old undici recorder this step was mandatory: it held real sockets
- * and a self-refreshing auto-flush timer open, and a `RECORD=1` run hung on
- * "close timed out" without it. Neither exists now.)
+ * The recorder holds no sockets and no timers, so nothing here has to close.
  */
 export function setup() { }
 export async function teardown() {
     await closeVcr();
 }
-//# sourceMappingURL=vcr-global-setup.js.map