@loopingai/core 0.7.0 → 0.8.0

package/dist/host/agent.js

@@ -5,6 +5,7 @@ import { resolveConfig } from "../config.js";
 import { AgentDB, stateOf } from "../db/index.js";
 import { callerContext } from "../a2a/caller.js";
 import { createPushChannel } from "../a2a/push.js";
+import { SelfOrigin } from "../a2a/self-origin.js";
 import { buildAgentSession } from "../agent/session.js";
 import { workersAIModels } from "../agent/workers-ai/index.js";
 /**
@@ -64,6 +65,17 @@ export class LoopingAgent extends Agent {
      * not depend on it surviving.
      */
     identityKey;
+    /**
+     * This deployment's own public origin, learned from the `jku` every turn
+     * carries and **pinned on the first one** this instance serves.
+     *
+     * Unlike {@link identityKey} this is shared by concurrent turns — the object
+     * is keyed by caller, not by origin — so it is pinned rather than
+     * last-write-wins: an immutable field cannot change under a credential thunk
+     * that reads it while a turn awaits a model call. See {@link SelfOrigin} for
+     * the full argument, and for why nothing is persisted.
+     */
+    selfOriginMemo = new SelfOrigin();
     /**
      * Test-only model injection. A **field**, not a constructor argument or an RPC
      * parameter, so it never appears on the generated DO stub: production callers
@@ -113,12 +125,11 @@ export class LoopingAgent extends Agent {
      * a trap that only shows up as a performance bug. This is called once.
      *
      * `ModelRuntime` is the whole contract: return anything satisfying it and
-     * every loop in core keeps working unchanged. Core ships two implementations,
-     * one directory each — {@link file://../agent/workers-ai/index.ts
-     * `agent/workers-ai`} (the default below) and `@loopingai/core/anthropic` —
-     * and a third provider is a third directory exporting one
-     * {@link file://../agent/model.ts ModelRuntimeFactory}, not a change to
-     * anything on this path.
+     * every loop in core keeps working unchanged. Core ships one implementation,
+     * {@link file://../agent/workers-ai/index.ts `agent/workers-ai`} (the default
+     * below); a second provider is one more
+     * {@link file://../agent/model.ts ModelRuntimeFactory}, defined here or in the
+     * consumer, not a change to anything on this path.
      *
      * Takes the resolved {@link ModelConfig} rather than reading `this.config`, so
      * that this signature matches
@@ -254,8 +265,40 @@ export class LoopingAgent extends Agent {
         }
         return (this.identityKey = key);
     }
+    /**
+     * Offer this deployment's own origin from a value that carries it. The first
+     * usable one is kept for the life of the instance.
+     *
+     * Called wherever a {@link TurnPushContext} arrives — here for every agent
+     * shape, and at the entry of `RoundAgentBase`'s two RPCs, where the origin is
+     * needed *before* this channel would be built. All three matter because any of
+     * them can be the call that wakes a fresh isolate. Cheap and unfailing: past
+     * the first turn it is one truthiness check, and an unusable value is ignored
+     * rather than thrown, because a turn must not fail over this.
+     */
+    noteSelfOrigin(url) {
+        this.selfOriginMemo.note(url);
+    }
+    /**
+     * This deployment's own public origin, if a turn has carried it to this
+     * instance yet. Constant once set, so it reads the same from any turn running
+     * on this object. See {@link SelfOrigin}.
+     */
+    selfOrigin() {
+        return this.selfOriginMemo.peek();
+    }
+    /**
+     * The same, for a caller that cannot proceed without it — signing a caller
+     * token with {@link file://../a2a/caller-token.ts signCallerToken} above all,
+     * whose `iss` this is. Throws naming the timing rather than producing a token
+     * with a nonsense issuer.
+     */
+    requireSelfOrigin() {
+        return this.selfOriginMemo.require();
+    }
     /** The gateway callback channel for one turn. See {@link PushChannel}. */
     push(context) {
+        this.noteSelfOrigin(context.jku);
         return createPushChannel(this.env.A2A_SIGNING_KEY, context);
     }
     /**

package/dist/round/agent.js

@@ -83,6 +83,9 @@ export class RoundAgentBase extends LoopingAgent {
      * number, and none can report the wrong one.
      */
     async runTaskTurn(input) {
+        // Before anything can reach a model: a round that calls out mint-signed
+        // needs this deployment's own origin, and this is where it arrives.
+        this.noteSelfOrigin(input.push?.jku);
         const budget = newTurnBudget(input.turnsRemaining);
         const verdict = await this.decideRound(input, budget);
         return { ...verdict, turns: budget.spent };
@@ -300,6 +303,10 @@ export class RoundAgentBase extends LoopingAgent {
      * not outcomes.
      */
     async executeSubtaskChunk(id, chunk, push) {
+        // Recorded here rather than left to `this.push(push)` below, which runs only
+        // after the chunk has already executed — and the child is handed this
+        // origin on the way in.
+        this.noteSelfOrigin(push?.jku);
         const prepared = await this.prepareChunk(id);
         if (prepared.kind === "terminal") {
             return { done: true, status: prepared.subtask.status, progress: [] };
@@ -482,9 +489,18 @@ export class RoundAgentBase extends LoopingAgent {
      * a second mismatch is a genuine lifecycle bug and must surface).
      */
     async executeChunkInChild(name, request, chunk, runtime) {
+        // A facet has no request path of its own: it is reached only from here, so
+        // this is the only way it can learn what this deployment is called. Passed
+        // as its own argument, never folded into `request`, for the same reason
+        // `chunk` is — the request is fingerprinted, and this is not part of what
+        // the execution *is*, so it must not be able to make a retry look like a
+        // different one. Pinned on both sides, so it cannot change under a run;
+        // undefined only on an instance no turn has reached, where the facet's own
+        // `requireSelfOrigin` produces the readable error.
+        const selfOrigin = this.selfOrigin();
         const child = await this.subAgent(this.subagentClass(), name);
         try {
-            return await child.executeChunk(request, chunk, runtime);
+            return await child.executeChunk(request, chunk, runtime, selfOrigin);
         }
         catch (err) {
             if (!String(err).includes(FINGERPRINT_MISMATCH))
@@ -492,7 +508,7 @@ export class RoundAgentBase extends LoopingAgent {
             console.warn("[agent] stale subagent state, recreating", { name });
             await this.deleteSubAgent(this.subagentClass(), name);
             const fresh = await this.subAgent(this.subagentClass(), name);
-            return await fresh.executeChunk(request, chunk, runtime);
+            return await fresh.executeChunk(request, chunk, runtime, selfOrigin);
         }
     }
     /** Let the owning plugin release whatever `resolveRuntime` acquired. */

package/dist/round/subagent.d.ts

@@ -59,14 +59,17 @@ export declare abstract class RecipeSubagentHost<TEnv extends Cloudflare.Env & A
      * 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.
+     * its parent runs on another provider 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.
+     * it. Two hand-copied runtime-construction bodies is what this shape exists to
+     * stop, because nothing type-checks their agreement.
+     *
+     * Note the cheapest way to satisfy this is to override *neither* seam, which
+     * is what an agent on core's default does.
      *
      * Takes the model config rather than reading `this.config`, because the facet
      * resolves its config inside `buildRuntime` and this is called from there.

package/dist/round/subagent.js

@@ -54,14 +54,17 @@ export class RecipeSubagentHost extends RecipeSubagentBase {
      * 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.
+     * its parent runs on another provider 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.
+     * it. Two hand-copied runtime-construction bodies is what this shape exists to
+     * stop, because nothing type-checks their agreement.
+     *
+     * Note the cheapest way to satisfy this is to override *neither* seam, which
+     * is what an agent on core's default does.
      *
      * Takes the model config rather than reading `this.config`, because the facet
      * resolves its config inside `buildRuntime` and this is called from there.

package/dist/subagent/index.d.ts

@@ -102,6 +102,14 @@ export declare abstract class RecipeSubagentBase<TEnv extends Cloudflare.Env = C
      * to interrupt. See {@link abortRun}.
      */
     private inflight?;
+    /**
+     * This deployment's own public origin, as the parent DO passes it on every
+     * chunk, pinned from the first. In memory for the same reason {@link inflight}
+     * is: a facet is reached only through {@link executeChunk}, so an instance that
+     * lost it is an instance that will be told again before it can run anything.
+     * See {@link SelfOrigin}.
+     */
+    private readonly selfOriginMemo;
     onStart(): Promise<void>;
     /**
      * Idempotent schema bootstrap. Also called lazily from the RPCs so
@@ -111,17 +119,30 @@ export declare abstract class RecipeSubagentBase<TEnv extends Cloudflare.Env = C
     private ensureTables;
     /** The recipe's durable workspace, backed by this facet's own SQLite storage. */
     private workspace;
+    /**
+     * This deployment's own public origin, if the parent has passed it to this
+     * instance yet. See {@link SelfOrigin}.
+     */
+    protected selfOrigin(): string | undefined;
+    /**
+     * The same, for a caller that cannot proceed without it — a facet that signs
+     * its own caller tokens, above all. Mirrors `LoopingAgent.requireSelfOrigin`,
+     * because a facet must run on the same provider, and so the same credential
+     * path, as the parent that delegated to it.
+     */
+    protected requireSelfOrigin(): string;
     /**
      * Execute one durable chunk of a Subtask under the parent's resolved Recipe.
      *
      * A terminal outcome (completed / failed) is cached and replayed on retry. A
      * mid-run chunk persists its rolling state to `run_state` and returns a
-     * `done: false` yield for the Workflow to run another chunk. `chunk` is a
-     * separate argument — never part of `request` — so every chunk fingerprints
-     * identically and the cache/resume keys line up. Only transient platform faults
-     * throw (nothing cached), so a Workflow retry resumes from the last checkpoint.
+     * `done: false` yield for the Workflow to run another chunk. `chunk` and
+     * `selfOrigin` are separate arguments — never part of `request` — so every
+     * chunk fingerprints identically and the cache/resume keys line up. Only
+     * transient platform faults throw (nothing cached), so a Workflow retry
+     * resumes from the last checkpoint.
      */
-    executeChunk(request: RecipeExecutionRequest, _chunk: number, runtime?: SubtaskRuntime): Promise<RecipeChunkResult>;
+    executeChunk(request: RecipeExecutionRequest, _chunk: number, runtime?: SubtaskRuntime, selfOrigin?: string): Promise<RecipeChunkResult>;
     /**
      * Interrupt the chunk running here right now, so a cancellation lands on the
      * current model call instead of at the next chunk boundary (up to `chunkSoftMs`

package/dist/subagent/index.js

@@ -4,6 +4,7 @@ import { CHUNK_SOFT_MS } from "../platform.js";
 import { buildRecipeTools } from "../runtime/tool-families.js";
 import { RecipeValidationError, validateRecipe } from "../contract/validation.js";
 import { SubtaskParamsError } from "../subtasks/subtask-types.js";
+import { SelfOrigin } from "../a2a/self-origin.js";
 import { renderSubagentPrompt } from "./prompt.js";
 import { makeWorkspaceHandle } from "./workspace.js";
 import { fingerprintRequest } from "./fingerprint.js";
@@ -77,6 +78,14 @@ export class RecipeSubagentBase extends Agent {
      * to interrupt. See {@link abortRun}.
      */
     inflight;
+    /**
+     * This deployment's own public origin, as the parent DO passes it on every
+     * chunk, pinned from the first. In memory for the same reason {@link inflight}
+     * is: a facet is reached only through {@link executeChunk}, so an instance that
+     * lost it is an instance that will be told again before it can run anything.
+     * See {@link SelfOrigin}.
+     */
+    selfOriginMemo = new SelfOrigin();
     async onStart() {
         this.ensureTables();
     }
@@ -107,18 +116,39 @@ export class RecipeSubagentBase extends Agent {
     workspace() {
         return (this._workspace ??= this.subagentRuntime().workspaceBacking(this.ctx.storage.sql, () => this.name));
     }
+    /**
+     * This deployment's own public origin, if the parent has passed it to this
+     * instance yet. See {@link SelfOrigin}.
+     */
+    selfOrigin() {
+        return this.selfOriginMemo.peek();
+    }
+    /**
+     * The same, for a caller that cannot proceed without it — a facet that signs
+     * its own caller tokens, above all. Mirrors `LoopingAgent.requireSelfOrigin`,
+     * because a facet must run on the same provider, and so the same credential
+     * path, as the parent that delegated to it.
+     */
+    requireSelfOrigin() {
+        return this.selfOriginMemo.require();
+    }
     /**
      * Execute one durable chunk of a Subtask under the parent's resolved Recipe.
      *
      * A terminal outcome (completed / failed) is cached and replayed on retry. A
      * mid-run chunk persists its rolling state to `run_state` and returns a
-     * `done: false` yield for the Workflow to run another chunk. `chunk` is a
-     * separate argument — never part of `request` — so every chunk fingerprints
-     * identically and the cache/resume keys line up. Only transient platform faults
-     * throw (nothing cached), so a Workflow retry resumes from the last checkpoint.
+     * `done: false` yield for the Workflow to run another chunk. `chunk` and
+     * `selfOrigin` are separate arguments — never part of `request` — so every
+     * chunk fingerprints identically and the cache/resume keys line up. Only
+     * transient platform faults throw (nothing cached), so a Workflow retry
+     * resumes from the last checkpoint.
      */
-    async executeChunk(request, _chunk, runtime = {}) {
+    async executeChunk(request, _chunk, runtime = {}, selfOrigin) {
         this.ensureTables();
+        // Before `subagentRuntime()`, which is where a host builds its model runtime
+        // — and a facet running on a provider it authenticates to mint-signed reads
+        // this origin from there.
+        this.selfOriginMemo.note(selfOrigin);
         const rt = this.subagentRuntime();
         const fingerprint = await fingerprintRequest(request);
         // A terminal result already exists → replay it (idempotent retry).

package/dist/subtasks/delegate.d.ts

@@ -54,9 +54,10 @@ export declare function makeDelegateTool(types: SubtaskTypeRegistry, maxSubtasks
  * 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.
+ * request, so changing the shape needs no migration. There is no longer a
+ * provider-side backstop in core — the adapter that carried one went with
+ * `./anthropic` in 0.8.0 — so a provider added here that validates tool-call ids
+ * needs to sanitize them on its own way out.
  */
 export declare function delegateToolCallId(taskId: string, round: number): string;
 /**

package/dist/subtasks/delegate.js

@@ -60,9 +60,10 @@ export function makeDelegateTool(types, maxSubtasks) {
  * 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.
+ * request, so changing the shape needs no migration. There is no longer a
+ * provider-side backstop in core — the adapter that carried one went with
+ * `./anthropic` in 0.8.0 — so a provider added here that validates tool-call ids
+ * needs to sanitize them on its own way out.
  */
 export function delegateToolCallId(taskId, round) {
     return `task_${taskId}_round_${round}_delegate`;

package/dist/testing/mock-model.js

@@ -122,7 +122,7 @@ export function rateLimitedModel(failures, ...steps) {
                 if (calls <= failures) {
                     throw new APICallError({
                         message: "429 Wholesale Rate limited",
-                        url: "anthropic:messages:test",
+                        url: "mock:chat:test",
                         requestBodyValues: {},
                         statusCode: 429,
                         responseHeaders: { "retry-after": "0" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loopingai/core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Shared, mandatory foundation for Looping agents on Cloudflare Workers: zero-trust A2A, durable task lifecycle, delegation and subagent runtime, test harness.",
   "keywords": [
     "a2a",
@@ -94,10 +94,6 @@
       "import": "./dist/testing/vcr-global-setup.js"
     },
     "./eslint": "./eslint-rules/index.js",
-    "./anthropic": {
-      "types": "./dist/agent/anthropic/index.d.ts",
-      "import": "./dist/agent/anthropic/index.js"
-    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -123,8 +119,6 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@ai-sdk/provider": "^4.0.0",
-    "@anthropic-ai/sdk": "^0.116.0",
     "@cloudflare/vitest-pool-workers": ">=0.18",
     "@typescript-eslint/utils": ">=8",
     "agents": "^0.20.0",
@@ -133,12 +127,6 @@
     "workers-ai-provider": "^4.0.0"
   },
   "peerDependenciesMeta": {
-    "@ai-sdk/provider": {
-      "optional": true
-    },
-    "@anthropic-ai/sdk": {
-      "optional": true
-    },
     "@cloudflare/vitest-pool-workers": {
       "optional": true
     },
@@ -150,8 +138,6 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/provider": "^4.0.0",
-    "@anthropic-ai/sdk": "^0.116.0",
     "@cloudflare/vitest-pool-workers": "^0.20.1",
     "@types/node": "^26.1.1",
     "agents": "^0.20.0",

package/scripts/generate-keys.mjs

@@ -7,7 +7,7 @@
  * registration (Trust-On-First-Use). No secret is shared in either direction —
  * see `src/a2a/verify.ts` for the other half of the contract.
  *
- *   node scripts/generate-keys.mjs              # print both halves
+ *   node scripts/generate-keys.mjs              # print the private JWK
  *   node scripts/generate-keys.mjs --kid my-key # choose the key id
  *
  * The `kid` is required, not decorative: it goes in the JWS protected header and
@@ -24,30 +24,25 @@ const kid =
     ? args[kidFlag + 1]
     : `a2a-${new Date().toISOString().slice(0, 10)}`;
 
-// `extractable` is required to export the private half at all.
-const { privateKey, publicKey } = await generateKeyPair("EdDSA", {
+// `extractable` is required to export the private half at all. Only the
+// private half is printed: the public one is derived from it at runtime and
+// served at the JWKS route, so there is nothing to copy anywhere.
+const { privateKey } = await generateKeyPair("EdDSA", {
   crv: "Ed25519",
   extractable: true
 });
 
 const priv = { ...(await exportJWK(privateKey)), kid };
-const pub = { ...(await exportJWK(publicKey)), kid, use: "sig", alg: "EdDSA" };
 
-console.log("A2A_SIGNING_KEY (private — set as a secret, never commit):\n");
-console.log(JSON.stringify(priv));
+console.log(`\nGenerated Ed25519 keypair (kid: ${kid})\n`);
 console.log(
-  "\nPublic JWKS (served at the card's `jku`, derived at runtime):\n"
+  "Add this line to .env — it is the private half, never commit it:\n"
+);
+console.log(`A2A_SIGNING_KEY=${JSON.stringify(priv)}\n`);
+console.log(
+  "To deploy it, push the whole file or just this one secret:\n\n" +
+    "  npx wrangler deploy --secrets-file .env\n" +
+    "  npx wrangler secret put A2A_SIGNING_KEY\n\n" +
+    "The public half is not configured anywhere — the Worker derives it from\n" +
+    "the private key and serves it at the JWKS route.\n"
 );
-console.log(JSON.stringify({ keys: [pub] }, null, 2));
-console.log(`
-Next:
-
-  # local
-  echo 'A2A_SIGNING_KEY=<the private JSON above>' >> .dev.vars
-
-  # deployed
-  npx wrangler secret put A2A_SIGNING_KEY
-
-The public half is not configured anywhere — the Worker derives it from the
-private key and serves it at the JWKS route.
-`);

package/dist/agent/anthropic/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * `@loopingai/core/anthropic` — Claude as a second model provider.
- *
- * Its own subpath, and an **optional** peer dependency on `@anthropic-ai/sdk`,
- * for the same reason `/round` is not re-exported from the root barrel: an agent
- * that runs on Workers AI should not pay — in install size, in bundle bytes, or
- * in a dependency it must keep current — for a provider it never calls.
- *
- * What lives here is a provider, not a capability. It ships no tools, no prompt
- * copy and no policy; it satisfies {@link ModelRuntime} and stops.
- */
-export { CredentialRejectedError, type CredentialRejectedBy } from "../errors.js";
-export { createAnthropicLanguageModel, type AnthropicModelDeps } from "./language-model.js";
-export { createAnthropicModelRuntime, type AnthropicRuntimeDeps } from "./runtime.js";
-export { ANTHROPIC_PROVIDER, type CacheTtl } from "./prompt.js";

package/dist/agent/anthropic/index.js

@@ -1,19 +0,0 @@
-/**
- * `@loopingai/core/anthropic` — Claude as a second model provider.
- *
- * Its own subpath, and an **optional** peer dependency on `@anthropic-ai/sdk`,
- * for the same reason `/round` is not re-exported from the root barrel: an agent
- * that runs on Workers AI should not pay — in install size, in bundle bytes, or
- * in a dependency it must keep current — for a provider it never calls.
- *
- * What lives here is a provider, not a capability. It ships no tools, no prompt
- * copy and no policy; it satisfies {@link ModelRuntime} and stops.
- */
-// Re-exported, not owned: a rejected credential is a fact about the path to a
-// model, not about Anthropic, so the error lives with the rest of the provider
-// contract in {@link file://../errors.ts}. An agent that only imports this
-// subpath still gets it from one place.
-export { CredentialRejectedError } from "../errors.js";
-export { createAnthropicLanguageModel } from "./language-model.js";
-export { createAnthropicModelRuntime } from "./runtime.js";
-export { ANTHROPIC_PROVIDER } from "./prompt.js";

package/dist/agent/anthropic/language-model.d.ts

@@ -1,59 +0,0 @@
-import type Anthropic from "@anthropic-ai/sdk";
-import type { LanguageModelV4 } from "@ai-sdk/provider";
-import { type CredentialRejectedBy } from "../errors.js";
-import { type CacheTtl } from "./prompt.js";
-/**
- * A `LanguageModelV4` over `@anthropic-ai/sdk`, so core's loops can call Claude
- * without knowing they are.
- *
- * Every loop in core is written against `generateText` from `ai` and a
- * `LanguageModel` — {@link file://../../round/turn.ts turn.ts},
- * {@link file://../../subagent/run.ts run.ts} and
- * {@link file://../session.ts session.ts}. Satisfying that interface is what
- * keeps the round loop, the control-tool repair ladder, subtask execution and
- * the Workflow untouched by a second provider. The alternative — a bespoke
- * Messages-API loop for one agent — would have given all of that up.
- *
- * `ai@7` accepts `LanguageModelV2 | V3 | V4`; this targets **v4**, the newest
- * the installed `@ai-sdk/provider` defines.
- */
-/** How the adapter reaches the API. Everything is injected so nothing reads env. */
-export interface AnthropicModelDeps {
-    /**
-     * Constructed lazily by the runtime — see the note in
-     * {@link file://./runtime.ts}. Awaited, because building it has to resolve
-     * `env.AI.gateway(id).getUrl()`, which is async.
-     */
-    client: () => Anthropic | Promise<Anthropic>;
-    /** Anthropic model id, e.g. `claude-opus-5`. */
-    modelId: string;
-    /** `max_tokens` when a caller supplies none. Anthropic requires the field. */
-    defaultMaxTokens: number;
-    /** Prompt-cache TTL, or `false` to place no breakpoints. Defaults to `"5m"`. */
-    cache?: CacheTtl | false;
-    /**
-     * Reasoning effort, when the caller does not set one per-call.
-     *
-     * Maps to `output_config.effort`. Coding and agentic work wants `"xhigh"`;
-     * `"high"` is the API default. Core never picks this — an agent does.
-     */
-    effort?: "low" | "medium" | "high" | "xhigh" | "max";
-    /** Extra headers merged into every request (AI Gateway metadata lives here). */
-    headers?: Record<string, string>;
-    /**
-     * Recognise a deployment-specific authority in a `401`/`403` body.
-     *
-     * Consulted before the built-in shapes; return `undefined` to fall through to
-     * them. It exists because a deployment may put an authenticated intermediary
-     * between the gateway and Anthropic, and only that deployment knows what its
-     * refusal looks like — core recognising one particular proxy's error body
-     * would be exactly the deployment policy this package does not ship.
-     *
-     * The remedy is what makes it worth distinguishing at all: a proxy that mints
-     * its caller credential per request has no secret to rotate, so reporting its
-     * `401` as `credential` sends an operator to replace a working token. See
-     * {@link file://../errors.ts CredentialRejectedBy}.
-     */
-    classifyAuthFailure?: (body: unknown) => CredentialRejectedBy | undefined;
-}
-export declare function createAnthropicLanguageModel(deps: AnthropicModelDeps): LanguageModelV4;