@loopingai/core 0.5.1 → 0.6.0

package/README.md

@@ -188,8 +188,8 @@ probed for), and hand-rolling it is how two agents in one repo drift apart.
 
 ### 4. Delegate, if your agent delegates
 
-`@loopingai/core/round` adds the other half: a durable Subtask DAG, wave
-scheduling, isolated subagent execution, and the round loop over them.
+`@loopingai/core/round` adds the other half: durable Subtasks, concurrent
+execution, isolated subagents, and the round loop over them.
 
 ```ts
 import { RoundAgentBase, type RoundPolicy } from "@loopingai/core/round";
@@ -225,10 +225,11 @@ not drag in the A2A adapter, and the test harness cannot reach a production bund
 | `@loopingai/core`              | `createAgentRuntime`, the plugin contract, config shapes, platform facts    |
 | `@loopingai/core/a2a`          | card signing, JWKS, gateway-JWT verify, push notify, task store, executor   |
 | `@loopingai/core/worker`       | `createA2AWorker()` — the whole zero-trust edge                             |
-| `@loopingai/core/agent`        | session, history, model runtime, inference, budget, control tools           |
+| `@loopingai/core/agent`        | session, history, models + Workers AI, inference, budget, control tools     |
 | `@loopingai/core/host`         | `LoopingAgent` — the Durable Object body — and `PluginHost`                 |
 | `@loopingai/core/round`        | the delegating round loop: `RoundAgentBase`, `runHandleTask`, `runTurn`     |
-| `@loopingai/core/subtasks`     | delegation types, decomposition, the `delegate` tool, wave scheduler        |
+| `@loopingai/core/anthropic`    | Claude as a second provider — _optional peer on `@anthropic-ai/sdk`_        |
+| `@loopingai/core/subtasks`     | delegation types, decomposition, the `delegate` tool                        |
 | `@loopingai/core/subagent`     | `RecipeSubagentBase`, resumable runs, fingerprinting, workspace             |
 | `@loopingai/core/db`           | `AgentDB`, `notify_tasks` + `subtasks` schema, migrations, `PluginStore`    |
 | `@loopingai/core/testing`      | VCR, `FakeSession`, `mockModel`, DO helpers, JWK fixtures — _workerd realm_ |
@@ -465,6 +466,7 @@ await withDb("accepts a turn once", async (db) => {
 - **Bindings:** `AI`, one Durable Object, one Workflow
 - **Secrets:** `A2A_SIGNING_KEY`, `GATEWAY_ORIGINS`
 - **Peers, never bundled:** `agents`, `ai`, `workers-ai-provider`
+- **Optional peer:** `@anthropic-ai/sdk`, needed only by `@loopingai/core/anthropic`
 
 That last point is not stylistic: two copies of `agents` in one Worker breaks the
 `Session` / `SessionMessage` types and every `instanceof`. For local development

package/dist/a2a/notify.d.ts

@@ -37,9 +37,10 @@ export { NOTIFICATION_TOKEN_HEADER } from "@loopingai/a2a-protocol";
  */
 export declare function buildSubmittedTask(taskId: string, contextId: string): PlainTask;
 /**
- * The terminal `completed` Task for a turn the agent deliberately did not answer
- * (it called the `no_reply` tool — see the agent loop). Same
- * shape as {@link buildSubmittedTask}: **no `status.message` at all**.
+ * The terminal `completed` Task for a turn the agent deliberately did not
+ * answer — a turn an `AgentPlugin.shouldHandleTurn` gate declined, or whatever
+ * else a host treats as "nothing to say". Same shape as
+ * {@link buildSubmittedTask}: **no `status.message` at all**.
  *
  * The callback is still POSTed. The gateway's pending row has to resolve — we
  * simply hand it nothing to post to Slack. There is no `messageId` because there

package/dist/a2a/notify.js

@@ -69,9 +69,10 @@ export function buildSubmittedTask(taskId, contextId) {
     return buildBareTask(taskId, contextId, TaskState.TASK_STATE_SUBMITTED);
 }
 /**
- * The terminal `completed` Task for a turn the agent deliberately did not answer
- * (it called the `no_reply` tool — see the agent loop). Same
- * shape as {@link buildSubmittedTask}: **no `status.message` at all**.
+ * The terminal `completed` Task for a turn the agent deliberately did not
+ * answer — a turn an `AgentPlugin.shouldHandleTurn` gate declined, or whatever
+ * else a host treats as "nothing to say". Same shape as
+ * {@link buildSubmittedTask}: **no `status.message` at all**.
  *
  * The callback is still POSTed. The gateway's pending row has to resolve — we
  * simply hand it nothing to post to Slack. There is no `messageId` because there

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

@@ -0,0 +1,15 @@
+/**
+ * `@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

@@ -0,0 +1,19 @@
+/**
+ * `@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

@@ -0,0 +1,59 @@
+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;

package/dist/agent/anthropic/language-model.js

@@ -0,0 +1,442 @@
+// The class from `ai`, the types from `@ai-sdk/provider`. `ai` re-exports
+// `APICallError` and is a required peer, so the only thing this adapter needs the
+// provider package for is types — which erase at build, and which `ai` does not
+// re-export.
+import { APICallError, UnsupportedFunctionalityError } from "ai";
+import { CredentialRejectedError } from "../errors.js";
+import { ANTHROPIC_PROVIDER, collectSamplingWarnings, mapPrompt, mapToolChoice, mapTools } from "./prompt.js";
+/**
+ * Anthropic `stop_reason` → the spec's unified finish reason.
+ *
+ * `raw` is always carried through: the unified set is lossy, and a caller
+ * debugging a truncated round wants to know it was `max_tokens` specifically.
+ */
+function mapFinishReason(stopReason) {
+    const raw = stopReason ?? undefined;
+    switch (stopReason) {
+        case "end_turn":
+        case "stop_sequence":
+            return { unified: "stop", raw };
+        case "max_tokens":
+            return { unified: "length", raw };
+        case "tool_use":
+            return { unified: "tool-calls", raw };
+        case "refusal":
+            return { unified: "content-filter", raw };
+        case "pause_turn":
+            return { unified: "other", raw };
+        default:
+            return { unified: "other", raw };
+    }
+}
+/** Anthropic usage → the spec's nested counters. */
+function mapUsage(usage) {
+    const cacheWrite = usage?.cache_creation_input_tokens ?? undefined;
+    const cacheRead = usage?.cache_read_input_tokens ?? undefined;
+    const noCache = usage?.input_tokens ?? undefined;
+    // `input_tokens` is the *uncached remainder*, so the true prompt size is the
+    // sum. Reporting only `input_tokens` as the total is the classic misread that
+    // makes a well-cached agent look like it is barely sending any context.
+    const total = noCache === undefined && cacheRead === undefined && cacheWrite === undefined
+        ? undefined
+        : (noCache ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
+    return {
+        inputTokens: { total, noCache, cacheRead, cacheWrite },
+        outputTokens: {
+            total: usage?.output_tokens ?? undefined,
+            text: undefined,
+            reasoning: undefined
+        }
+    };
+}
+/**
+ * Anthropic content blocks → spec content parts.
+ *
+ * Two details that corrupt silently if missed:
+ *
+ * - `tool-call.input` is a **JSON string** on the result side, even though the
+ *   same-named field on the prompt side is a parsed value.
+ * - a `thinking` block's `signature` must survive into `providerMetadata`, or
+ *   the next turn cannot replay it and the round after this one fails.
+ */
+function mapContent(blocks) {
+    const content = [];
+    for (const block of blocks) {
+        switch (block.type) {
+            case "text":
+                content.push({ type: "text", text: block.text });
+                break;
+            case "thinking":
+                content.push({
+                    type: "reasoning",
+                    text: block.thinking,
+                    providerMetadata: {
+                        [ANTHROPIC_PROVIDER]: { signature: block.signature }
+                    }
+                });
+                break;
+            case "redacted_thinking":
+                content.push({
+                    type: "reasoning",
+                    text: "",
+                    providerMetadata: {
+                        [ANTHROPIC_PROVIDER]: { redactedData: block.data }
+                    }
+                });
+                break;
+            case "tool_use":
+                content.push({
+                    type: "tool-call",
+                    toolCallId: block.id,
+                    toolName: block.name,
+                    // Result side: a JSON string, not the object.
+                    input: JSON.stringify(block.input ?? {})
+                });
+                break;
+            default:
+                // Server-tool blocks (web search, code execution, …). Core never asks
+                // for them; ignoring is correct and quiet is fine — a warning per block
+                // would be noise on a feature nobody enabled.
+                break;
+        }
+    }
+    return content;
+}
+/**
+ * Which authority refused, read off the response body the SDK parsed onto
+ * `APIError.error`.
+ *
+ * Only the two authorities *core itself* puts on the path are recognised here.
+ * They are unmistakable once you have seen them, and nothing else distinguishes
+ * them — same status, same header set:
+ *
+ * ```jsonc
+ * // AI Gateway, authentication enabled and no cf-aig-authorization sent
+ * { "name": "AiGatewayError", "internalCode": 2009, "message": "Unauthorized" }
+ * // Anthropic
+ * { "type": "error", "error": { "type": "authentication_error", … } }
+ * ```
+ *
+ * Matched on `name` **or** `internalCode`, because either alone is a single
+ * upstream rename away from silently falling through.
+ *
+ * A deployment that puts its own intermediary between the two supplies
+ * {@link AnthropicModelDeps.classifyAuthFailure}, which is consulted first —
+ * that body's shape is the deployment's fact, not core's.
+ *
+ * `undefined` means "nothing here says a credential was refused", which is
+ * distinct from `"unknown"` — see {@link asCredentialError}, where the two
+ * differ by status.
+ */
+function rejectedBy(body, classify) {
+    const declared = classify?.(body);
+    if (declared)
+        return declared;
+    if (typeof body !== "object" || body === null)
+        return undefined;
+    const parsed = body;
+    if (parsed.name === "AiGatewayError" || parsed.internalCode === 2009)
+        return "gateway";
+    if (parsed.error?.type === "authentication_error")
+        return "provider";
+    return undefined;
+}
+/**
+ * Anthropic's `Headers` (or whatever the SDK put there) as the plain object the
+ * AI SDK's retry logic indexes.
+ *
+ * `getRetryDelayInMs` reads `headers["retry-after-ms"]` and `headers["retry-after"]`
+ * with bracket access — a `Headers` instance answers `undefined` to both, so the
+ * wait silently degrades to plain exponential backoff and the provider's own
+ * "come back in N seconds" is thrown away. Lowercased on the way in because HTTP
+ * header names are case-insensitive and `Headers.forEach` is the only iteration
+ * order we can rely on.
+ */
+function plainHeaders(value) {
+    if (!value)
+        return undefined;
+    const out = {};
+    if (typeof value.forEach === "function") {
+        value.forEach((v, k) => {
+            out[k.toLowerCase()] = v;
+        });
+        return out;
+    }
+    if (typeof value !== "object")
+        return undefined;
+    for (const [k, v] of Object.entries(value)) {
+        if (typeof v === "string")
+            out[k.toLowerCase()] = v;
+    }
+    return out;
+}
+/**
+ * A provider error in the shape the AI SDK's retry logic can act on.
+ *
+ * This is what makes `maxRetries` mean anything for this adapter. `ai`'s
+ * `retryWithExponentialBackoffRespectingRetryHeaders` gates on
+ * `APICallError.isInstance(error) && error.isRetryable`, so a raw
+ * `@anthropic-ai/sdk` error — which is what this used to rethrow — is never
+ * retried, however retryable it obviously is. A 429 went straight past the
+ * retry, burned the fallback slot on a model sharing the same credential, threw,
+ * and made the Workflow retry the entire round instead of waiting the two
+ * seconds the provider asked for.
+ *
+ * `isRetryable` is deliberately not passed: `APICallError` derives it from the
+ * status (408/409/429/5xx), which is exactly the policy we want and one fewer
+ * place for the two to disagree.
+ *
+ * Credentials are handled *before* this — see the call site. A 401 must stay
+ * non-retryable and non-fallback-able, and it reaches core as
+ * {@link CredentialRejectedError} instead.
+ */
+function asApiCallError(err, body) {
+    const source = err;
+    const status = source?.status;
+    // The gateway's provider-native URL is resolved per call inside the client, so
+    // the adapter does not hold it. The model id is the useful half anyway.
+    const url = `anthropic:messages:${body.model}`;
+    if (typeof status !== "number") {
+        // A transport failure: the request never reached a server that could answer
+        // with a status. The SDK raises `APIConnectionError` /
+        // `APIConnectionTimeoutError` for these, both built by `APIError.generate`
+        // with an explicitly `undefined` status — which is the shape matched below,
+        // since the SDK sets no distinguishing `name` and is an optional peer whose
+        // classes may exist twice in one bundle.
+        //
+        // Mapping it matters because *nothing else* would retry it. The client runs
+        // with `maxRetries: 0`, `isRetryable` is derived from a status this error
+        // does not have, and the message — "Connection error." — matches none of
+        // `isTransientAiError`'s fragments. A blip therefore burned the primary,
+        // burned the fallback, and failed the task as `exhausted`.
+        if (!isSdkError(source))
+            return undefined;
+        return new APICallError({
+            message: source?.message ?? "Anthropic request failed to connect",
+            url,
+            requestBodyValues: body,
+            // Explicit, because there is no status to derive it from. A connection
+            // that never opened is the definition of worth trying again.
+            isRetryable: true,
+            cause: err
+        });
+    }
+    return new APICallError({
+        message: source?.message ?? `Anthropic request failed with ${status}`,
+        url,
+        requestBodyValues: body,
+        statusCode: status,
+        responseHeaders: plainHeaders(source?.headers),
+        responseBody: source?.error === undefined ? undefined : JSON.stringify(source.error),
+        cause: err
+    });
+}
+/**
+ * Whether this came out of the Anthropic SDK at all, as opposed to being a
+ * programming error thrown from the same `try`.
+ *
+ * `APIError` assigns `status` and `type` unconditionally, so both are **own
+ * properties even when undefined** — which is what separates a status-less
+ * transport failure from a `TypeError`. Deliberately not `instanceof`: the SDK
+ * is an optional peer and a bundle may hold two copies.
+ */
+function isSdkError(err) {
+    return (err instanceof Error && "status" in err && "type" in err && "headers" in err);
+}
+/**
+ * Recognise a rejected credential, and say whose.
+ *
+ * Structural rather than `instanceof Anthropic.AuthenticationError`: the SDK is
+ * an optional peer, so a bundle can hold two copies, and this must not depend on
+ * which one threw.
+ *
+ * ## Why 401 and 403 are not treated alike
+ *
+ * A `401` **is** an authentication failure — that is what the status means — so
+ * an unrecognised body still yields `"unknown"`, which is the honest answer and
+ * still stops the ladder.
+ *
+ * A `403` is authorization, and Anthropic uses it for `permission_error`: a
+ * perfectly valid credential that lacks access to *this* model or resource.
+ * Reporting that as a dead credential is doubly wrong — it sends an operator to
+ * rotate a working token, and it skips the fallback slot, which is the one thing
+ * that could still answer, because the fallback is a **different model** and may
+ * well be permitted. So a `403` counts only when the body positively names a
+ * refused credential; anything else falls through to {@link asApiCallError} and
+ * the fallback is tried as usual.
+ */
+function asCredentialError(err, classify) {
+    if (CredentialRejectedError.isInstance(err))
+        return err;
+    const status = err?.status;
+    if (status !== 401 && status !== 403)
+        return undefined;
+    const source = rejectedBy(err?.error, classify);
+    // A 403 nobody claimed is a permission problem, not a credential one.
+    if (source === undefined && status === 403)
+        return undefined;
+    const message = err instanceof Error ? err.message : "a credential was rejected";
+    return new CredentialRejectedError(message, {
+        status,
+        source: source ?? "unknown",
+        cause: err
+    });
+}
+export function createAnthropicLanguageModel(deps) {
+    const cache = deps.cache ?? "5m";
+    const ttl = cache === false ? undefined : cache;
+    return {
+        specificationVersion: "v4",
+        provider: ANTHROPIC_PROVIDER,
+        modelId: deps.modelId,
+        // Anthropic fetches image and PDF URLs itself, so the SDK need not download
+        // and re-encode them.
+        supportedUrls: {
+            "image/*": [/^https?:\/\/.+$/],
+            "application/pdf": [/^https?:\/\/.+$/]
+        },
+        async doGenerate(options) {
+            const warnings = [...collectSamplingWarnings(options)];
+            const { system, messages, warnings: promptWarnings } = mapPrompt(options.prompt, {
+                cache,
+                defaultMaxTokens: deps.defaultMaxTokens
+            });
+            warnings.push(...promptWarnings);
+            const tools = options.tools
+                ? mapTools(options.tools, ttl, warnings)
+                : undefined;
+            if (options.responseFormat?.type === "json") {
+                warnings.push({
+                    type: "unsupported",
+                    feature: "responseFormat",
+                    details: "structured outputs are not mapped yet; use a tool with a strict schema"
+                });
+            }
+            const effort = mapEffort(options.reasoning ?? deps.effort, warnings);
+            const body = {
+                model: deps.modelId,
+                max_tokens: options.maxOutputTokens ?? deps.defaultMaxTokens,
+                messages,
+                ...(system ? { system } : {}),
+                ...(tools ? { tools } : {}),
+                ...(options.toolChoice
+                    ? { tool_choice: mapToolChoice(options.toolChoice) }
+                    : {}),
+                ...(options.stopSequences?.length
+                    ? { stop_sequences: options.stopSequences }
+                    : {}),
+                ...(effort ? { output_config: { effort } } : {})
+            };
+            try {
+                // Streamed on the wire, accumulated here into the single result the
+                // spec returns. This is not an optimisation and not optional: the SDK
+                // refuses a NON-streaming request outright — before any network call —
+                // once `max_tokens` implies a response that could take more than ten
+                // minutes, at `(60 * 60 * max_tokens) / 128_000 > 600`, i.e. above
+                // 21,333 tokens. An agent whose whole point is long output would have
+                // to be capped below that ceiling to use `create`.
+                //
+                // `doStream` still throws: what streams is the transport, not this
+                // adapter's contract. Core calls `generateText`, which wants one
+                // result, and it gets one.
+                const client = await deps.client();
+                const response = await client.messages
+                    .stream(body, {
+                    ...(options.abortSignal ? { signal: options.abortSignal } : {}),
+                    headers: { ...deps.headers, ...stripUndefined(options.headers) }
+                })
+                    .finalMessage();
+                return {
+                    // `refusal` arrives as a normal 200 with empty or partial content, so
+                    // this must never assume `content[0]` exists.
+                    content: mapContent(response.content ?? []),
+                    finishReason: mapFinishReason(response.stop_reason),
+                    usage: mapUsage(response.usage),
+                    warnings,
+                    request: { body },
+                    response: { id: response.id, modelId: response.model }
+                };
+            }
+            catch (err) {
+                // Credentials first, and the order is the whole point: a 401 is a
+                // status the generic mapper below would happily wrap, and an
+                // `APICallError` is something core's ladder is allowed to fall back
+                // from. A dead token must stop the task instead.
+                const credential = asCredentialError(err, deps.classifyAuthFailure);
+                if (credential)
+                    throw credential;
+                // Everything else in the shape the SDK's retry and core's transient
+                // classifier can both read. See {@link asApiCallError}.
+                const apiError = asApiCallError(err, body);
+                if (apiError)
+                    throw apiError;
+                throw err;
+            }
+        },
+        /**
+         * Not implemented, deliberately. Core's loops call `generateText`, which
+         * never touches `doStream` — what streams is the transport inside
+         * `doGenerate`, not this adapter's contract. The spec's own error is the
+         * right one: it fails by name, and a caller reaching for `streamText` sees
+         * which method is missing rather than something half-formed.
+         */
+        doStream() {
+            throw new UnsupportedFunctionalityError({
+                functionality: "doStream",
+                message: "The Anthropic adapter implements doGenerate only. " +
+                    "Core's loops call generateText, which never streams. " +
+                    "Implement doStream in @loopingai/core/anthropic before using streamText."
+            });
+        }
+    };
+}
+/**
+ * Reasoning effort → `output_config.effort`, or nothing.
+ *
+ * The two vocabularies overlap but are not the same, and the difference is a
+ * 400 rather than a type error: the spec's `reasoning` includes `"minimal"`,
+ * which Anthropic's `effort` does not define. Casting across them — which is
+ * what this replaced — silences the one check that would have caught it.
+ *
+ * `provider-default` and `none` mean "say nothing", so the field is omitted and
+ * the API picks. `minimal` is mapped down to the nearest real level rather than
+ * dropped: the caller asked for *less* thinking, and omitting the field would
+ * silently give them the API default of `high` — the opposite.
+ */
+function mapEffort(reasoning, warnings) {
+    switch (reasoning) {
+        case undefined:
+        case "provider-default":
+        case "none":
+            return undefined;
+        case "low":
+        case "medium":
+        case "high":
+        case "xhigh":
+        case "max":
+            return reasoning;
+        case "minimal":
+            warnings.push({
+                type: "unsupported",
+                feature: "reasoning",
+                details: 'Anthropic has no "minimal" effort; sent "low" instead'
+            });
+            return "low";
+        default:
+            warnings.push({
+                type: "unsupported",
+                feature: "reasoning",
+                details: `unknown reasoning effort "${reasoning}"; the field was omitted`
+            });
+            return undefined;
+    }
+}
+/** The spec allows `undefined` header values; `fetch` does not. */
+function stripUndefined(headers) {
+    const out = {};
+    for (const [key, value] of Object.entries(headers ?? {})) {
+        if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}