@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/providers/anthropic.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type AiProvider, type AiProviderRequest, type AiToolSchemaLimits, type AiUsage } from './contract';
+/**
+ * The Anthropic adapter (AGL-2903, behind the contract since AGL-2939):
+ * the Messages API over raw `fetch`. No provider SDK is installed, and the
+ * meter prices by model id from the catalog, so nothing an SDK would add
+ * is used here. This file and the catalog are the only places in the
+ * plugin that name the vendor's URL, header or model ids.
+ *
+ * ── Errors (AGL-2815) ─────────────────────────────────────────────────────
+ *
+ * Provider error text describes OUR account with the vendor — a key, a rate
+ * limit, a balance — and names the vendor to a white-label org's users. It
+ * never leaves this module as a message: a non-2xx answer becomes an
+ * `AiUpstreamError` carrying the status, whether the failure is retryable
+ * and a fixed customer-safe sentence; the provider's body goes to
+ * `console.error` beside the request id, where an operator can find it.
+ * A `refusal` stop is not an error at all — the tokens were spent and the
+ * model answered — so it comes back as a typed `AiRefusal` result.
+ */
+export declare const ANTHROPIC_PROVIDER_ID = "anthropic";
+export declare const ANTHROPIC_API_KEY_ENV = "ANTHROPIC_API_KEY";
+/** The Messages API accepts at most this many `cache_control` markers. */
+export declare const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4;
+/**
+ * What the Messages API compiles of one request's strict schemas, as its
+ * structured-outputs documentation states the limits: 20 strict tools, 24
+ * optional parameters and 16 parameters with union types, each a total over
+ * every strict schema the request carries. Past any of them the request is
+ * refused with a 400 before the model runs.
+ *
+ * `compiledSchemaBytes` is not one of those. The API also refuses a request
+ * whose schemas compile to too large a grammar — "Simplify your tool schemas
+ * or reduce the number of strict tools" — and states no size for it, so this
+ * bound is measured rather than read (AGL-3096). Its evidence is two live
+ * requests for the automation draft, the largest strict schema anything here
+ * sends:
+ *
+ *  - 8,757 bytes, refused for grammar size (`req_011CfC6Fif9iJvmKPTRgtLdp`,
+ *    2026-09-19), with 1 strict tool, 0 optional parameters and 2 unions:
+ *    every published count was green;
+ *  - 3,807 bytes, served (`req_011CfELn62WVLeaNzwK4TWgb`, 2026-09-20), the
+ *    same tool with the guard lifted out of the steps' union and one variant
+ *    per set of fields.
+ *
+ * Everything else the plugin sends is smaller still, the next largest being
+ * the theme tool at 2,410 bytes. The bound sits at what has been served, so a
+ * schema that grows past it has to be proved live before the bound moves.
+ */
+export declare const ANTHROPIC_TOOL_SCHEMA_LIMITS: AiToolSchemaLimits;
+/**
+ * Whether a provider failure is the kind that clears on its own. Matched on
+ * the status AND the error type, because the in-stream `error` event has no
+ * status to go by.
+ */
+export declare function anthropicFailureIsRetryable(status: number | null, errorType: string | undefined): boolean;
+/** Anthropic's `usage` object, in the meter's shape. Missing fields read 0. */
+export declare function anthropicUsageFrom(usage: unknown): AiUsage;
+/**
+ * The Messages API body for a request. Exported so a spec can assert the
+ * wire shape without a network. The cache-prefix rule is enforced by the
+ * runtime before the request reaches any adapter; this maps the surviving
+ * breakpoints onto `cache_control` and refuses only the count the API
+ * itself refuses.
+ */
+export declare function buildAnthropicRequestBody(input: Omit<AiProviderRequest, 'apiKey' | 'signal'> & {
+    stream: boolean;
+}): Record<string, unknown>;
+export declare const anthropicProvider: AiProvider;

package/src/lib/providers/anthropic.js

@@ -0,0 +1,432 @@
+import { _ as _await_async_generator } from "@swc/helpers/_/_await_async_generator";
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _wrap_async_generator } from "@swc/helpers/_/_wrap_async_generator";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { aiModelIdsForProvider, estimateAiBilledUsd, aiCatalogEntry } from "./catalog.js";
+import { AiUpstreamError, aiRawOutputOf, aiStoppedAtCeiling, aiTokenCount, aiToolInputOf } from "./contract.js";
+/**
+ * The Anthropic adapter (AGL-2903, behind the contract since AGL-2939):
+ * the Messages API over raw `fetch`. No provider SDK is installed, and the
+ * meter prices by model id from the catalog, so nothing an SDK would add
+ * is used here. This file and the catalog are the only places in the
+ * plugin that name the vendor's URL, header or model ids.
+ *
+ * ── Errors (AGL-2815) ─────────────────────────────────────────────────────
+ *
+ * Provider error text describes OUR account with the vendor — a key, a rate
+ * limit, a balance — and names the vendor to a white-label org's users. It
+ * never leaves this module as a message: a non-2xx answer becomes an
+ * `AiUpstreamError` carrying the status, whether the failure is retryable
+ * and a fixed customer-safe sentence; the provider's body goes to
+ * `console.error` beside the request id, where an operator can find it.
+ * A `refusal` stop is not an error at all — the tokens were spent and the
+ * model answered — so it comes back as a typed `AiRefusal` result.
+ */ export const ANTHROPIC_PROVIDER_ID = 'anthropic';
+export const ANTHROPIC_API_KEY_ENV = 'ANTHROPIC_API_KEY';
+const ANTHROPIC_HOST = 'api.anthropic.com';
+const ANTHROPIC_URL = `https://${ANTHROPIC_HOST}/v1/messages`;
+const ANTHROPIC_VERSION = '2023-06-01';
+/** The Messages API accepts at most this many `cache_control` markers. */ export const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4;
+/**
+ * What the Messages API compiles of one request's strict schemas, as its
+ * structured-outputs documentation states the limits: 20 strict tools, 24
+ * optional parameters and 16 parameters with union types, each a total over
+ * every strict schema the request carries. Past any of them the request is
+ * refused with a 400 before the model runs.
+ *
+ * `compiledSchemaBytes` is not one of those. The API also refuses a request
+ * whose schemas compile to too large a grammar — "Simplify your tool schemas
+ * or reduce the number of strict tools" — and states no size for it, so this
+ * bound is measured rather than read (AGL-3096). Its evidence is two live
+ * requests for the automation draft, the largest strict schema anything here
+ * sends:
+ *
+ *  - 8,757 bytes, refused for grammar size (`req_011CfC6Fif9iJvmKPTRgtLdp`,
+ *    2026-09-19), with 1 strict tool, 0 optional parameters and 2 unions:
+ *    every published count was green;
+ *  - 3,807 bytes, served (`req_011CfELn62WVLeaNzwK4TWgb`, 2026-09-20), the
+ *    same tool with the guard lifted out of the steps' union and one variant
+ *    per set of fields.
+ *
+ * Everything else the plugin sends is smaller still, the next largest being
+ * the theme tool at 2,410 bytes. The bound sits at what has been served, so a
+ * schema that grows past it has to be proved live before the bound moves.
+ */ export const ANTHROPIC_TOOL_SCHEMA_LIMITS = {
+    strictTools: 20,
+    optionalParameters: 24,
+    unionParameters: 16,
+    compiledSchemaBytes: 3807
+};
+/**
+ * Whether a provider failure is the kind that clears on its own. Matched on
+ * the status AND the error type, because the in-stream `error` event has no
+ * status to go by.
+ */ export function anthropicFailureIsRetryable(status, errorType) {
+    return status === 429 || status === 529 || errorType === 'rate_limit_error' || errorType === 'overloaded_error';
+}
+/** Anthropic's `usage` object, in the meter's shape. Missing fields read 0. */ export function anthropicUsageFrom(usage) {
+    const record = usage != null ? usage : {};
+    // Part of `output_tokens`, and carried only where the response breaks them
+    // down, so an answer that reports none says nothing rather than zero.
+    const details = record['output_tokens_details'];
+    const thinking = details && typeof details === 'object' ? details['thinking_tokens'] : undefined;
+    return _extends({
+        inputTokens: aiTokenCount(record['input_tokens']),
+        outputTokens: aiTokenCount(record['output_tokens']),
+        cacheReadTokens: aiTokenCount(record['cache_read_input_tokens']),
+        cacheWriteTokens: aiTokenCount(record['cache_creation_input_tokens'])
+    }, thinking === undefined ? {} : {
+        thinkingTokens: aiTokenCount(thinking)
+    });
+}
+/**
+ * The Messages API body for a request. Exported so a spec can assert the
+ * wire shape without a network. The cache-prefix rule is enforced by the
+ * runtime before the request reaches any adapter; this maps the surviving
+ * breakpoints onto `cache_control` and refuses only the count the API
+ * itself refuses.
+ */ export function buildAnthropicRequestBody(input) {
+    var _input_tools, _aiCatalogEntry;
+    const breakpoints = input.system.filter((block)=>block.cacheBreakpoint);
+    if (breakpoints.length > ANTHROPIC_MAX_CACHE_BREAKPOINTS) {
+        throw new Error(`${breakpoints.length} cache breakpoints; the Messages API allows ${ANTHROPIC_MAX_CACHE_BREAKPOINTS}`);
+    }
+    const system = input.system.map((block)=>_extends({
+            type: 'text',
+            text: block.text
+        }, block.cacheBreakpoint ? {
+            cache_control: {
+                type: 'ephemeral'
+            }
+        } : {}));
+    const tools = (_input_tools = input.tools) == null ? void 0 : _input_tools.map((tool)=>({
+            name: tool.name,
+            description: tool.description,
+            input_schema: _extends({}, tool.inputSchema, {
+                additionalProperties: false
+            }),
+            strict: true
+        }));
+    // A model that rejects an explicit thinking setting gets none, whatever
+    // the door asked for, and no effort either: effort rides the same rule
+    // (see the contract), and the catalog says which models those are.
+    const settable = ((_aiCatalogEntry = aiCatalogEntry(input.model)) == null ? void 0 : _aiCatalogEntry.capabilities.thinking) !== false;
+    const thinking = settable ? input.thinking : undefined;
+    const effort = settable ? input.effort : undefined;
+    return _extends({
+        model: input.model,
+        max_tokens: input.maxTokens
+    }, input.stream ? {
+        stream: true
+    } : {}, thinking === 'off' ? {
+        thinking: {
+            type: 'disabled'
+        }
+    } : thinking === 'adaptive' ? {
+        thinking: {
+            type: 'adaptive'
+        }
+    } : {}, effort ? {
+        output_config: {
+            effort
+        }
+    } : {}, system.length ? {
+        system
+    } : {}, {
+        messages: input.messages.map((message)=>({
+                role: message.role,
+                content: anthropicContentOf(message)
+            }))
+    }, (tools == null ? void 0 : tools.length) ? {
+        tools,
+        tool_choice: {
+            type: 'auto'
+        }
+    } : {});
+}
+/**
+ * A turn's content in the Messages API's shape: a text-only turn as the
+ * string it is, and a turn with pictures as content blocks in order, each
+ * picture a base64 image block (AGL-2916).
+ */ function anthropicContentOf(message) {
+    if (typeof message.content === 'string') return message.content;
+    return message.content.map((part)=>part.type === 'image' ? {
+            type: 'image',
+            source: {
+                type: 'base64',
+                media_type: part.mediaType,
+                data: part.data
+            }
+        } : {
+            type: 'text',
+            text: part.text
+        });
+}
+/** The provider's request id, when it sent one — the log's join key. */ function requestIdOf(response) {
+    var _ref;
+    var _response_headers_get, _response_headers;
+    return (_ref = (_response_headers = response.headers) == null ? void 0 : (_response_headers_get = _response_headers.get) == null ? void 0 : _response_headers_get.call(_response_headers, 'request-id')) != null ? _ref : null;
+}
+async function send(input, stream) {
+    const body = buildAnthropicRequestBody(_extends({}, input, {
+        stream
+    }));
+    const response = await fetch(ANTHROPIC_URL, _extends({
+        method: 'POST',
+        headers: {
+            'x-api-key': input.apiKey,
+            'anthropic-version': ANTHROPIC_VERSION,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(body)
+    }, input.signal ? {
+        signal: input.signal
+    } : {}));
+    if (!response.ok || stream && !response.body) {
+        var _ref;
+        var _payload_error;
+        const requestId = requestIdOf(response);
+        const payload = await response.json().catch(()=>null);
+        console.error('ai upstream error', {
+            provider: ANTHROPIC_PROVIDER_ID,
+            status: response.status,
+            requestId,
+            model: input.model,
+            error: (_ref = payload == null ? void 0 : payload.error) != null ? _ref : null
+        });
+        throw new AiUpstreamError(response.status, anthropicFailureIsRetryable(response.status, payload == null ? void 0 : (_payload_error = payload.error) == null ? void 0 : _payload_error.type), requestId);
+    }
+    return response;
+}
+async function complete(input) {
+    const response = await send(input, false);
+    const payload = await response.json();
+    const blocks = Array.isArray(payload == null ? void 0 : payload.content) ? payload.content : [];
+    const text = blocks.filter((block)=>(block == null ? void 0 : block['type']) === 'text').map((block)=>{
+        var _block_text;
+        return String((_block_text = block['text']) != null ? _block_text : '');
+    }).join('');
+    const toolUse = blocks.filter((block)=>(block == null ? void 0 : block['type']) === 'tool_use').map((block)=>{
+        var _block_name;
+        return {
+            name: String((_block_name = block['name']) != null ? _block_name : ''),
+            input: aiToolInputOf(block['input'])
+        };
+    });
+    const usage = anthropicUsageFrom(payload == null ? void 0 : payload.usage);
+    const estCostUsd = estimateAiBilledUsd(usage, input.model);
+    const stopReason = typeof (payload == null ? void 0 : payload.stop_reason) === 'string' && payload.stop_reason ? payload.stop_reason : null;
+    if (stopReason === 'refusal') {
+        return {
+            kind: 'refusal',
+            text,
+            usage,
+            estCostUsd,
+            stopReason
+        };
+    }
+    return _extends({
+        kind: 'completion',
+        text,
+        toolUse,
+        usage,
+        estCostUsd,
+        stopReason
+    }, aiStoppedAtCeiling(stopReason) ? {
+        rawOutput: aiRawOutputOf(blocks)
+    } : {});
+}
+async function stream(input) {
+    const response = await send(input, true);
+    return streamEvents(response.body, input.model, requestIdOf(response));
+}
+/**
+ * Anthropic's SSE stream as contract events. Usage is taken from
+ * `message_start` (input and cache figures) and `message_delta` (the
+ * output count, and any cumulative input figures a newer API sends); the
+ * `done` event carries whatever was known when the body ended, so a stream
+ * cut short still meters what it cost.
+ */ function streamEvents(body, model, requestId) {
+    return _wrap_async_generator(function*() {
+        const decoder = new TextDecoder();
+        const reader = body.getReader();
+        const usage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0
+        };
+        let stopReason = null;
+        /** Tool-use blocks in flight, by content index; input arrives in pieces. */ const tools = new Map();
+        /**
+   * What each tool call was actually written in, in the order its block
+   * opened (AGL-3143). The `tool` events below carry only as much of these
+   * as `aiToolInputOf` could still parse, so for a call the ceiling cut off
+   * this is the one place the emitted bytes survive.
+   */ const written = [];
+        let buffer = '';
+        let drained = false;
+        try {
+            for(;;){
+                var _lines_pop;
+                const { done, value } = yield _await_async_generator(reader.read());
+                if (done) {
+                    drained = true;
+                    break;
+                }
+                buffer += decoder.decode(value, {
+                    stream: true
+                });
+                const lines = buffer.split('\n');
+                buffer = (_lines_pop = lines.pop()) != null ? _lines_pop : '';
+                for (const line of lines){
+                    if (!line.startsWith('data: ')) continue;
+                    let event;
+                    try {
+                        event = JSON.parse(line.slice('data: '.length));
+                    } catch (unused) {
+                        continue;
+                    }
+                    const index = Number(event['index']);
+                    switch(event['type']){
+                        case 'message_start':
+                            {
+                                var _event_message;
+                                const start = anthropicUsageFrom((_event_message = event['message']) == null ? void 0 : _event_message.usage);
+                                usage.inputTokens = start.inputTokens;
+                                usage.cacheReadTokens = start.cacheReadTokens;
+                                usage.cacheWriteTokens = start.cacheWriteTokens;
+                                break;
+                            }
+                        case 'content_block_start':
+                            {
+                                const block = event['content_block'];
+                                if ((block == null ? void 0 : block.type) === 'tool_use') {
+                                    var _block_name;
+                                    tools.set(index, {
+                                        name: String((_block_name = block.name) != null ? _block_name : ''),
+                                        json: ''
+                                    });
+                                }
+                                break;
+                            }
+                        case 'content_block_delta':
+                            {
+                                const delta = event['delta'];
+                                if ((delta == null ? void 0 : delta.type) === 'text_delta' && delta.text) {
+                                    yield {
+                                        type: 'delta',
+                                        text: delta.text
+                                    };
+                                } else if ((delta == null ? void 0 : delta.type) === 'input_json_delta') {
+                                    var _delta_partial_json;
+                                    const tool = tools.get(index);
+                                    if (tool) tool.json += (_delta_partial_json = delta.partial_json) != null ? _delta_partial_json : '';
+                                }
+                                break;
+                            }
+                        case 'content_block_stop':
+                            {
+                                const tool = tools.get(index);
+                                if (tool) {
+                                    tools.delete(index);
+                                    written.push(tool.json);
+                                    yield {
+                                        type: 'tool',
+                                        name: tool.name,
+                                        input: aiToolInputOf(tool.json)
+                                    };
+                                }
+                                break;
+                            }
+                        case 'message_delta':
+                            {
+                                var _event_delta;
+                                const delta = anthropicUsageFrom(event['usage']);
+                                usage.outputTokens = delta.outputTokens || usage.outputTokens;
+                                usage.inputTokens = delta.inputTokens || usage.inputTokens;
+                                usage.cacheReadTokens = delta.cacheReadTokens || usage.cacheReadTokens;
+                                usage.cacheWriteTokens = delta.cacheWriteTokens || usage.cacheWriteTokens;
+                                // Kept where the breakdown is reported and left absent where it
+                                // is not (AGL-3143), never set to a zero the provider did not
+                                // send. A stream needs it for the reason a completion does: it
+                                // is the figure that accounts for a spent ceiling first, and it
+                                // arrives in the same usage object as the four above.
+                                if (delta.thinkingTokens !== undefined) usage.thinkingTokens = delta.thinkingTokens;
+                                const reason = (_event_delta = event['delta']) == null ? void 0 : _event_delta.stop_reason;
+                                if (typeof reason === 'string' && reason) stopReason = reason;
+                                break;
+                            }
+                        case 'error':
+                            {
+                                const error = event['error'];
+                                console.error('ai upstream stream error', {
+                                    provider: ANTHROPIC_PROVIDER_ID,
+                                    requestId,
+                                    model,
+                                    error: error != null ? error : null
+                                });
+                                yield {
+                                    type: 'error',
+                                    retryable: anthropicFailureIsRetryable(null, error == null ? void 0 : error.type)
+                                };
+                                break;
+                            }
+                        default:
+                            break;
+                    }
+                }
+            }
+        } finally{
+            // A consumer that stops iterating early — a client that hung up — must
+            // not leave the provider generating into a socket nobody reads: cancel
+            // tells the upstream to stop, and the tokens it has already produced are
+            // the only ones billed.
+            if (!drained) yield _await_async_generator(reader.cancel().catch(()=>undefined));
+            reader.releaseLock();
+        }
+        // A message the ceiling ends mid-block never reaches that block's stop
+        // event, so what it had written is still held in flight.
+        for (const tool of tools.values())written.push(tool.json);
+        yield _extends({
+            type: 'done',
+            usage,
+            estCostUsd: estimateAiBilledUsd(usage, model),
+            stopReason
+        }, aiStoppedAtCeiling(stopReason) ? {
+            rawOutput: aiRawOutputOf(written.join(''))
+        } : {});
+    })();
+}
+export const anthropicProvider = {
+    id: ANTHROPIC_PROVIDER_ID,
+    label: 'Anthropic',
+    apiKeyEnv: ANTHROPIC_API_KEY_ENV,
+    readApiKey: ()=>{
+        var _process_env_ANTHROPIC_API_KEY;
+        return ((_process_env_ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY) == null ? void 0 : _process_env_ANTHROPIC_API_KEY.trim()) || undefined;
+    },
+    endpointHost: ANTHROPIC_HOST,
+    toolSchemaLimits: ANTHROPIC_TOOL_SCHEMA_LIMITS,
+    models () {
+        return aiModelIdsForProvider(ANTHROPIC_PROVIDER_ID).map((id)=>aiCatalogEntry(id)).filter((entry)=>Boolean(entry));
+    },
+    complete,
+    stream
+};
+
+//# sourceMappingURL=anthropic.js.map

package/src/lib/providers/anthropic.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/ai/src/lib/providers/anthropic.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { aiModelIdsForProvider, estimateAiBilledUsd, aiCatalogEntry } from './catalog'\nimport {\n  AiUpstreamError,\n  aiRawOutputOf,\n  aiStoppedAtCeiling,\n  aiTokenCount,\n  aiToolInputOf,\n  type AiMessage,\n  type AiModelDescriptor,\n  type AiProvider,\n  type AiProviderRequest,\n  type AiResult,\n  type AiStreamEvent,\n  type AiToolSchemaLimits,\n  type AiToolUse,\n  type AiUsage,\n} from './contract'\n\n/**\n * The Anthropic adapter (AGL-2903, behind the contract since AGL-2939):\n * the Messages API over raw `fetch`. No provider SDK is installed, and the\n * meter prices by model id from the catalog, so nothing an SDK would add\n * is used here. This file and the catalog are the only places in the\n * plugin that name the vendor's URL, header or model ids.\n *\n * ── Errors (AGL-2815) ─────────────────────────────────────────────────────\n *\n * Provider error text describes OUR account with the vendor — a key, a rate\n * limit, a balance — and names the vendor to a white-label org's users. It\n * never leaves this module as a message: a non-2xx answer becomes an\n * `AiUpstreamError` carrying the status, whether the failure is retryable\n * and a fixed customer-safe sentence; the provider's body goes to\n * `console.error` beside the request id, where an operator can find it.\n * A `refusal` stop is not an error at all — the tokens were spent and the\n * model answered — so it comes back as a typed `AiRefusal` result.\n */\n\nexport const ANTHROPIC_PROVIDER_ID = 'anthropic'\nexport const ANTHROPIC_API_KEY_ENV = 'ANTHROPIC_API_KEY'\nconst ANTHROPIC_HOST = 'api.anthropic.com'\nconst ANTHROPIC_URL = `https://${ANTHROPIC_HOST}/v1/messages`\nconst ANTHROPIC_VERSION = '2023-06-01'\n\n/** The Messages API accepts at most this many `cache_control` markers. */\nexport const ANTHROPIC_MAX_CACHE_BREAKPOINTS = 4\n\n/**\n * What the Messages API compiles of one request's strict schemas, as its\n * structured-outputs documentation states the limits: 20 strict tools, 24\n * optional parameters and 16 parameters with union types, each a total over\n * every strict schema the request carries. Past any of them the request is\n * refused with a 400 before the model runs.\n *\n * `compiledSchemaBytes` is not one of those. The API also refuses a request\n * whose schemas compile to too large a grammar — \"Simplify your tool schemas\n * or reduce the number of strict tools\" — and states no size for it, so this\n * bound is measured rather than read (AGL-3096). Its evidence is two live\n * requests for the automation draft, the largest strict schema anything here\n * sends:\n *\n *  - 8,757 bytes, refused for grammar size (`req_011CfC6Fif9iJvmKPTRgtLdp`,\n *    2026-09-19), with 1 strict tool, 0 optional parameters and 2 unions:\n *    every published count was green;\n *  - 3,807 bytes, served (`req_011CfELn62WVLeaNzwK4TWgb`, 2026-09-20), the\n *    same tool with the guard lifted out of the steps' union and one variant\n *    per set of fields.\n *\n * Everything else the plugin sends is smaller still, the next largest being\n * the theme tool at 2,410 bytes. The bound sits at what has been served, so a\n * schema that grows past it has to be proved live before the bound moves.\n */\nexport const ANTHROPIC_TOOL_SCHEMA_LIMITS: AiToolSchemaLimits = {\n  strictTools: 20,\n  optionalParameters: 24,\n  unionParameters: 16,\n  compiledSchemaBytes: 3_807,\n}\n\n/**\n * Whether a provider failure is the kind that clears on its own. Matched on\n * the status AND the error type, because the in-stream `error` event has no\n * status to go by.\n */\nexport function anthropicFailureIsRetryable(\n  status: number | null,\n  errorType: string | undefined,\n): boolean {\n  return (\n    status === 429 ||\n    status === 529 ||\n    errorType === 'rate_limit_error' ||\n    errorType === 'overloaded_error'\n  )\n}\n\n/** Anthropic's `usage` object, in the meter's shape. Missing fields read 0. */\nexport function anthropicUsageFrom(usage: unknown): AiUsage {\n  const record = (usage ?? {}) as Record<string, unknown>\n  // Part of `output_tokens`, and carried only where the response breaks them\n  // down, so an answer that reports none says nothing rather than zero.\n  const details = record['output_tokens_details']\n  const thinking =\n    details && typeof details === 'object'\n      ? (details as Record<string, unknown>)['thinking_tokens']\n      : undefined\n  return {\n    inputTokens: aiTokenCount(record['input_tokens']),\n    outputTokens: aiTokenCount(record['output_tokens']),\n    cacheReadTokens: aiTokenCount(record['cache_read_input_tokens']),\n    cacheWriteTokens: aiTokenCount(record['cache_creation_input_tokens']),\n    ...(thinking === undefined ? {} : { thinkingTokens: aiTokenCount(thinking) }),\n  }\n}\n\n/**\n * The Messages API body for a request. Exported so a spec can assert the\n * wire shape without a network. The cache-prefix rule is enforced by the\n * runtime before the request reaches any adapter; this maps the surviving\n * breakpoints onto `cache_control` and refuses only the count the API\n * itself refuses.\n */\nexport function buildAnthropicRequestBody(\n  input: Omit<AiProviderRequest, 'apiKey' | 'signal'> & { stream: boolean },\n): Record<string, unknown> {\n  const breakpoints = input.system.filter((block) => block.cacheBreakpoint)\n  if (breakpoints.length > ANTHROPIC_MAX_CACHE_BREAKPOINTS) {\n    throw new Error(\n      `${breakpoints.length} cache breakpoints; the Messages API allows ${ANTHROPIC_MAX_CACHE_BREAKPOINTS}`,\n    )\n  }\n  const system = input.system.map((block) => ({\n    type: 'text',\n    text: block.text,\n    ...(block.cacheBreakpoint ? { cache_control: { type: 'ephemeral' } } : {}),\n  }))\n  const tools = input.tools?.map((tool) => ({\n    name: tool.name,\n    description: tool.description,\n    input_schema: { ...tool.inputSchema, additionalProperties: false },\n    strict: true,\n  }))\n  // A model that rejects an explicit thinking setting gets none, whatever\n  // the door asked for, and no effort either: effort rides the same rule\n  // (see the contract), and the catalog says which models those are.\n  const settable = aiCatalogEntry(input.model)?.capabilities.thinking !== false\n  const thinking = settable ? input.thinking : undefined\n  const effort = settable ? input.effort : undefined\n  return {\n    model: input.model,\n    max_tokens: input.maxTokens,\n    ...(input.stream ? { stream: true } : {}),\n    ...(thinking === 'off'\n      ? { thinking: { type: 'disabled' } }\n      : thinking === 'adaptive'\n        ? { thinking: { type: 'adaptive' } }\n        : {}),\n    ...(effort ? { output_config: { effort } } : {}),\n    ...(system.length ? { system } : {}),\n    messages: input.messages.map((message) => ({\n      role: message.role,\n      content: anthropicContentOf(message),\n    })),\n    ...(tools?.length ? { tools, tool_choice: { type: 'auto' } } : {}),\n  }\n}\n\n/**\n * A turn's content in the Messages API's shape: a text-only turn as the\n * string it is, and a turn with pictures as content blocks in order, each\n * picture a base64 image block (AGL-2916).\n */\nfunction anthropicContentOf(message: AiMessage): string | Array<Record<string, unknown>> {\n  if (typeof message.content === 'string') return message.content\n  return message.content.map((part) =>\n    part.type === 'image'\n      ? { type: 'image', source: { type: 'base64', media_type: part.mediaType, data: part.data } }\n      : { type: 'text', text: part.text },\n  )\n}\n\n/** The provider's request id, when it sent one — the log's join key. */\nfunction requestIdOf(response: Response): string | null {\n  return response.headers?.get?.('request-id') ?? null\n}\n\nasync function send(\n  input: AiProviderRequest,\n  stream: boolean,\n): Promise<Response> {\n  const body = buildAnthropicRequestBody({ ...input, stream })\n  const response = await fetch(ANTHROPIC_URL, {\n    method: 'POST',\n    headers: {\n      'x-api-key': input.apiKey,\n      'anthropic-version': ANTHROPIC_VERSION,\n      'Content-Type': 'application/json',\n    },\n    body: JSON.stringify(body),\n    ...(input.signal ? { signal: input.signal } : {}),\n  })\n  if (!response.ok || (stream && !response.body)) {\n    const requestId = requestIdOf(response)\n    const payload = (await response.json().catch(() => null)) as {\n      error?: { type?: string; message?: string }\n    } | null\n    console.error('ai upstream error', {\n      provider: ANTHROPIC_PROVIDER_ID,\n      status: response.status,\n      requestId,\n      model: input.model,\n      error: payload?.error ?? null,\n    })\n    throw new AiUpstreamError(\n      response.status,\n      anthropicFailureIsRetryable(response.status, payload?.error?.type),\n      requestId,\n    )\n  }\n  return response\n}\n\nasync function complete(input: AiProviderRequest): Promise<AiResult> {\n  const response = await send(input, false)\n  const payload = (await response.json()) as {\n    content?: Array<Record<string, unknown>>\n    stop_reason?: unknown\n    usage?: unknown\n  }\n  const blocks = Array.isArray(payload?.content) ? payload.content : []\n  const text = blocks\n    .filter((block) => block?.['type'] === 'text')\n    .map((block) => String(block['text'] ?? ''))\n    .join('')\n  const toolUse: AiToolUse[] = blocks\n    .filter((block) => block?.['type'] === 'tool_use')\n    .map((block) => ({\n      name: String(block['name'] ?? ''),\n      input: aiToolInputOf(block['input']),\n    }))\n  const usage = anthropicUsageFrom(payload?.usage)\n  const estCostUsd = estimateAiBilledUsd(usage, input.model)\n  const stopReason =\n    typeof payload?.stop_reason === 'string' && payload.stop_reason\n      ? payload.stop_reason\n      : null\n  if (stopReason === 'refusal') {\n    return { kind: 'refusal', text, usage, estCostUsd, stopReason }\n  }\n  return {\n    kind: 'completion',\n    text,\n    toolUse,\n    usage,\n    estCostUsd,\n    stopReason,\n    // The blocks as the provider answered them, for a call its ceiling cut\n    // off (AGL-3143): `toolUse` holds only what still parsed out of them.\n    ...(aiStoppedAtCeiling(stopReason) ? { rawOutput: aiRawOutputOf(blocks) } : {}),\n  }\n}\n\nasync function stream(input: AiProviderRequest): Promise<AsyncIterable<AiStreamEvent>> {\n  const response = await send(input, true)\n  return streamEvents(\n    response.body as ReadableStream<Uint8Array>,\n    input.model,\n    requestIdOf(response),\n  )\n}\n\n/**\n * Anthropic's SSE stream as contract events. Usage is taken from\n * `message_start` (input and cache figures) and `message_delta` (the\n * output count, and any cumulative input figures a newer API sends); the\n * `done` event carries whatever was known when the body ended, so a stream\n * cut short still meters what it cost.\n */\nasync function* streamEvents(\n  body: ReadableStream<Uint8Array>,\n  model: string,\n  requestId: string | null,\n): AsyncGenerator<AiStreamEvent> {\n  const decoder = new TextDecoder()\n  const reader = body.getReader()\n  const usage: AiUsage = {\n    inputTokens: 0,\n    outputTokens: 0,\n    cacheReadTokens: 0,\n    cacheWriteTokens: 0,\n  }\n  let stopReason: string | null = null\n  /** Tool-use blocks in flight, by content index; input arrives in pieces. */\n  const tools = new Map<number, { name: string; json: string }>()\n  /**\n   * What each tool call was actually written in, in the order its block\n   * opened (AGL-3143). The `tool` events below carry only as much of these\n   * as `aiToolInputOf` could still parse, so for a call the ceiling cut off\n   * this is the one place the emitted bytes survive.\n   */\n  const written: string[] = []\n  let buffer = ''\n  let drained = false\n  try {\n    for (;;) {\n      const { done, value } = await reader.read()\n      if (done) {\n        drained = true\n        break\n      }\n      buffer += decoder.decode(value, { stream: true })\n      const lines = buffer.split('\\n')\n      buffer = lines.pop() ?? ''\n      for (const line of lines) {\n        if (!line.startsWith('data: ')) continue\n        let event: Record<string, unknown>\n        try {\n          event = JSON.parse(line.slice('data: '.length))\n        } catch {\n          continue\n        }\n        const index = Number(event['index'])\n        switch (event['type']) {\n          case 'message_start': {\n            const start = anthropicUsageFrom(\n              (event['message'] as { usage?: unknown } | undefined)?.usage,\n            )\n            usage.inputTokens = start.inputTokens\n            usage.cacheReadTokens = start.cacheReadTokens\n            usage.cacheWriteTokens = start.cacheWriteTokens\n            break\n          }\n          case 'content_block_start': {\n            const block = event['content_block'] as\n              | { type?: string; name?: string }\n              | undefined\n            if (block?.type === 'tool_use') {\n              tools.set(index, { name: String(block.name ?? ''), json: '' })\n            }\n            break\n          }\n          case 'content_block_delta': {\n            const delta = event['delta'] as\n              | { type?: string; text?: string; partial_json?: string }\n              | undefined\n            if (delta?.type === 'text_delta' && delta.text) {\n              yield { type: 'delta', text: delta.text }\n            } else if (delta?.type === 'input_json_delta') {\n              const tool = tools.get(index)\n              if (tool) tool.json += delta.partial_json ?? ''\n            }\n            break\n          }\n          case 'content_block_stop': {\n            const tool = tools.get(index)\n            if (tool) {\n              tools.delete(index)\n              written.push(tool.json)\n              yield { type: 'tool', name: tool.name, input: aiToolInputOf(tool.json) }\n            }\n            break\n          }\n          case 'message_delta': {\n            const delta = anthropicUsageFrom(event['usage'])\n            usage.outputTokens = delta.outputTokens || usage.outputTokens\n            usage.inputTokens = delta.inputTokens || usage.inputTokens\n            usage.cacheReadTokens = delta.cacheReadTokens || usage.cacheReadTokens\n            usage.cacheWriteTokens = delta.cacheWriteTokens || usage.cacheWriteTokens\n            // Kept where the breakdown is reported and left absent where it\n            // is not (AGL-3143), never set to a zero the provider did not\n            // send. A stream needs it for the reason a completion does: it\n            // is the figure that accounts for a spent ceiling first, and it\n            // arrives in the same usage object as the four above.\n            if (delta.thinkingTokens !== undefined) usage.thinkingTokens = delta.thinkingTokens\n            const reason = (event['delta'] as { stop_reason?: unknown } | undefined)\n              ?.stop_reason\n            if (typeof reason === 'string' && reason) stopReason = reason\n            break\n          }\n          case 'error': {\n            const error = event['error'] as\n              | { type?: string; message?: string }\n              | undefined\n            console.error('ai upstream stream error', {\n              provider: ANTHROPIC_PROVIDER_ID,\n              requestId,\n              model,\n              error: error ?? null,\n            })\n            yield { type: 'error', retryable: anthropicFailureIsRetryable(null, error?.type) }\n            break\n          }\n          default:\n            break\n        }\n      }\n    }\n  } finally {\n    // A consumer that stops iterating early — a client that hung up — must\n    // not leave the provider generating into a socket nobody reads: cancel\n    // tells the upstream to stop, and the tokens it has already produced are\n    // the only ones billed.\n    if (!drained) await reader.cancel().catch(() => undefined)\n    reader.releaseLock()\n  }\n  // A message the ceiling ends mid-block never reaches that block's stop\n  // event, so what it had written is still held in flight.\n  for (const tool of tools.values()) written.push(tool.json)\n  yield {\n    type: 'done',\n    usage,\n    estCostUsd: estimateAiBilledUsd(usage, model),\n    stopReason,\n    // What the model emitted into its tool calls, for a stream its ceiling\n    // cut off (AGL-3143): the `tool` events carry only what parsed out.\n    ...(aiStoppedAtCeiling(stopReason) ? { rawOutput: aiRawOutputOf(written.join('')) } : {}),\n  }\n}\n\nexport const anthropicProvider: AiProvider = {\n  id: ANTHROPIC_PROVIDER_ID,\n  label: 'Anthropic',\n  apiKeyEnv: ANTHROPIC_API_KEY_ENV,\n  readApiKey: () => process.env.ANTHROPIC_API_KEY?.trim() || undefined,\n  endpointHost: ANTHROPIC_HOST,\n  toolSchemaLimits: ANTHROPIC_TOOL_SCHEMA_LIMITS,\n  models(): readonly AiModelDescriptor[] {\n    return aiModelIdsForProvider(ANTHROPIC_PROVIDER_ID)\n      .map((id) => aiCatalogEntry(id))\n      .filter((entry): entry is NonNullable<typeof entry> => Boolean(entry))\n  },\n  complete,\n  stream,\n}\n"],"names":["aiModelIdsForProvider","estimateAiBilledUsd","aiCatalogEntry","AiUpstreamError","aiRawOutputOf","aiStoppedAtCeiling","aiTokenCount","aiToolInputOf","ANTHROPIC_PROVIDER_ID","ANTHROPIC_API_KEY_ENV","ANTHROPIC_HOST","ANTHROPIC_URL","ANTHROPIC_VERSION","ANTHROPIC_MAX_CACHE_BREAKPOINTS","ANTHROPIC_TOOL_SCHEMA_LIMITS","strictTools","optionalParameters","unionParameters","compiledSchemaBytes","anthropicFailureIsRetryable","status","errorType","anthropicUsageFrom","usage","record","details","thinking","undefined","inputTokens","outputTokens","cacheReadTokens","cacheWriteTokens","thinkingTokens","buildAnthropicRequestBody","input","breakpoints","system","filter","block","cacheBreakpoint","length","Error","map","type","text","cache_control","tools","tool","name","description","input_schema","inputSchema","additionalProperties","strict","settable","model","capabilities","effort","max_tokens","maxTokens","stream","output_config","messages","message","role","content","anthropicContentOf","tool_choice","part","source","media_type","mediaType","data","requestIdOf","response","headers","get","send","body","fetch","method","apiKey","JSON","stringify","signal","ok","payload","requestId","json","catch","console","error","provider","complete","blocks","Array","isArray","String","join","toolUse","estCostUsd","stopReason","stop_reason","kind","rawOutput","streamEvents","decoder","TextDecoder","reader","getReader","Map","written","buffer","drained","lines","done","value","read","decode","split","pop","line","startsWith","event","parse","slice","index","Number","start","set","delta","partial_json","delete","push","reason","retryable","cancel","releaseLock","values","anthropicProvider","id","label","apiKeyEnv","readApiKey","process","env","ANTHROPIC_API_KEY","trim","endpointHost","toolSchemaLimits","models","entry","Boolean"],"mappings":"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"}