@particle-academy/prism 0.0.0

package/dist/providers/anthropic/maps/message-map.d.ts

@@ -0,0 +1,31 @@
+import type { JsonValue } from '../../../json.js';
+import type { Message, SystemMessage } from '../../../value-objects/messages/index.js';
+/**
+ * Map messages onto Anthropic's `messages` array.
+ *
+ * Anthropic differs from the Responses API in four ways that are easy to get
+ * subtly wrong:
+ *
+ *   1. System prompts do NOT go in the message list. They are a top-level
+ *      `system` field, which is why {@link mapSystem} exists separately — a
+ *      system message pushed into `messages` is rejected outright.
+ *   2. Tool calls stay ATTACHED to the assistant turn as `tool_use` content
+ *      blocks. They do not become top-level items the way `function_call` does.
+ *   3. A tool result is a USER turn containing `tool_result` blocks, keyed by
+ *      `tool_use_id` — the id of the CALL, not of the result. That is the
+ *      opposite of the Responses API, where the result id is the key.
+ *   4. Turns must alternate. Consecutive tool results therefore travel as
+ *      blocks inside ONE user turn rather than as several user turns.
+ *
+ * @throws PrismError code `unknown_message_type`
+ */
+export declare function mapMessages(messages: readonly Message[]): JsonValue[];
+/**
+ * The top-level `system` field, or null when there is nothing to say.
+ *
+ * Several system prompts join with a blank line between them. Anthropic accepts
+ * an array of blocks here too, but a joined string is what the reference sends
+ * and the bytes are the contract.
+ */
+export declare function mapSystem(systemPrompts: readonly SystemMessage[]): string | null;
+//# sourceMappingURL=message-map.d.ts.map

package/dist/providers/anthropic/maps/message-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-map.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/maps/message-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG9D,OAAO,KAAK,EAAoB,OAAO,EAAE,aAAa,EAAqB,MAAM,0CAA0C,CAAC;AAI5H;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,EAAE,CAiCrE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,aAAa,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,GAAG,IAAI,CAIhF"}

package/dist/providers/anthropic/maps/message-map.js

@@ -0,0 +1,121 @@
+import { canonicalJson, isJsonObject } from '../../../json.js';
+import { PrismError } from '../../../errors.js';
+import { mapDocument, mapImage } from './media-map.js';
+/**
+ * Map messages onto Anthropic's `messages` array.
+ *
+ * Anthropic differs from the Responses API in four ways that are easy to get
+ * subtly wrong:
+ *
+ *   1. System prompts do NOT go in the message list. They are a top-level
+ *      `system` field, which is why {@link mapSystem} exists separately — a
+ *      system message pushed into `messages` is rejected outright.
+ *   2. Tool calls stay ATTACHED to the assistant turn as `tool_use` content
+ *      blocks. They do not become top-level items the way `function_call` does.
+ *   3. A tool result is a USER turn containing `tool_result` blocks, keyed by
+ *      `tool_use_id` — the id of the CALL, not of the result. That is the
+ *      opposite of the Responses API, where the result id is the key.
+ *   4. Turns must alternate. Consecutive tool results therefore travel as
+ *      blocks inside ONE user turn rather than as several user turns.
+ *
+ * @throws PrismError code `unknown_message_type`
+ */
+export function mapMessages(messages) {
+    const items = [];
+    for (const message of messages) {
+        switch (message.type) {
+            case 'system':
+                // Reaching here means a system message was passed as a MESSAGE rather
+                // than a system prompt. Anthropic has no system role, and silently
+                // demoting it to a user turn would change what the model was told.
+                throw PrismError.unknownMessageType('a system message in the message list; pass it as a system prompt');
+            case 'user':
+                items.push({
+                    role: 'user',
+                    content: [
+                        { type: 'text', text: message.text() },
+                        ...message.images().map(mapImage),
+                        ...message.documents().map(mapDocument),
+                    ],
+                    ...message.additionalAttributes,
+                });
+                break;
+            case 'assistant':
+                mapAssistantMessage(message, items);
+                break;
+            case 'tool_result':
+                mapToolResultMessage(message, items);
+                break;
+            default:
+                throw PrismError.unknownMessageType(describeMessage(message));
+        }
+    }
+    return items;
+}
+/**
+ * The top-level `system` field, or null when there is nothing to say.
+ *
+ * Several system prompts join with a blank line between them. Anthropic accepts
+ * an array of blocks here too, but a joined string is what the reference sends
+ * and the bytes are the contract.
+ */
+export function mapSystem(systemPrompts) {
+    const parts = systemPrompts.map((prompt) => prompt.content).filter((content) => content !== '');
+    return parts.length > 0 ? parts.join('\n\n') : null;
+}
+function mapAssistantMessage(message, items) {
+    const content = [];
+    // Text first. Anthropic reads content blocks in order, and a tool_use ahead
+    // of the reasoning that led to it reads as a model that decided first and
+    // explained afterwards.
+    if (message.content !== '') {
+        content.push({ type: 'text', text: message.content });
+    }
+    for (const toolCall of message.toolCalls) {
+        content.push({
+            type: 'tool_use',
+            // The CALL id. Anthropic echoes it back on the matching tool_result, and
+            // a mismatch here is rejected rather than ignored.
+            id: toolCall.id,
+            name: toolCall.name,
+            // An OBJECT, not a JSON string. The Responses API takes a document nested
+            // inside a document; Anthropic takes the arguments themselves.
+            input: toolCall.parsedArguments(),
+        });
+    }
+    // An assistant turn with neither text nor tool calls contributes nothing —
+    // Anthropic rejects an empty content array.
+    if (content.length > 0) {
+        items.push({ role: 'assistant', content });
+    }
+}
+/**
+ * Tool results become blocks in ONE user turn.
+ *
+ * Appended to the previous turn when that turn is already a user turn, because
+ * Anthropic requires roles to alternate and two user turns in a row is a 400.
+ */
+function mapToolResultMessage(message, items) {
+    const blocks = message.toolResults.map((toolResult) => ({
+        type: 'tool_result',
+        tool_use_id: toolResult.toolCallId,
+        content: stringifyToolOutput(toolResult.result),
+    }));
+    if (blocks.length === 0) {
+        return;
+    }
+    const previous = items[items.length - 1];
+    if (previous !== undefined && previous.role === 'user' && Array.isArray(previous.content)) {
+        previous.content = [...previous.content, ...blocks];
+        return;
+    }
+    items.push({ role: 'user', content: blocks });
+}
+/** A tool's return value as text. Objects are canonicalised, not inspected. */
+function stringifyToolOutput(result) {
+    return typeof result === 'string' ? result : canonicalJson(result);
+}
+function describeMessage(message) {
+    return isJsonObject(message) && typeof message.type === 'string' ? message.type : typeof message;
+}
+//# sourceMappingURL=message-map.js.map

package/dist/providers/anthropic/maps/message-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-map.js","sourceRoot":"","sources":["../../../../src/providers/anthropic/maps/message-map.ts"],"names":[],"mappings":"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"}

package/dist/providers/anthropic/maps/tool-choice-map.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObject } from '../../../json.js';
+import { ToolChoice } from '../../../enums.js';
+/**
+ * Map the shared tool choice onto Anthropic's object form.
+ *
+ * Anthropic takes an OBJECT where OpenAI takes a string, and it spells "the
+ * model must call something" as `any` rather than `required`. A named tool is
+ * `{ type: 'tool', name }`.
+ */
+export declare function mapToolChoice(choice: string | ToolChoice | null): JsonObject | null;
+//# sourceMappingURL=tool-choice-map.d.ts.map

package/dist/providers/anthropic/maps/tool-choice-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-choice-map.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/maps/tool-choice-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,GAAG,UAAU,GAAG,IAAI,CAmBnF"}

package/dist/providers/anthropic/maps/tool-choice-map.js

@@ -0,0 +1,25 @@
+import { ToolChoice } from '../../../enums.js';
+/**
+ * Map the shared tool choice onto Anthropic's object form.
+ *
+ * Anthropic takes an OBJECT where OpenAI takes a string, and it spells "the
+ * model must call something" as `any` rather than `required`. A named tool is
+ * `{ type: 'tool', name }`.
+ */
+export function mapToolChoice(choice) {
+    if (choice === null) {
+        return null;
+    }
+    if (choice === ToolChoice.Auto) {
+        return { type: 'auto' };
+    }
+    if (choice === ToolChoice.Any) {
+        return { type: 'any' };
+    }
+    if (choice === ToolChoice.None) {
+        return { type: 'none' };
+    }
+    // Anything else names a tool.
+    return { type: 'tool', name: String(choice) };
+}
+//# sourceMappingURL=tool-choice-map.js.map

package/dist/providers/anthropic/maps/tool-choice-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-choice-map.js","sourceRoot":"","sources":["../../../../src/providers/anthropic/maps/tool-choice-map.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,MAAkC;IAC9D,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,MAAM,KAAK,UAAU,CAAC,IAAI,EAAE,CAAC;QAC/B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAC1B,CAAC;IAED,IAAI,MAAM,KAAK,UAAU,CAAC,GAAG,EAAE,CAAC;QAC9B,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;IACzB,CAAC;IAED,IAAI,MAAM,KAAK,UAAU,CAAC,IAAI,EAAE,CAAC;QAC/B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAC1B,CAAC;IAED,8BAA8B;IAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;AAChD,CAAC"}

package/dist/providers/anthropic/maps/tool-map.d.ts

@@ -0,0 +1,14 @@
+import type { JsonObject } from '../../../json.js';
+import type { Tool } from '../../../tool.js';
+/**
+ * Map tools onto Anthropic's `tools` array.
+ *
+ * Anthropic names the schema field `input_schema`, not `parameters`, and it is
+ * NOT optional the way OpenAI's is: a tool without one is rejected. So a
+ * parameterless tool sends an empty object schema rather than omitting the key.
+ *
+ * Declaration order is preserved. Tool order reaches the model and influences
+ * which tool it picks.
+ */
+export declare function mapTools(tools: readonly Tool[]): JsonObject[];
+//# sourceMappingURL=tool-map.d.ts.map

package/dist/providers/anthropic/maps/tool-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-map.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/maps/tool-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,UAAU,EAAE,CAU7D"}

package/dist/providers/anthropic/maps/tool-map.js

@@ -0,0 +1,22 @@
+/**
+ * Map tools onto Anthropic's `tools` array.
+ *
+ * Anthropic names the schema field `input_schema`, not `parameters`, and it is
+ * NOT optional the way OpenAI's is: a tool without one is rejected. So a
+ * parameterless tool sends an empty object schema rather than omitting the key.
+ *
+ * Declaration order is preserved. Tool order reaches the model and influences
+ * which tool it picks.
+ */
+export function mapTools(tools) {
+    return tools.map((tool) => ({
+        name: tool.name(),
+        description: tool.description(),
+        input_schema: {
+            type: 'object',
+            properties: tool.hasParameters() ? tool.parametersAsObject() : {},
+            required: [...tool.requiredParameters()],
+        },
+    }));
+}
+//# sourceMappingURL=tool-map.js.map

package/dist/providers/anthropic/maps/tool-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-map.js","sourceRoot":"","sources":["../../../../src/providers/anthropic/maps/tool-map.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAsB;IAC7C,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC1B,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE;QACjB,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE;QAC/B,YAAY,EAAE;YACZ,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,EAAE;YACjE,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;SACzC;KACF,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/providers/anthropic/parse-response.d.ts

@@ -0,0 +1,21 @@
+import type { TextRequest } from '../../text/request.js';
+import type { TextResponse } from '../../text/response.js';
+import type { ProviderRateLimit } from '../../value-objects/provider-rate-limit.js';
+export interface ParseTextResponseOptions {
+    rateLimits?: readonly ProviderRateLimit[];
+}
+/**
+ * Turn a raw Anthropic Messages payload into a `TextResponse`.
+ *
+ * No HTTP happens here, so a stored payload can be replayed through exactly the
+ * code path a live call takes.
+ *
+ * @throws PrismError code `provider_response_error` when the payload is missing,
+ *   empty, or carries an `error`.
+ * @throws PrismError code `max_tokens_exceeded` when generation was cut short.
+ * @throws PrismError code `tool_loop_not_supported` when the response stopped on
+ *   tool use. Running tools is outside this port's slice, and returning a
+ *   half-formed response would be worse than saying so.
+ */
+export declare function parseTextResponse(request: TextRequest, rawBody: unknown, options?: ParseTextResponseOptions): TextResponse;
+//# sourceMappingURL=parse-response.d.ts.map

package/dist/providers/anthropic/parse-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-response.d.ts","sourceRoot":"","sources":["../../../src/providers/anthropic/parse-response.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAG3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAC;AAKpF,MAAM,WAAW,wBAAwB;IACvC,UAAU,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC3C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,wBAA6B,GACrC,YAAY,CAiBd"}

package/dist/providers/anthropic/parse-response.js

@@ -0,0 +1,109 @@
+import { isJsonObject } from '../../json.js';
+import { PrismError } from '../../errors.js';
+import { FinishReason } from '../../enums.js';
+import { isTruthyByReferenceRules, readArray, readNullableNumber, readNumber, readObject, readString, whereNotNull, } from '../../internal/filters.js';
+import { ResponseBuilder } from '../../text/response-builder.js';
+import { TextStep } from '../../text/step.js';
+import { Meta } from '../../value-objects/meta.js';
+import { ToolCall } from '../../value-objects/tool-call.js';
+import { Usage } from '../../value-objects/usage.js';
+import { mapFinishReason } from './maps/finish-reason-map.js';
+/**
+ * Turn a raw Anthropic Messages payload into a `TextResponse`.
+ *
+ * No HTTP happens here, so a stored payload can be replayed through exactly the
+ * code path a live call takes.
+ *
+ * @throws PrismError code `provider_response_error` when the payload is missing,
+ *   empty, or carries an `error`.
+ * @throws PrismError code `max_tokens_exceeded` when generation was cut short.
+ * @throws PrismError code `tool_loop_not_supported` when the response stopped on
+ *   tool use. Running tools is outside this port's slice, and returning a
+ *   half-formed response would be worse than saying so.
+ */
+export function parseTextResponse(request, rawBody, options = {}) {
+    const data = validateResponse(rawBody);
+    const finishReason = mapFinishReason(data);
+    if (finishReason === FinishReason.ToolCalls) {
+        throw PrismError.toolLoopNotSupported();
+    }
+    if (finishReason === FinishReason.Length) {
+        throw PrismError.maxTokensExceeded(readString(data.stop_reason, ''), readString(data.type, ''));
+    }
+    const builder = new ResponseBuilder();
+    builder.addStep(buildStep(data, request, finishReason, options.rateLimits ?? []));
+    return builder.toResponse();
+}
+function validateResponse(rawBody) {
+    if (!isJsonObject(rawBody) || Object.keys(rawBody).length === 0) {
+        throw PrismError.providerResponseError('Anthropic returned an empty or non-object response body.');
+    }
+    // Anthropic reports failures with `type: "error"` at the top level, and the
+    // HTTP status is not always 4xx for them — so this is checked on the body
+    // rather than left to the caller's status check.
+    if (rawBody.type === 'error' || isTruthyByReferenceRules(rawBody.error)) {
+        const error = readObject(rawBody.error) ?? {};
+        throw PrismError.providerResponseError(`Anthropic error [${readString(error.type, 'unknown')}]: ${readString(error.message, 'unknown')}`);
+    }
+    return rawBody;
+}
+function buildStep(data, request, finishReason, rateLimits) {
+    const content = readArray(data.content);
+    const usage = readObject(data.usage) ?? {};
+    return new TextStep({
+        text: outputText(content),
+        finishReason,
+        toolCalls: mapToolCalls(content),
+        usage: new Usage(
+        // Anthropic reports cache tokens SEPARATELY from input_tokens rather than
+        // inside them, so unlike the OpenAI mapping nothing is subtracted here.
+        // Subtracting would under-report the prompt.
+        readNumber(usage.input_tokens, 0), readNumber(usage.output_tokens, 0), readNullableNumber(usage.cache_creation_input_tokens), readNullableNumber(usage.cache_read_input_tokens), 
+        // Reasoning tokens, and a BREAKDOWN of output_tokens rather than an
+        // addition to them -- 1240 thinking inside 2820 output, not beside.
+        // Reported by the Moic Suite team against the live API; every Anthropic
+        // path in all three languages was leaving this null, so no cross-language
+        // check could see it. They agreed on something wrong.
+        readNullableNumber(readObject(usage.output_tokens_details)?.thinking_tokens)),
+        meta: new Meta(readString(data.id, ''), readString(data.model, ''), rateLimits, null),
+        messages: request.messages(),
+        systemPrompts: request.systemPrompts(),
+        additionalContent: whereNotNull({
+            thinking: thinkingText(content),
+            stopSequence: typeof data.stop_sequence === 'string' ? data.stop_sequence : null,
+        }),
+        raw: data,
+    });
+}
+/**
+ * Every text block joined, not just the first.
+ *
+ * Anthropic splits a reply across several text blocks when thinking or tool use
+ * interleaves with it, so taking `content[0]` returns a truncated answer that
+ * looks complete.
+ */
+function outputText(content) {
+    return content
+        .filter(isJsonObject)
+        .filter((block) => block.type === 'text')
+        .map((block) => readString(block.text, ''))
+        .join('');
+}
+function mapToolCalls(content) {
+    return content
+        .filter(isJsonObject)
+        .filter((block) => block.type === 'tool_use')
+        .map((block) => new ToolCall(readString(block.id, ''), readString(block.name, ''), 
+    // An object on the wire, unlike the Responses API's JSON string.
+    isJsonObject(block.input) ? block.input : {}, null));
+}
+/** Extended-thinking blocks joined, or null when the model did not think. */
+function thinkingText(content) {
+    const parts = content
+        .filter(isJsonObject)
+        .filter((block) => block.type === 'thinking')
+        .map((block) => readString(block.thinking, ''))
+        .filter((text) => text !== '');
+    return parts.length > 0 ? parts.join('') : null;
+}
+//# sourceMappingURL=parse-response.js.map

package/dist/providers/anthropic/parse-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-response.js","sourceRoot":"","sources":["../../../src/providers/anthropic/parse-response.ts"],"names":[],"mappings":"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"}

package/dist/providers/anthropic/rate-limits.d.ts

@@ -0,0 +1,4 @@
+import { ProviderRateLimit } from '../../value-objects/provider-rate-limit.js';
+/** Read Anthropic's `anthropic-ratelimit-*` headers into rate-limit value objects. */
+export declare function parseRateLimits(headers: Readonly<Record<string, string>>): ProviderRateLimit[];
+//# sourceMappingURL=rate-limits.d.ts.map

package/dist/providers/anthropic/rate-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limits.d.ts","sourceRoot":"","sources":["../../../src/providers/anthropic/rate-limits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAC;AAU/E,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,iBAAiB,EAAE,CA8B9F"}

package/dist/providers/anthropic/rate-limits.js

@@ -0,0 +1,47 @@
+import { ProviderRateLimit } from '../../value-objects/provider-rate-limit.js';
+import { foldHeaderNames } from '../../http/header-names.js';
+/**
+ * Anthropic reports four buckets where OpenAI reports two, and the extra pair
+ * matters: input and output tokens are limited SEPARATELY, so a caller that
+ * only watched a combined figure would be surprised by which one ran out.
+ */
+const BUCKETS = ['requests', 'tokens', 'input-tokens', 'output-tokens'];
+/** Read Anthropic's `anthropic-ratelimit-*` headers into rate-limit value objects. */
+export function parseRateLimits(headers) {
+    const rateLimits = [];
+    // Folded first: HTTP field names are case-insensitive (RFC 9110 §5.1) and
+    // these are exact key lookups, so an `Anthropic-RateLimit-…` from a
+    // title-casing gateway used to match nothing and return an empty array —
+    // which is also what a response with no quota headers looks like.
+    const found = foldHeaderNames(headers);
+    for (const bucket of BUCKETS) {
+        const limit = found[`anthropic-ratelimit-${bucket}-limit`];
+        const remaining = found[`anthropic-ratelimit-${bucket}-remaining`];
+        // Both or neither. A bucket with a limit and no remaining tells a caller
+        // nothing actionable, and reporting it as zero remaining would be a lie.
+        if (limit === undefined || remaining === undefined) {
+            continue;
+        }
+        rateLimits.push(new ProviderRateLimit(bucket, toInteger(limit), toInteger(remaining), parseResetTime(found[`anthropic-ratelimit-${bucket}-reset`])));
+    }
+    return rateLimits;
+}
+function toInteger(value) {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+}
+/**
+ * Anthropic sends an RFC 3339 timestamp where OpenAI sends a duration.
+ *
+ * An unparseable value becomes null rather than the epoch: a reset time of
+ * 1970 reads as "already reset" and would have a caller retry immediately into
+ * the same limit.
+ */
+function parseResetTime(value) {
+    if (value === undefined || value === '') {
+        return null;
+    }
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+//# sourceMappingURL=rate-limits.js.map

package/dist/providers/anthropic/rate-limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limits.js","sourceRoot":"","sources":["../../../src/providers/anthropic/rate-limits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;;GAIG;AACH,MAAM,OAAO,GAAG,CAAC,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,eAAe,CAAU,CAAC;AAEjF,sFAAsF;AACtF,MAAM,UAAU,eAAe,CAAC,OAAyC;IACvE,MAAM,UAAU,GAAwB,EAAE,CAAC;IAE3C,0EAA0E;IAC1E,oEAAoE;IACpE,yEAAyE;IACzE,kEAAkE;IAClE,MAAM,KAAK,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;IAEvC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG,KAAK,CAAC,uBAAuB,MAAM,QAAQ,CAAC,CAAC;QAC3D,MAAM,SAAS,GAAG,KAAK,CAAC,uBAAuB,MAAM,YAAY,CAAC,CAAC;QAEnE,yEAAyE;QACzE,yEAAyE;QACzE,IAAI,KAAK,KAAK,SAAS,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YACnD,SAAS;QACX,CAAC;QAED,UAAU,CAAC,IAAI,CACb,IAAI,iBAAiB,CACnB,MAAM,EACN,SAAS,CAAC,KAAK,CAAC,EAChB,SAAS,CAAC,SAAS,CAAC,EACpB,cAAc,CAAC,KAAK,CAAC,uBAAuB,MAAM,QAAQ,CAAC,CAAC,CAC7D,CACF,CAAC;IACJ,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,SAAS,SAAS,CAAC,KAAa;IAC9B,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAE1C,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;AAC3C,CAAC;AAED;;;;;;GAMG;AACH,SAAS,cAAc,CAAC,KAAyB;IAC/C,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QACxC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;IAE/B,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC;AACxD,CAAC"}

package/dist/providers/anthropic/stream-events.d.ts

@@ -0,0 +1,27 @@
+import { type JsonObject } from '../../json.js';
+import { type StreamEvent } from '../../streaming/events.js';
+/**
+ * Anthropic's stream, which needs MEMORY where OpenAI's does not.
+ *
+ * OpenAI repeats the identifiers on every event, so a payload can be mapped on
+ * its own and the mapper is a pure function. Anthropic does not: a
+ * `content_block_delta` carries only an INDEX, the message id arrived back at
+ * `message_start`, the stop reason arrives at `message_delta` and the stream
+ * ends at `message_stop`. Mapping one payload in isolation is impossible.
+ *
+ * So this is a class with state, and that difference is the provider's, not a
+ * design choice worth hiding. The alternative — emitting events with empty ids,
+ * or an end event with no reason — would keep the shape uniform by making the
+ * contents wrong.
+ */
+export declare class AnthropicStreamMapper {
+    #private;
+    /**
+     * Zero or one event for this payload.
+     *
+     * `ping` and `content_block_start` for a text block produce nothing a
+     * consumer can use; they are dropped rather than surfaced as noise.
+     */
+    map(payload: JsonObject): StreamEvent | null;
+}
+//# sourceMappingURL=stream-events.d.ts.map

package/dist/providers/anthropic/stream-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-events.d.ts","sourceRoot":"","sources":["../../../src/providers/anthropic/stream-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,eAAe,CAAC;AAK9D,OAAO,EAGL,KAAK,WAAW,EAMjB,MAAM,2BAA2B,CAAC;AAGnC;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAqB;;IAUhC;;;;;OAKG;IACH,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,WAAW,GAAG,IAAI;CAsI7C"}

package/dist/providers/anthropic/stream-events.js

@@ -0,0 +1,147 @@
+import { isJsonObject } from '../../json.js';
+import { readNullableNumber } from '../../internal/filters.js';
+import { FinishReason } from '../../enums.js';
+import { ToolCall } from '../../value-objects/tool-call.js';
+import { Usage } from '../../value-objects/usage.js';
+import { ErrorEvent, StreamEndEvent, StreamStartEvent, TextCompleteEvent, TextDeltaEvent, TextStartEvent, ToolCallEvent, } from '../../streaming/events.js';
+import { mapFinishReason } from './maps/finish-reason-map.js';
+/**
+ * Anthropic's stream, which needs MEMORY where OpenAI's does not.
+ *
+ * OpenAI repeats the identifiers on every event, so a payload can be mapped on
+ * its own and the mapper is a pure function. Anthropic does not: a
+ * `content_block_delta` carries only an INDEX, the message id arrived back at
+ * `message_start`, the stop reason arrives at `message_delta` and the stream
+ * ends at `message_stop`. Mapping one payload in isolation is impossible.
+ *
+ * So this is a class with state, and that difference is the provider's, not a
+ * design choice worth hiding. The alternative — emitting events with empty ids,
+ * or an end event with no reason — would keep the shape uniform by making the
+ * contents wrong.
+ */
+export class AnthropicStreamMapper {
+    #messageId = '';
+    #stopReason = {};
+    #usage = null;
+    /** Accumulated text and tool JSON, per content-block index. */
+    #blocks = new Map();
+    /**
+     * Zero or one event for this payload.
+     *
+     * `ping` and `content_block_start` for a text block produce nothing a
+     * consumer can use; they are dropped rather than surfaced as noise.
+     */
+    map(payload) {
+        switch (readString(payload.type)) {
+            case 'message_start':
+                return this.#messageStart(payload);
+            case 'content_block_start':
+                return this.#blockStart(payload);
+            case 'content_block_delta':
+                return this.#blockDelta(payload);
+            case 'content_block_stop':
+                return this.#blockStop(payload);
+            case 'message_delta':
+                this.#messageDelta(payload);
+                return null;
+            case 'message_stop':
+                return new StreamEndEvent(this.#finishReason(), this.#usage);
+            case 'error':
+                return new ErrorEvent(readString(readObject(payload.error)?.type) || 'unknown_error', readString(readObject(payload.error)?.message) || 'The provider reported an error mid-stream.');
+            default:
+                // `ping`, and anything Anthropic adds later. Ignored rather than fatal,
+                // for the same reason the OpenAI mapper ignores what it does not know:
+                // a provider's additive change must not become an outage.
+                return null;
+        }
+    }
+    #messageStart(payload) {
+        const message = readObject(payload.message);
+        this.#messageId = readString(message?.id);
+        this.#usage = usage(readObject(message?.usage));
+        return new StreamStartEvent(readString(message?.model));
+    }
+    #blockStart(payload) {
+        const index = readNumber(payload.index);
+        const block = readObject(payload.content_block);
+        const type = readString(block?.type);
+        this.#blocks.set(index, {
+            type,
+            text: '',
+            id: readString(block?.id),
+            name: readString(block?.name),
+        });
+        // A text block opening is worth announcing; a tool block opening is not,
+        // because the tool call is only meaningful once its arguments have arrived.
+        return type === 'text' ? new TextStartEvent(this.#messageId) : null;
+    }
+    #blockDelta(payload) {
+        const index = readNumber(payload.index);
+        const delta = readObject(payload.delta);
+        const block = this.#blocks.get(index);
+        if (block === undefined || delta === null) {
+            return null;
+        }
+        // Text and tool arguments arrive through the same event with different
+        // delta types. Both accumulate; only text is worth emitting per chunk,
+        // because a half-parsed JSON fragment is not something a consumer can use.
+        if (readString(delta.type) === 'text_delta') {
+            const text = readString(delta.text);
+            block.text += text;
+            return new TextDeltaEvent(text, this.#messageId);
+        }
+        if (readString(delta.type) === 'input_json_delta') {
+            block.text += readString(delta.partial_json);
+        }
+        return null;
+    }
+    #blockStop(payload) {
+        const block = this.#blocks.get(readNumber(payload.index));
+        if (block === undefined) {
+            return null;
+        }
+        // Truthful because it was accumulated. Anthropic's `content_block_stop`
+        // carries no text of its own, so emitting a complete event without the
+        // memory above would mean emitting an empty one.
+        return block.type === 'text'
+            ? new TextCompleteEvent(block.text, this.#messageId)
+            : new ToolCallEvent(new ToolCall(block.id, block.name, block.text), this.#messageId);
+    }
+    #messageDelta(payload) {
+        const delta = readObject(payload.delta);
+        if (delta !== null) {
+            this.#stopReason = delta;
+        }
+        // Anthropic reports output tokens here rather than at message_stop, and
+        // reports them CUMULATIVELY, so the last one wins rather than summing.
+        const tokens = readObject(payload.usage);
+        if (tokens !== null) {
+            // Rebuilt rather than mutated, so everything not restated here would be
+            // LOST. Prompt tokens were already carried forward for that reason; cache
+            // and thinking counts arrive at message_start and never again, so they
+            // need the same treatment.
+            this.#usage = new Usage(this.#usage?.promptTokens ?? 0, readNumber(tokens.output_tokens), this.#usage?.cacheWriteInputTokens ?? null, this.#usage?.cacheReadInputTokens ?? null, readNullableNumber(readObject(tokens.output_tokens_details)?.thinking_tokens) ??
+                this.#usage?.thoughtTokens ??
+                null);
+        }
+    }
+    #finishReason() {
+        return this.#stopReason.stop_reason === undefined ? FinishReason.Stop : mapFinishReason(this.#stopReason);
+    }
+}
+function usage(raw) {
+    if (raw === null) {
+        return null;
+    }
+    return new Usage(readNumber(raw.input_tokens), readNumber(raw.output_tokens), readNullableNumber(raw.cache_creation_input_tokens), readNullableNumber(raw.cache_read_input_tokens), readNullableNumber(readObject(raw.output_tokens_details)?.thinking_tokens));
+}
+function readObject(value) {
+    return isJsonObject(value) ? value : null;
+}
+function readString(value) {
+    return typeof value === 'string' ? value : '';
+}
+function readNumber(value) {
+    return typeof value === 'number' ? value : 0;
+}
+//# sourceMappingURL=stream-events.js.map