@alvin0/ai-agent-sdk-protocol-anthropic-messages 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 alvin0 (chaulamdinhai) <chaulamdinhai@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @alvin0/ai-agent-sdk-protocol-anthropic-messages
+
+Runtime: **Universal** (Edge/Worker, browser, Deno, Bun, and Node).
+
+```sh
+pnpm add @alvin0/ai-agent-sdk-core @alvin0/ai-agent-sdk-protocol-anthropic-messages
+```
+
+Universal Anthropic Messages wire schema, request serializer, stream translator, and dialect. It owns no endpoint, credentials, fetch implementation, filesystem access, or Node.js APIs.
+
+```ts
+import { anthropicMessagesProtocol } from '@alvin0/ai-agent-sdk-protocol-anthropic-messages'
+```
+
+Composition: `provider-author.protocol`. Lifecycle: `inert-value`; select it in
+`createRuntimeHttpProvider()` without any startup or cleanup obligation.
+
+The only runtime dependency is `@alvin0/ai-agent-sdk-core`.

package/dist/index.d.ts

@@ -0,0 +1,365 @@
+import { GenerateOptions, StreamChunk, UsageCounters } from "@alvin0/ai-agent-sdk-core";
+import { ModelTarget, ResolvedModelInfo } from "@alvin0/ai-agent-sdk-core/provider";
+//#region src/contract.d.ts
+/** The request fields a pure wire protocol is allowed to inspect. */
+interface ProtocolRequest {
+  readonly options: GenerateOptions;
+  readonly maxTokens: number;
+}
+/** One decoded SSE event, expressed without depending on an HTTP transport. */
+interface ProtocolSseEvent {
+  readonly event: string | undefined;
+  readonly data: string;
+}
+/** Protocol-internal chunks may carry a partial untrusted usage report. */
+type ProtocolStreamChunk = Exclude<StreamChunk, {
+  readonly type: 'usage';
+}> | {
+  readonly type: 'usage';
+  readonly usage: UsageCounters;
+};
+/** Structural protocol contract implemented without importing provider-http. */
+interface ProtocolDefinition<Dialect> {
+  readonly id: string;
+  readonly defaultDialect: Dialect;
+  endpointPath(request: ProtocolRequest, dialect: Dialect): string;
+  protocolHeaders?(dialect: Dialect): Record<string, string>;
+  serialize(request: ProtocolRequest, dialect: Dialect): unknown | Promise<unknown>;
+  translate(events: AsyncIterable<ProtocolSseEvent>, request: ProtocolRequest, displayName: string): AsyncGenerator<ProtocolStreamChunk>;
+}
+//#endregion
+//#region src/wire.d.ts
+/**
+ * The Anthropic Messages API wire shapes.
+ *
+ * These types never leave this folder. Keeping the vendor vocabulary quarantined
+ * here is what lets `serialize`/`translate` be the only two places that need
+ * updating when the API changes, and it stops provider-specific field names from
+ * leaking into the core.
+ *
+ * @module ai-agent-sdk/providers/anthropic/wire
+ */
+/** Image bytes as the Messages API accepts them. */
+type WireImageSource = {
+  type: 'base64';
+  media_type: string;
+  data: string;
+} | {
+  type: 'url';
+  url: string;
+};
+/** A request-side content block. */
+type WireRequestBlock = {
+  type: 'text';
+  text: string;
+  citations?: WireCitation[];
+} | {
+  type: 'image';
+  source: WireImageSource;
+} | {
+  type: 'tool_use';
+  id: string;
+  name: string;
+  input: unknown;
+} | {
+  type: 'tool_result';
+  tool_use_id: string;
+  content: WireToolResultContent[] | string;
+  is_error?: boolean;
+} |
+/**
+ * An echoed thinking block. `signature` is mandatory on the way back: the API
+ * verifies it to confirm the block is genuinely Claude's own reasoning.
+ */
+{
+  type: 'thinking';
+  thinking: string;
+  signature: string;
+} | {
+  type: 'redacted_thinking';
+  data: string;
+} | WireServerToolUseBlock | WireWebSearchToolResultBlock;
+interface WireServerToolUseBlock {
+  type: 'server_tool_use';
+  id: string;
+  name: string;
+  input: unknown;
+}
+interface WireWebSearchToolResultBlock {
+  type: 'web_search_tool_result';
+  tool_use_id: string;
+  content: unknown;
+  caller?: unknown;
+}
+interface WireCitation {
+  type: string;
+  [key: string]: unknown;
+}
+/** What a `tool_result` block may carry back to the model. */
+type WireToolResultContent = {
+  type: 'text';
+  text: string;
+} | {
+  type: 'image';
+  source: WireImageSource;
+};
+/** One request message. Only `user` and `assistant` exist; system text is a top-level field. */
+interface WireMessage {
+  role: 'user' | 'assistant';
+  content: WireRequestBlock[];
+}
+/** A host function offered to the model. */
+interface WireFunctionTool {
+  name: string;
+  description: string;
+  input_schema: Record<string, unknown>;
+}
+/** Anthropic-hosted web search. */
+interface WireWebSearchTool {
+  type: 'web_search_20250305';
+  name: 'web_search';
+  max_uses?: number;
+  allowed_domains?: string[];
+  blocked_domains?: string[];
+  user_location?: {
+    type: 'approximate';
+    city?: string;
+    region?: string;
+    country?: string;
+    timezone?: string;
+  };
+}
+type WireTool = WireFunctionTool | WireWebSearchTool;
+/** How the model must choose among the offered tools. */
+type WireToolChoice = {
+  type: 'auto';
+} | {
+  type: 'any';
+} | {
+  type: 'none';
+} | {
+  type: 'tool';
+  name: string;
+};
+/** Extended-thinking configuration. */
+type WireThinking = {
+  type: 'enabled';
+  budget_tokens: number;
+} | {
+  type: 'disabled';
+};
+interface WireOutputConfig {
+  format: {
+    type: 'json_schema';
+    schema: Readonly<Record<string, unknown>>;
+  };
+}
+/** The request body. */
+interface WireRequest {
+  model: string;
+  /** REQUIRED by this API, unlike most others — the adapter always resolves one. */
+  max_tokens: number;
+  messages: WireMessage[];
+  system?: string;
+  tools?: WireTool[];
+  tool_choice?: WireToolChoice;
+  temperature?: number;
+  top_p?: number;
+  stop_sequences?: string[];
+  thinking?: WireThinking;
+  output_config?: WireOutputConfig;
+  stream?: boolean;
+}
+/**
+ * Token accounting.
+ *
+ * `input_tokens` already EXCLUDES cached tokens, which is why this adapter passes
+ * the counts through unchanged — providers that fold cache hits into one prompt
+ * total have to subtract them back out to honour the SDK's disjoint convention.
+ */
+interface WireUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+  cache_creation_input_tokens?: number | null;
+  cache_read_input_tokens?: number | null;
+}
+/** Why generation stopped. */
+type WireStopReason = 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | 'pause_turn' | 'refusal';
+/** A response-side content block, as `content_block_start` announces it. */
+type WireResponseBlock = {
+  type: 'text';
+  text: string;
+} | {
+  type: 'thinking';
+  thinking: string;
+  signature?: string;
+} | {
+  type: 'redacted_thinking';
+  data: string;
+} | {
+  type: 'tool_use';
+  id: string;
+  name: string;
+  input: unknown;
+} | WireServerToolUseBlock | WireWebSearchToolResultBlock;
+/** Incremental updates to an open content block. */
+type WireDelta = {
+  type: 'text_delta';
+  text: string;
+} | {
+  type: 'input_json_delta';
+  partial_json: string;
+} | {
+  type: 'thinking_delta';
+  thinking: string;
+} |
+/** Arrives once, immediately before `content_block_stop`, for a thinking block. */
+{
+  type: 'signature_delta';
+  signature: string;
+} | {
+  type: 'citations_delta';
+  citation: WireCitation;
+};
+/** The streaming event union. */
+type WireStreamEvent = {
+  type: 'message_start';
+  message: {
+    id?: string;
+    model?: string;
+    usage?: WireUsage;
+  };
+} | {
+  type: 'content_block_start';
+  index: number;
+  content_block: WireResponseBlock;
+} | {
+  type: 'content_block_delta';
+  index: number;
+  delta: WireDelta;
+} | {
+  type: 'content_block_stop';
+  index: number;
+} | {
+  type: 'message_delta';
+  delta: {
+    stop_reason?: WireStopReason | null;
+    stop_sequence?: string | null;
+  };
+  usage?: WireUsage;
+} | {
+  type: 'message_stop';
+} | {
+  type: 'ping';
+} | {
+  type: 'error';
+  error: WireErrorBody;
+};
+/** The error payload, in both HTTP error bodies and mid-stream `error` events. */
+interface WireErrorBody {
+  type?: string;
+  message?: string;
+}
+/** An HTTP error response body. */
+interface WireErrorResponse {
+  type?: 'error';
+  error?: WireErrorBody;
+}
+//#endregion
+//#region src/serialize.d.ts
+/**
+ * Adapter-private state kept on a {@link ReasoningBlock} so a thinking block can
+ * be echoed back exactly.
+ *
+ * The signature is the load-bearing part: this API verifies it to confirm the
+ * block is genuinely the model's own reasoning, and a thinking block sent back
+ * without it is rejected.
+ */
+interface AnthropicReasoningState {
+  /** `thinking` for an ordinary block, `redacted_thinking` for an opaque one. */
+  kind: 'thinking' | 'redacted_thinking';
+  /** Cryptographic signature over the thinking content. */
+  signature?: string;
+  /** Opaque payload of a redacted block. */
+  data?: string;
+}
+/** How a reasoning effort becomes a thinking token budget. */
+type ThinkingBudgets = Readonly<Record<string, number>>;
+/** Options controlling how the request is built. */
+interface AnthropicSerializeOptions {
+  /** Effort id to thinking-token budget. An absent or zero budget disables thinking. */
+  budgets: ThinkingBudgets;
+}
+/**
+ * Build the Messages request body.
+ * @param request - the resolved request, model, and connection.
+ * @param options - thinking-budget mapping.
+ * @returns the wire body, ready to serialize.
+ */
+declare function serializeAnthropicRequest(request: ProtocolRequest, options: AnthropicSerializeOptions): WireRequest;
+//#endregion
+//#region src/protocol.d.ts
+/** Protocol id, usable as a stable string in configuration. */
+declare const ANTHROPIC_MESSAGES_PROTOCOL_ID = "anthropic-messages";
+/**
+ * The API version header value.
+ *
+ * Mandatory on every request. Stable across the entire lifetime of this API — new
+ * capabilities arrive as opt-in beta headers rather than a version bump — which is
+ * why it lives on the protocol instead of being restated by each endpoint.
+ */
+declare const ANTHROPIC_VERSION = "2023-06-01";
+/**
+ * Default reasoning efforts, expressed as thinking-token budgets.
+ *
+ * Budgets rather than an opaque level because that is what this API takes. The
+ * SDK's effort ids are a neutral surface over a provider-specific knob, and
+ * mapping them here is the whole reason `ReasoningEffortId` is opaque.
+ */
+declare const DEFAULT_THINKING_BUDGETS: ThinkingBudgets;
+/** Per-endpoint knobs of the Messages protocol. */
+interface AnthropicDialect {
+  /** Effort id to thinking-token budget. */
+  readonly budgets: ThinkingBudgets;
+  /** `anthropic-version` header value. */
+  readonly version: string;
+  /** Opt-in beta features, sent as `anthropic-beta`. */
+  readonly beta: readonly string[];
+}
+interface RuntimeProtocolRequest extends ProtocolRequest {
+  readonly model: ResolvedModelInfo;
+  readonly connection: {
+    readonly baseUrl: string;
+    readonly headers: Readonly<Record<string, string>>;
+  };
+}
+/** Marker-based runtime view, kept structurally independent from provider-http. */
+interface AnthropicMessagesProtocolDefinition {
+  readonly kind: 'http-wire-protocol';
+  readonly apiVersion: 1;
+  readonly id: string;
+  readonly defaultDialect: AnthropicDialect;
+  readonly exampleModel?: ModelTarget;
+  readonly endpointPath: (request: RuntimeProtocolRequest, dialect: AnthropicDialect) => string;
+  readonly protocolHeaders?: (dialect: AnthropicDialect) => Readonly<Record<string, string>>;
+  readonly serialize: (request: RuntimeProtocolRequest, dialect: AnthropicDialect) => Readonly<Record<string, unknown>>;
+  readonly translate: (events: AsyncIterable<ProtocolSseEvent>, request: RuntimeProtocolRequest, displayName: string) => AsyncGenerator<ProtocolStreamChunk>;
+}
+/** The Anthropic Messages wire protocol. */
+declare const anthropicMessagesProtocol: ProtocolDefinition<AnthropicDialect> & AnthropicMessagesProtocolDefinition;
+//#endregion
+//#region src/translate.d.ts
+/**
+ * Translate one Messages SSE stream.
+ *
+ * Owns termination. There is no `[DONE]` sentinel: the stream ends on
+ * `message_stop`, and a body that ends before that was truncated — a failure
+ * rather than a short answer.
+ * @param events - decoded SSE events.
+ * @param displayName - provider name, used in diagnostics.
+ * @returns the chunk stream.
+ */
+declare function translateAnthropicStream(events: AsyncIterable<ProtocolSseEvent>, displayName: string): AsyncGenerator<ProtocolStreamChunk>;
+//#endregion
+export { ANTHROPIC_MESSAGES_PROTOCOL_ID, ANTHROPIC_VERSION, type AnthropicDialect, type AnthropicMessagesProtocolDefinition, type AnthropicReasoningState, type AnthropicSerializeOptions, DEFAULT_THINKING_BUDGETS, type ProtocolDefinition, type ProtocolRequest, type ProtocolSseEvent, type ProtocolStreamChunk, type ThinkingBudgets, type WireCitation, type WireDelta, type WireErrorBody, type WireErrorResponse, type WireFunctionTool, type WireImageSource, type WireMessage, type WireOutputConfig, type WireRequest, type WireRequestBlock, type WireResponseBlock, type WireServerToolUseBlock, type WireStopReason, type WireStreamEvent, type WireThinking, type WireTool, type WireToolChoice, type WireToolResultContent, type WireUsage, type WireWebSearchTool, type WireWebSearchToolResultBlock, anthropicMessagesProtocol, serializeAnthropicRequest, translateAnthropicStream };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/contract.ts","../src/wire.ts","../src/serialize.ts","../src/protocol.ts","../src/translate.ts"],"mappings":";;;;UAGiB;WACN,SAAS;WACT;;;UAIM;WACN;WACA;;;KAIC,sBACR,QAAQ;WAAwB;;WACrB;WAAwB,OAAO;;;UAG7B,mBAAmB;WACzB;WACA,gBAAgB;EACzB,aAAa,SAAS,iBAAiB,SAAS;EAChD,iBAAiB,SAAS,UAAU;EACpC,UAAU,SAAS,iBAAiB,SAAS,oBAAoB;EACjE,UACE,QAAQ,cAAc,mBACtB,SAAS,iBACT,sBACC,eAAe;;;;;;;;;;;;;;;KClBR;EACN;EAAgB;EAAoB;;EACpC;EAAa;;;KAGP;EACN;EAAc;EAAc,YAAY;;EACxC;EAAe,QAAQ;;EACvB;EAAkB;EAAY;EAAc;;EAE9C;EACA;EACA,SAAS;EACT;;;;;;;EAME;EAAkB;EAAkB;;EACpC;EAA2B;IAC7B,yBACA;UAEa;EACf;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;;UAGe;EACf;GACC;;;KAIS;EACN;EAAc;;EACd;EAAe,QAAQ;;;UAGZ;EACf;EACA,SAAS;;;UAIM;EACf;EACA;EACA,cAAc;;;UAIC;EACf;EACA;EACA;EACA;EACA;EACA;IACE;IACA;IACA;IACA;IACA;;;KAIQ,WAAW,mBAAmB;;KAG9B;EACN;;EACA;;EACA;;EACA;EAAc;;;KAGR;EACN;EAAiB;;EACjB;;UAEW;EACf;IACE;IACA,QAAQ,SAAS;;;;UAKJ;EACf;;EAEA;EACA,UAAU;EACV;EACA,QAAQ;EACR,cAAc;EACd;EACA;EACA;EACA,WAAW;EACX,gBAAgB;EAChB;;;;;;;;;UAUe;EACf;EACA;EACA;EACA;;;KAIU;;KASA;EACN;EAAc;;EACd;EAAkB;EAAkB;;EACpC;EAA2B;;EAC3B;EAAkB;EAAY;EAAc;IAC9C,yBACA;;KAGQ;EACN;EAAoB;;EACpB;EAA0B;;EAC1B;EAAwB;;;;EAExB;EAAyB;;EACzB;EAAyB,UAAU;;;KAG7B;EACN;EAAuB;IAAW;IAAa;IAAgB,QAAQ;;;EACvE;EAA6B;EAAe,eAAe;;EAC3D;EAA6B;EAAe,OAAO;;EACnD;EAA4B;;EAE9B;EACA;IAAS,cAAc;IAAuB;;EAC9C,QAAQ;;EAEN;;EACA;;EACA;EAAe,OAAO;;;UAGX;EACf;EACA;;;UAIe;EACf;EACA,QAAQ;;;;;;;;;;;;UChJO;;EAEf;;EAEA;;EAEA;;;KAiOU,kBAAkB,SAAS;;UAGtB;;EAEf,SAAS;;;;;;;;iBAmCK,0BACd,SAAS,iBACT,SAAS,4BACR;;;;cCjTU;;;;;;;;cASA;;;;;;;;cASA,0BAA0B;;UAQtB;;WAEN,SAAS;;WAET;;WAEA;;UASD,+BAA+B;WAC9B,OAAO;WACP;aACE;aACA,SAAS,SAAS;;;;UAKd;WACN;WACA;WACA;WACA,gBAAgB;WAChB,eAAe;WACf,eAAe,SAAS,wBAAwB,SAAS;WACzD,mBAAmB,SAAS,qBAAqB,SAAS;WAC1D,YACP,SAAS,wBACT,SAAS,qBACN,SAAS;WACL,YACP,QAAQ,cAAc,mBACtB,SAAS,wBACT,wBACG,eAAe;;;cAIT,2BAA2B,mBAAmB,oBACvD;;;;;;;;;;;;;iBC6HmB,yBACrB,QAAQ,cAAc,mBACtB,sBACC,eAAe"}

package/dist/index.js

@@ -0,0 +1,638 @@
+import { CONTEXT_WINDOW_EXCEEDED_CODE, MODEL_ERROR_CODES, ModelError, QUOTA_EXCEEDED_CODE, ToolCallId, isContextWindowExceededError, isJsonValue, isNativeToolSchema, isQuotaExceededError } from "@alvin0/ai-agent-sdk-core";
+
+//#region src/serialize.ts
+/**
+* Normalized request to Anthropic Messages API wire JSON.
+*
+* Two things here differ sharply from the Responses API and are easy to get wrong:
+*
+* 1. `tool_use.input` is a parsed OBJECT, not a JSON string. Our normalized block
+*    keeps the raw string the model produced, so it is parsed on the way out.
+* 2. Consecutive same-role messages are MERGED. This is not cosmetic tidying —
+*    when a model makes three parallel tool calls, we produce three separate
+*    tool-result messages, and this API expects all three `tool_result` blocks in
+*    ONE user message. Without merging, parallel tool use breaks.
+*
+* @module ai-agent-sdk/providers/anthropic/serialize
+*/
+/** Read reasoning state back off a block, tolerating anything unexpected. */
+function reasoningStateOf(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const state = value;
+	if (state.kind !== "thinking" && state.kind !== "redacted_thinking") return void 0;
+	return {
+		kind: state.kind,
+		...typeof state.signature === "string" ? { signature: state.signature } : {},
+		...typeof state.data === "string" ? { data: state.data } : {}
+	};
+}
+/** Map an image source onto this API's tagged source object. */
+function imageSource(source) {
+	if (source.kind === "url") return {
+		type: "url",
+		url: source.url
+	};
+	if (source.kind === "base64") return {
+		type: "base64",
+		media_type: source.mediaType,
+		data: source.data
+	};
+	throw new ModelError("Anthropic image inputs support URL or base64 sources, not file ids", MODEL_ERROR_CODES.INVALID_REQUEST);
+}
+/** Restrict tool-result content to the block types this API accepts there. */
+function toolResultContent(blocks) {
+	const parts = [];
+	let textOnly = true;
+	for (const block of blocks) if (block.type === "text") parts.push({
+		type: "text",
+		text: block.text
+	});
+	else if (block.type === "image") {
+		textOnly = false;
+		parts.push({
+			type: "image",
+			source: imageSource(block.source)
+		});
+	}
+	if (textOnly) return parts.map((part) => part.type === "text" ? part.text : "").join("\n");
+	return parts;
+}
+/** Parse tool-call arguments into the object this API expects. */
+function toolInput(raw) {
+	if (raw.trim().length === 0) return {};
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return {};
+	}
+}
+function citationOf(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const citation = value;
+	return typeof citation.type === "string" ? structuredClone(citation) : void 0;
+}
+function nativeReplayBlocks(value) {
+	if (typeof value !== "object" || value === null) return [];
+	const state = value;
+	return [state.call, state.result].flatMap((candidate) => {
+		if (typeof candidate !== "object" || candidate === null) return [];
+		const block = candidate;
+		if (block.type === "server_tool_use" && typeof block.id === "string" && typeof block.name === "string") return [{
+			type: "server_tool_use",
+			id: block.id,
+			name: block.name,
+			input: structuredClone(block.input ?? {})
+		}];
+		if (block.type === "web_search_tool_result" && typeof block.tool_use_id === "string") return [{
+			type: "web_search_tool_result",
+			tool_use_id: block.tool_use_id,
+			content: structuredClone(block.content),
+			...block.caller === void 0 ? {} : { caller: structuredClone(block.caller) }
+		}];
+		return [];
+	});
+}
+/** Convert one normalized block to zero or more wire blocks. */
+function requestBlocks(block) {
+	switch (block.type) {
+		case "text": {
+			if (block.text.trim().length === 0) return [];
+			const citations = block.annotations?.flatMap((annotation) => {
+				if (annotation.type !== "url-citation") return [];
+				const citation = citationOf(annotation.providerState);
+				return citation === void 0 ? [] : [citation];
+			});
+			return [{
+				type: "text",
+				text: block.text,
+				...citations === void 0 || citations.length === 0 ? {} : { citations }
+			}];
+		}
+		case "image": return [{
+			type: "image",
+			source: imageSource(block.source)
+		}];
+		case "tool-call": return [{
+			type: "tool_use",
+			id: block.id,
+			name: block.name,
+			input: toolInput(block.arguments)
+		}];
+		case "tool-result": return [{
+			type: "tool_result",
+			tool_use_id: block.toolCallId,
+			content: toolResultContent(block.content),
+			...block.isError === true ? { is_error: true } : {}
+		}];
+		case "native-tool-call": return nativeReplayBlocks(block.providerState);
+		case "reasoning": {
+			const state = reasoningStateOf(block.providerState);
+			if (state === void 0) return [];
+			if (state.kind === "redacted_thinking") return state.data === void 0 ? [] : [{
+				type: "redacted_thinking",
+				data: state.data
+			}];
+			return state.signature === void 0 ? [] : [{
+				type: "thinking",
+				thinking: block.text,
+				signature: state.signature
+			}];
+		}
+		default: return [];
+	}
+}
+/**
+* Build the message list, merging consecutive same-role messages.
+*
+* See the module note for why merging matters.
+*/
+function messagesOf(messages) {
+	const result = [];
+	for (const message of messages) {
+		if (message.role === "system") continue;
+		const role = message.role === "assistant" ? "assistant" : "user";
+		const blocks = message.content.flatMap(requestBlocks);
+		if (blocks.length === 0) continue;
+		const previous = result.at(-1);
+		if (previous !== void 0 && previous.role === role) previous.content.push(...blocks);
+		else result.push({
+			role,
+			content: blocks
+		});
+	}
+	return result;
+}
+/** Collect the system prompt from the request plus any system-role messages. */
+function systemOf(request) {
+	const fromMessages = request.options.messages.filter((message) => message.role === "system").flatMap((message) => message.content).filter((block) => block.type === "text").map((block) => block.text);
+	const joined = (request.options.system === void 0 ? fromMessages : [request.options.system, ...fromMessages]).join("\n\n");
+	return joined.length === 0 ? void 0 : joined;
+}
+/** Map the neutral tool-choice vocabulary onto this API's. */
+function toolChoiceOf(choice) {
+	if (choice === "auto") return { type: "auto" };
+	if (choice === "none") return { type: "none" };
+	if (choice === "required") return { type: "any" };
+	return {
+		type: "tool",
+		name: choice.type === "native" ? nativeToolName(choice.name) : choice.name
+	};
+}
+function functionTool(tool) {
+	return {
+		name: tool.name,
+		description: tool.description,
+		input_schema: tool.parameters
+	};
+}
+function nativeToolName(name) {
+	if (name === "web-search") return "web_search";
+	return name.replaceAll("-", "_");
+}
+function webSearchTool(tool) {
+	if (tool.allowedDomains !== void 0 && tool.blockedDomains !== void 0) throw new ModelError("Anthropic web search accepts allowedDomains or blockedDomains, not both", MODEL_ERROR_CODES.INVALID_REQUEST);
+	return {
+		type: "web_search_20250305",
+		name: "web_search",
+		...tool.maxUses === void 0 ? {} : { max_uses: tool.maxUses },
+		...tool.allowedDomains === void 0 ? {} : { allowed_domains: [...tool.allowedDomains] },
+		...tool.blockedDomains === void 0 ? {} : { blocked_domains: [...tool.blockedDomains] },
+		...tool.userLocation === void 0 ? {} : { user_location: {
+			type: "approximate",
+			...tool.userLocation
+		} }
+	};
+}
+function toolOf(tool) {
+	if (!isNativeToolSchema(tool)) return functionTool(tool);
+	if (tool.name === "web-search") return webSearchTool(tool);
+	throw new ModelError(`Anthropic does not support the provider-native tool '${tool.name}'`, MODEL_ERROR_CODES.INVALID_REQUEST);
+}
+/**
+* Resolve the `thinking` field for this request.
+*
+* The budget must leave room for a real answer, so it is capped below
+* `max_tokens` — this API requires `budget_tokens < max_tokens` and rejects the
+* request otherwise.
+*/
+function thinkingOf(effort, maxTokens, budgets) {
+	if (effort === void 0) return void 0;
+	const requested = budgets[effort];
+	if (requested === void 0 || requested <= 0) return { type: "disabled" };
+	const capped = Math.min(requested, Math.floor(maxTokens * .75));
+	return capped < 1024 ? { type: "disabled" } : {
+		type: "enabled",
+		budget_tokens: capped
+	};
+}
+function outputConfig(format) {
+	if (format === void 0 || format.type === "text") return void 0;
+	return { format: {
+		type: "json_schema",
+		schema: format.schema
+	} };
+}
+/**
+* Build the Messages request body.
+* @param request - the resolved request, model, and connection.
+* @param options - thinking-budget mapping.
+* @returns the wire body, ready to serialize.
+*/
+function serializeAnthropicRequest(request, options) {
+	const { options: call } = request;
+	const system = systemOf(request);
+	const tools = call.tools === void 0 || call.tools.length === 0 ? void 0 : call.tools.map(toolOf);
+	const thinking = thinkingOf(call.reasoningEffort === void 0 ? void 0 : String(call.reasoningEffort), request.maxTokens, options.budgets);
+	const thinkingEnabled = thinking?.type === "enabled";
+	const output = outputConfig(call.outputFormat);
+	return {
+		model: call.model,
+		max_tokens: request.maxTokens,
+		messages: messagesOf(call.messages),
+		...system === void 0 ? {} : { system },
+		...tools === void 0 ? {} : { tools },
+		...call.toolChoice === void 0 ? {} : { tool_choice: toolChoiceOf(call.toolChoice) },
+		...!thinkingEnabled && call.temperature !== void 0 ? { temperature: call.temperature } : {},
+		...!thinkingEnabled && call.topP !== void 0 ? { top_p: call.topP } : {},
+		...call.stop === void 0 || call.stop.length === 0 ? {} : { stop_sequences: [...call.stop] },
+		...thinking === void 0 ? {} : { thinking },
+		...output === void 0 ? {} : { output_config: output },
+		stream: true
+	};
+}
+
+//#endregion
+//#region src/translate.ts
+/**
+* Anthropic Messages API SSE events to the SDK's chunk protocol.
+*
+* Notable differences from the Responses translation:
+*
+* - Block indices come straight from the provider. This API numbers content
+*   blocks contiguously from zero in emission order, which is already exactly
+*   what our protocol wants, so no remapping is needed.
+* - Usage arrives in TWO places: input counts on `message_start`, output counts on
+*   `message_delta`. They are accumulated and emitted once, before the finish.
+* - `input_tokens` here already EXCLUDES cached tokens, so unlike the Responses
+*   translation nothing is subtracted. Getting this backwards would under-report
+*   input on every cached call.
+*
+* @module ai-agent-sdk/providers/anthropic/translate
+*/
+function blockKind(type) {
+	switch (type) {
+		case "text": return "text";
+		case "thinking":
+		case "redacted_thinking": return "reasoning";
+		case "tool_use": return "tool-call";
+		case "server_tool_use": return "native-tool-call";
+		default: return;
+	}
+}
+function absorbUsage(target, usage) {
+	if (typeof usage !== "object" || usage === null) return;
+	if ("input_tokens" in usage) target.input = usage.input_tokens;
+	if ("output_tokens" in usage) target.output = usage.output_tokens;
+	if ("cache_read_input_tokens" in usage && usage.cache_read_input_tokens !== null) target.cacheRead = usage.cache_read_input_tokens;
+	if ("cache_creation_input_tokens" in usage && usage.cache_creation_input_tokens !== null) target.cacheWrite = usage.cache_creation_input_tokens;
+	target.seen = true;
+}
+function finalUsage(accumulated) {
+	if (!accumulated.seen) return void 0;
+	const output = {
+		...accumulated.input === void 0 ? {} : { inputTokens: accumulated.input },
+		...accumulated.output === void 0 ? {} : { outputTokens: accumulated.output },
+		...accumulated.cacheRead === void 0 || accumulated.cacheRead === 0 ? {} : { cacheReadTokens: accumulated.cacheRead },
+		...accumulated.cacheWrite === void 0 || accumulated.cacheWrite === 0 ? {} : { cacheWriteTokens: accumulated.cacheWrite }
+	};
+	const counters = [
+		accumulated.input,
+		accumulated.cacheRead ?? 0,
+		accumulated.cacheWrite ?? 0,
+		accumulated.output
+	];
+	if (counters.every(validUsageCounter)) output.totalTokens = counters.reduce((total, value) => total + value, 0);
+	return output;
+}
+function validUsageCounter(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+/** Map this API's stop reason onto ours. */
+function finishReason(stop) {
+	switch (stop) {
+		case "tool_use": return { kind: "tool-calls" };
+		case "max_tokens": return { kind: "max-tokens" };
+		case "refusal": return {
+			kind: "error",
+			failure: {
+				message: "the model refused to answer",
+				code: MODEL_ERROR_CODES.INVALID_REQUEST
+			}
+		};
+		default: return { kind: "stop" };
+	}
+}
+/** Build the authoritative block for a completed content block. */
+function closedBlock(open) {
+	switch (open.kind) {
+		case "text": return {
+			type: "text",
+			text: open.text,
+			...open.annotations.length === 0 ? {} : { annotations: open.annotations }
+		};
+		case "reasoning": {
+			const state = open.redactedData !== void 0 ? {
+				kind: "redacted_thinking",
+				data: open.redactedData
+			} : {
+				kind: "thinking",
+				...open.signature === void 0 ? {} : { signature: open.signature }
+			};
+			return {
+				type: "reasoning",
+				text: open.text,
+				providerState: state
+			};
+		}
+		case "tool-call": return {
+			type: "tool-call",
+			id: ToolCallId(open.callId),
+			name: open.name,
+			arguments: open.args.length > 0 ? open.args : "{}"
+		};
+		case "native-tool-call": {
+			const parsed = parsedArguments(open.args, open.nativeCall?.input);
+			const call = open.nativeCall ?? {
+				type: "server_tool_use",
+				id: open.callId,
+				name: "web_search",
+				input: parsed
+			};
+			return {
+				type: "native-tool-call",
+				id: open.callId,
+				name: open.name === "web_search" ? "web-search" : open.name.replaceAll("_", "-"),
+				arguments: parsed,
+				content: [],
+				providerState: {
+					call: {
+						...call,
+						input: parsed
+					},
+					...open.nativeResult === void 0 ? {} : { result: open.nativeResult }
+				}
+			};
+		}
+		default: return;
+	}
+}
+function parsedArguments(raw, fallback) {
+	if (raw.length === 0) return isJsonValue(fallback) ? fallback : {};
+	try {
+		const value = JSON.parse(raw);
+		return isJsonValue(value) ? value : {};
+	} catch {
+		return {};
+	}
+}
+function citationAnnotation(citation) {
+	if (citation.type !== "web_search_result_location" || typeof citation.url !== "string") return;
+	return {
+		type: "url-citation",
+		url: citation.url,
+		...typeof citation.title === "string" ? { title: citation.title } : {},
+		providerState: structuredClone(citation)
+	};
+}
+/**
+* Translate one Messages SSE stream.
+*
+* Owns termination. There is no `[DONE]` sentinel: the stream ends on
+* `message_stop`, and a body that ends before that was truncated — a failure
+* rather than a short answer.
+* @param events - decoded SSE events.
+* @param displayName - provider name, used in diagnostics.
+* @returns the chunk stream.
+*/
+async function* translateAnthropicStream(events, displayName) {
+	const open = /* @__PURE__ */ new Map();
+	const usage = {
+		input: void 0,
+		output: void 0,
+		cacheRead: void 0,
+		cacheWrite: void 0,
+		seen: false
+	};
+	let stop;
+	let terminated = false;
+	let emittedBlocks = 0;
+	for await (const raw of events) {
+		let event;
+		try {
+			event = JSON.parse(raw.data);
+		} catch (error) {
+			throw new ModelError(`${displayName} sent a malformed stream event`, MODEL_ERROR_CODES.MALFORMED_RESPONSE, { cause: error });
+		}
+		switch (event.type) {
+			case "message_start":
+				absorbUsage(usage, event.message.usage);
+				break;
+			case "content_block_start": {
+				if (event.content_block.type === "web_search_tool_result") {
+					const result = event.content_block;
+					const owner = [...open.values()].find((entry) => entry.kind === "native-tool-call" && entry.callId === result.tool_use_id);
+					if (owner !== void 0) {
+						owner.nativeResult = result;
+						const block = closedBlock(owner);
+						if (block !== void 0 && !owner.closed) {
+							owner.closed = true;
+							yield {
+								type: "block-end",
+								index: [...open.entries()].find(([, entry]) => entry === owner)?.[0] ?? event.index,
+								block
+							};
+						}
+					}
+					break;
+				}
+				const kind = blockKind(event.content_block.type);
+				if (kind === void 0) break;
+				const block = event.content_block;
+				const entry = {
+					kind,
+					text: block.type === "text" ? block.text : block.type === "thinking" ? block.thinking : "",
+					args: "",
+					callId: block.type === "tool_use" ? block.id : `block-${event.index}`,
+					name: block.type === "tool_use" || block.type === "server_tool_use" ? block.name : "",
+					signature: block.type === "thinking" ? block.signature : void 0,
+					redactedData: block.type === "redacted_thinking" ? block.data : void 0,
+					annotations: [],
+					nativeCall: block.type === "server_tool_use" ? block : void 0,
+					nativeResult: void 0,
+					closed: false
+				};
+				if (block.type === "server_tool_use") {
+					entry.callId = block.id;
+					entry.args = "";
+				}
+				open.set(event.index, entry);
+				emittedBlocks += 1;
+				yield {
+					type: "block-start",
+					index: event.index,
+					blockType: kind
+				};
+				break;
+			}
+			case "content_block_delta": {
+				const entry = open.get(event.index);
+				if (entry === void 0) break;
+				const delta = event.delta;
+				switch (delta.type) {
+					case "text_delta":
+						entry.text += delta.text;
+						yield {
+							type: "text-delta",
+							index: event.index,
+							text: delta.text
+						};
+						break;
+					case "thinking_delta":
+						entry.text += delta.thinking;
+						yield {
+							type: "reasoning-delta",
+							index: event.index,
+							text: delta.thinking
+						};
+						break;
+					case "signature_delta":
+						entry.signature = delta.signature;
+						break;
+					case "input_json_delta":
+						entry.args += delta.partial_json;
+						if (entry.kind === "tool-call") yield {
+							type: "tool-call-delta",
+							index: event.index,
+							id: ToolCallId(entry.callId),
+							...entry.name.length > 0 ? { name: entry.name } : {},
+							argumentsDelta: delta.partial_json
+						};
+						break;
+					case "citations_delta": {
+						const annotation = citationAnnotation(delta.citation);
+						if (annotation !== void 0) entry.annotations.push(annotation);
+						break;
+					}
+				}
+				break;
+			}
+			case "content_block_stop": {
+				const entry = open.get(event.index);
+				if (entry === void 0) break;
+				if (entry.kind === "native-tool-call") break;
+				const block = closedBlock(entry);
+				if (block !== void 0 && !entry.closed) {
+					entry.closed = true;
+					yield {
+						type: "block-end",
+						index: event.index,
+						block
+					};
+				}
+				break;
+			}
+			case "message_delta":
+				stop = event.delta.stop_reason;
+				absorbUsage(usage, event.usage);
+				break;
+			case "message_stop": {
+				for (const [index, entry] of open) {
+					if (entry.kind !== "native-tool-call" || entry.closed) continue;
+					const block = closedBlock(entry);
+					if (block !== void 0) yield {
+						type: "block-end",
+						index,
+						block
+					};
+					entry.closed = true;
+				}
+				const mapped = finalUsage(usage);
+				if (mapped !== void 0) yield {
+					type: "usage",
+					usage: mapped
+				};
+				if (emittedBlocks === 0) throw new ModelError(`${displayName} returned a response with no content`, "EMPTY_RESPONSE");
+				yield {
+					type: "finish",
+					reason: finishReason(stop)
+				};
+				terminated = true;
+				return;
+			}
+			case "error": {
+				const detail = [event.error.type, event.error.message].filter((part) => part !== void 0).join(" ");
+				throw new ModelError(event.error.message ?? `${displayName} reported a stream error`, event.error.type === "overloaded_error" ? MODEL_ERROR_CODES.SERVER : anthropicStreamErrorCode(event.error.type, detail));
+			}
+		}
+	}
+	if (!terminated) throw new ModelError(`${displayName} stream ended before message_stop`, MODEL_ERROR_CODES.STREAM_CLOSED);
+}
+function anthropicStreamErrorCode(type, detail) {
+	if (type === "authentication_error" || type === "permission_error") return MODEL_ERROR_CODES.AUTH;
+	if (isQuotaExceededError(detail)) return QUOTA_EXCEEDED_CODE;
+	if (type === "rate_limit_error") return MODEL_ERROR_CODES.RATE_LIMIT;
+	if (type === "api_error") return MODEL_ERROR_CODES.SERVER;
+	if (isContextWindowExceededError(detail)) return CONTEXT_WINDOW_EXCEEDED_CODE;
+	return MODEL_ERROR_CODES.INVALID_REQUEST;
+}
+
+//#endregion
+//#region src/protocol.ts
+/** Protocol id, usable as a stable string in configuration. */
+const ANTHROPIC_MESSAGES_PROTOCOL_ID = "anthropic-messages";
+/**
+* The API version header value.
+*
+* Mandatory on every request. Stable across the entire lifetime of this API — new
+* capabilities arrive as opt-in beta headers rather than a version bump — which is
+* why it lives on the protocol instead of being restated by each endpoint.
+*/
+const ANTHROPIC_VERSION = "2023-06-01";
+/**
+* Default reasoning efforts, expressed as thinking-token budgets.
+*
+* Budgets rather than an opaque level because that is what this API takes. The
+* SDK's effort ids are a neutral surface over a provider-specific knob, and
+* mapping them here is the whole reason `ReasoningEffortId` is opaque.
+*/
+const DEFAULT_THINKING_BUDGETS = Object.freeze({
+	off: 0,
+	low: 2048,
+	medium: 8192,
+	high: 24576
+});
+const DEFAULT_DIALECT = Object.freeze({
+	budgets: DEFAULT_THINKING_BUDGETS,
+	version: ANTHROPIC_VERSION,
+	beta: Object.freeze([])
+});
+/** The Anthropic Messages wire protocol. */
+const anthropicMessagesProtocol = Object.freeze({
+	kind: "http-wire-protocol",
+	apiVersion: 1,
+	id: ANTHROPIC_MESSAGES_PROTOCOL_ID,
+	defaultDialect: DEFAULT_DIALECT,
+	endpointPath: () => "/v1/messages",
+	protocolHeaders: (dialect) => ({
+		"anthropic-version": dialect.version,
+		...dialect.beta.length === 0 ? {} : { "anthropic-beta": dialect.beta.join(",") }
+	}),
+	serialize(request, dialect) {
+		return serializeAnthropicRequest(request, { budgets: dialect.budgets });
+	},
+	translate: (events, _request, displayName) => translateAnthropicStream(events, displayName)
+});
+
+//#endregion
+export { ANTHROPIC_MESSAGES_PROTOCOL_ID, ANTHROPIC_VERSION, DEFAULT_THINKING_BUDGETS, anthropicMessagesProtocol, serializeAnthropicRequest, translateAnthropicStream };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/serialize.ts","../src/translate.ts","../src/protocol.ts"],"sourcesContent":["/**\n * Normalized request to Anthropic Messages API wire JSON.\n *\n * Two things here differ sharply from the Responses API and are easy to get wrong:\n *\n * 1. `tool_use.input` is a parsed OBJECT, not a JSON string. Our normalized block\n *    keeps the raw string the model produced, so it is parsed on the way out.\n * 2. Consecutive same-role messages are MERGED. This is not cosmetic tidying —\n *    when a model makes three parallel tool calls, we produce three separate\n *    tool-result messages, and this API expects all three `tool_result` blocks in\n *    ONE user message. Without merging, parallel tool use breaks.\n *\n * @module ai-agent-sdk/providers/anthropic/serialize\n */\n\nimport {\n  isNativeToolSchema,\n  type ModelOutputFormat,\n  type ModelToolSchema,\n  type NativeWebSearchTool,\n  type ToolChoice,\n  type ToolSchema,\n} from '@alvin0/ai-agent-sdk-core'\nimport { MODEL_ERROR_CODES, ModelError } from '@alvin0/ai-agent-sdk-core'\nimport type { ContentBlock, ImageSource } from '@alvin0/ai-agent-sdk-core'\nimport type { Message } from '@alvin0/ai-agent-sdk-core'\nimport type { ProtocolRequest } from './contract.ts'\nimport type {\n  WireImageSource,\n  WireCitation,\n  WireMessage,\n  WireOutputConfig,\n  WireRequest,\n  WireRequestBlock,\n  WireThinking,\n  WireTool,\n  WireToolChoice,\n  WireToolResultContent,\n} from './wire.ts'\n\n/**\n * Adapter-private state kept on a {@link ReasoningBlock} so a thinking block can\n * be echoed back exactly.\n *\n * The signature is the load-bearing part: this API verifies it to confirm the\n * block is genuinely the model's own reasoning, and a thinking block sent back\n * without it is rejected.\n */\nexport interface AnthropicReasoningState {\n  /** `thinking` for an ordinary block, `redacted_thinking` for an opaque one. */\n  kind: 'thinking' | 'redacted_thinking'\n  /** Cryptographic signature over the thinking content. */\n  signature?: string\n  /** Opaque payload of a redacted block. */\n  data?: string\n}\n\n/** Read reasoning state back off a block, tolerating anything unexpected. */\nfunction reasoningStateOf(value: unknown): AnthropicReasoningState | undefined {\n  if (typeof value !== 'object' || value === null) return undefined\n  const state = value as AnthropicReasoningState\n  if (state.kind !== 'thinking' && state.kind !== 'redacted_thinking') return undefined\n  return {\n    kind: state.kind,\n    ...typeof state.signature === 'string' ? { signature: state.signature } : {},\n    ...typeof state.data === 'string' ? { data: state.data } : {},\n  }\n}\n\n/** Map an image source onto this API's tagged source object. */\nfunction imageSource(source: ImageSource): WireImageSource {\n  if (source.kind === 'url') return { type: 'url', url: source.url }\n  if (source.kind === 'base64') {\n    return { type: 'base64', media_type: source.mediaType, data: source.data }\n  }\n  throw new ModelError(\n    'Anthropic image inputs support URL or base64 sources, not file ids',\n    MODEL_ERROR_CODES.INVALID_REQUEST,\n  )\n}\n\n/** Restrict tool-result content to the block types this API accepts there. */\nfunction toolResultContent(blocks: readonly ContentBlock[]): WireToolResultContent[] | string {\n  const parts: WireToolResultContent[] = []\n  let textOnly = true\n  for (const block of blocks) {\n    if (block.type === 'text') parts.push({ type: 'text', text: block.text })\n    else if (block.type === 'image') {\n      textOnly = false\n      parts.push({ type: 'image', source: imageSource(block.source) })\n    }\n    // Anything else (a nested tool result, an extension block) has no\n    // representation inside a tool result and is dropped rather than guessed at.\n  }\n  if (textOnly) {\n    return parts.map(part => (part.type === 'text' ? part.text : '')).join('\\n')\n  }\n  return parts\n}\n\n/** Parse tool-call arguments into the object this API expects. */\nfunction toolInput(raw: string): unknown {\n  if (raw.trim().length === 0) return {}\n  try {\n    return JSON.parse(raw) as unknown\n  } catch {\n    // The model emitted invalid JSON. Sending `{}` keeps the conversation\n    // well-formed so the tool layer can report the problem back to the model,\n    // which is recoverable; failing the request here is not.\n    return {}\n  }\n}\n\nfunction citationOf(value: unknown): WireCitation | undefined {\n  if (typeof value !== 'object' || value === null) return undefined\n  const citation = value as Record<string, unknown>\n  return typeof citation.type === 'string' ? structuredClone(citation) as WireCitation : undefined\n}\n\nfunction nativeReplayBlocks(value: unknown): WireRequestBlock[] {\n  if (typeof value !== 'object' || value === null) return []\n  const state = value as Record<string, unknown>\n  const values = [state.call, state.result]\n  return values.flatMap((candidate): WireRequestBlock[] => {\n    if (typeof candidate !== 'object' || candidate === null) return []\n    const block = candidate as Record<string, unknown>\n    if (block.type === 'server_tool_use'\n      && typeof block.id === 'string'\n      && typeof block.name === 'string') {\n      return [{\n        type: 'server_tool_use', id: block.id, name: block.name,\n        input: structuredClone(block.input ?? {}),\n      }]\n    }\n    if (block.type === 'web_search_tool_result' && typeof block.tool_use_id === 'string') {\n      return [{\n        type: 'web_search_tool_result', tool_use_id: block.tool_use_id,\n        content: structuredClone(block.content),\n        ...block.caller === undefined ? {} : { caller: structuredClone(block.caller) },\n      }]\n    }\n    return []\n  })\n}\n\n/** Convert one normalized block to zero or more wire blocks. */\nfunction requestBlocks(block: ContentBlock): WireRequestBlock[] {\n  switch (block.type) {\n    case 'text': {\n      // Whitespace-only text is rejected by this API, so it is dropped.\n      if (block.text.trim().length === 0) return []\n      const citations = block.annotations?.flatMap((annotation): WireCitation[] => {\n        if (annotation.type !== 'url-citation') return []\n        const citation = citationOf(annotation.providerState)\n        return citation === undefined ? [] : [citation]\n      })\n      return [{\n        type: 'text', text: block.text,\n        ...citations === undefined || citations.length === 0 ? {} : { citations },\n      }]\n    }\n    case 'image':\n      return [{ type: 'image', source: imageSource(block.source) }]\n    case 'tool-call':\n      return [{\n        type: 'tool_use',\n        id: block.id,\n        name: block.name,\n        input: toolInput(block.arguments),\n      }]\n    case 'tool-result':\n      return [{\n        type: 'tool_result',\n        tool_use_id: block.toolCallId,\n        content: toolResultContent(block.content),\n        ...block.isError === true ? { is_error: true } : {},\n      }]\n    case 'native-tool-call':\n      return nativeReplayBlocks(block.providerState)\n    case 'reasoning': {\n      const state = reasoningStateOf(block.providerState)\n      if (state === undefined) {\n        // No signature means this cannot be replayed as a thinking block. Dropping\n        // it is correct: sending unsigned thinking is rejected outright.\n        return []\n      }\n      if (state.kind === 'redacted_thinking') {\n        return state.data === undefined ? [] : [{ type: 'redacted_thinking', data: state.data }]\n      }\n      return state.signature === undefined\n        ? []\n        : [{ type: 'thinking', thinking: block.text, signature: state.signature }]\n    }\n    default:\n      return []\n  }\n}\n\n/**\n * Build the message list, merging consecutive same-role messages.\n *\n * See the module note for why merging matters.\n */\nfunction messagesOf(messages: readonly Message[]): WireMessage[] {\n  const result: WireMessage[] = []\n  for (const message of messages) {\n    if (message.role === 'system') continue // hoisted to the `system` field\n    const role = message.role === 'assistant' ? 'assistant' : 'user'\n    const blocks = message.content.flatMap(requestBlocks)\n    if (blocks.length === 0) continue\n\n    const previous = result.at(-1)\n    if (previous !== undefined && previous.role === role) previous.content.push(...blocks)\n    else result.push({ role, content: blocks })\n  }\n  return result\n}\n\n/** Collect the system prompt from the request plus any system-role messages. */\nfunction systemOf(request: ProtocolRequest): string | undefined {\n  const fromMessages = request.options.messages\n    .filter(message => message.role === 'system')\n    .flatMap(message => message.content)\n    .filter((block): block is Extract<ContentBlock, { type: 'text' }> => block.type === 'text')\n    .map(block => block.text)\n  const all = request.options.system === undefined\n    ? fromMessages\n    : [request.options.system, ...fromMessages]\n  const joined = all.join('\\n\\n')\n  return joined.length === 0 ? undefined : joined\n}\n\n/** Map the neutral tool-choice vocabulary onto this API's. */\nfunction toolChoiceOf(choice: ToolChoice): WireToolChoice {\n  if (choice === 'auto') return { type: 'auto' }\n  if (choice === 'none') return { type: 'none' }\n  // \"call some tool\" is spelled `any` here, not `required`.\n  if (choice === 'required') return { type: 'any' }\n  return { type: 'tool', name: choice.type === 'native' ? nativeToolName(choice.name) : choice.name }\n}\n\nfunction functionTool(tool: ToolSchema): WireTool {\n  return { name: tool.name, description: tool.description, input_schema: tool.parameters }\n}\n\nfunction nativeToolName(name: string): string {\n  if (name === 'web-search') return 'web_search'\n  return name.replaceAll('-', '_')\n}\n\nfunction webSearchTool(tool: NativeWebSearchTool): WireTool {\n  if (tool.allowedDomains !== undefined && tool.blockedDomains !== undefined) {\n    throw new ModelError(\n      'Anthropic web search accepts allowedDomains or blockedDomains, not both',\n      MODEL_ERROR_CODES.INVALID_REQUEST,\n    )\n  }\n  return {\n    type: 'web_search_20250305',\n    name: 'web_search',\n    ...tool.maxUses === undefined ? {} : { max_uses: tool.maxUses },\n    ...tool.allowedDomains === undefined ? {} : { allowed_domains: [...tool.allowedDomains] },\n    ...tool.blockedDomains === undefined ? {} : { blocked_domains: [...tool.blockedDomains] },\n    ...tool.userLocation === undefined ? {} : {\n      user_location: { type: 'approximate', ...tool.userLocation },\n    },\n  }\n}\n\nfunction toolOf(tool: ModelToolSchema): WireTool {\n  if (!isNativeToolSchema(tool)) return functionTool(tool)\n  if (tool.name === 'web-search') return webSearchTool(tool)\n  throw new ModelError(\n    `Anthropic does not support the provider-native tool '${tool.name}'`,\n    MODEL_ERROR_CODES.INVALID_REQUEST,\n  )\n}\n\n/** How a reasoning effort becomes a thinking token budget. */\nexport type ThinkingBudgets = Readonly<Record<string, number>>\n\n/** Options controlling how the request is built. */\nexport interface AnthropicSerializeOptions {\n  /** Effort id to thinking-token budget. An absent or zero budget disables thinking. */\n  budgets: ThinkingBudgets\n}\n\n/**\n * Resolve the `thinking` field for this request.\n *\n * The budget must leave room for a real answer, so it is capped below\n * `max_tokens` — this API requires `budget_tokens < max_tokens` and rejects the\n * request otherwise.\n */\nfunction thinkingOf(\n  effort: string | undefined,\n  maxTokens: number,\n  budgets: ThinkingBudgets,\n): WireThinking | undefined {\n  if (effort === undefined) return undefined\n  const requested = budgets[effort]\n  if (requested === undefined || requested <= 0) return { type: 'disabled' }\n  // Leave at least a quarter of the budget for the visible answer.\n  const capped = Math.min(requested, Math.floor(maxTokens * 0.75))\n  // This API's own floor for extended thinking.\n  return capped < 1_024 ? { type: 'disabled' } : { type: 'enabled', budget_tokens: capped }\n}\n\nfunction outputConfig(format: ModelOutputFormat | undefined): WireOutputConfig | undefined {\n  if (format === undefined || format.type === 'text') return undefined\n  return { format: { type: 'json_schema', schema: format.schema } }\n}\n\n/**\n * Build the Messages request body.\n * @param request - the resolved request, model, and connection.\n * @param options - thinking-budget mapping.\n * @returns the wire body, ready to serialize.\n */\nexport function serializeAnthropicRequest(\n  request: ProtocolRequest,\n  options: AnthropicSerializeOptions,\n): WireRequest {\n  const { options: call } = request\n  const system = systemOf(request)\n  const tools = call.tools === undefined || call.tools.length === 0\n    ? undefined\n    : call.tools.map(toolOf)\n  const thinking = thinkingOf(\n    call.reasoningEffort === undefined ? undefined : String(call.reasoningEffort),\n    request.maxTokens,\n    options.budgets,\n  )\n  const thinkingEnabled = thinking?.type === 'enabled'\n  const output = outputConfig(call.outputFormat)\n\n  return {\n    model: call.model,\n    // Required by this API — unlike most others, omitting it is an error.\n    max_tokens: request.maxTokens,\n    messages: messagesOf(call.messages),\n    ...system === undefined ? {} : { system },\n    ...tools === undefined ? {} : { tools },\n    ...call.toolChoice === undefined ? {} : { tool_choice: toolChoiceOf(call.toolChoice) },\n    // Extended thinking is incompatible with sampling adjustments; sending both\n    // is rejected, so the sampling knobs are dropped when thinking is on.\n    ...!thinkingEnabled && call.temperature !== undefined\n      ? { temperature: call.temperature }\n      : {},\n    ...!thinkingEnabled && call.topP !== undefined ? { top_p: call.topP } : {},\n    ...call.stop === undefined || call.stop.length === 0\n      ? {}\n      : { stop_sequences: [...call.stop] },\n    ...thinking === undefined ? {} : { thinking },\n    ...output === undefined ? {} : { output_config: output },\n    stream: true,\n  }\n}\n","/**\n * Anthropic Messages API SSE events to the SDK's chunk protocol.\n *\n * Notable differences from the Responses translation:\n *\n * - Block indices come straight from the provider. This API numbers content\n *   blocks contiguously from zero in emission order, which is already exactly\n *   what our protocol wants, so no remapping is needed.\n * - Usage arrives in TWO places: input counts on `message_start`, output counts on\n *   `message_delta`. They are accumulated and emitted once, before the finish.\n * - `input_tokens` here already EXCLUDES cached tokens, so unlike the Responses\n *   translation nothing is subtracted. Getting this backwards would under-report\n *   input on every cached call.\n *\n * @module ai-agent-sdk/providers/anthropic/translate\n */\n\nimport {\n  CONTEXT_WINDOW_EXCEEDED_CODE,\n  MODEL_ERROR_CODES,\n  ModelError,\n  QUOTA_EXCEEDED_CODE,\n  isContextWindowExceededError,\n  isQuotaExceededError,\n} from '@alvin0/ai-agent-sdk-core'\nimport { ToolCallId } from '@alvin0/ai-agent-sdk-core'\nimport { isJsonValue, type JsonValue } from '@alvin0/ai-agent-sdk-core'\nimport type { ContentBlock, TextAnnotation } from '@alvin0/ai-agent-sdk-core'\nimport type { FinishReason, UsageCounters } from '@alvin0/ai-agent-sdk-core'\nimport type { ProtocolSseEvent, ProtocolStreamChunk } from './contract.ts'\nimport type { AnthropicReasoningState } from './serialize.ts'\nimport type {\n  WireCitation,\n  WireServerToolUseBlock,\n  WireStopReason,\n  WireStreamEvent,\n  WireUsage,\n  WireWebSearchToolResultBlock,\n} from './wire.ts'\n\n/** Which of our block types one wire block maps to. */\ntype BlockKind = 'text' | 'reasoning' | 'tool-call' | 'native-tool-call'\n\ninterface OpenBlock {\n  readonly kind: BlockKind\n  text: string\n  args: string\n  callId: string\n  name: string\n  signature: string | undefined\n  redactedData: string | undefined\n  annotations: TextAnnotation[]\n  nativeCall: WireServerToolUseBlock | undefined\n  nativeResult: WireWebSearchToolResultBlock | undefined\n  closed: boolean\n}\n\nfunction blockKind(type: string | undefined): BlockKind | undefined {\n  switch (type) {\n    case 'text': return 'text'\n    case 'thinking':\n    case 'redacted_thinking': return 'reasoning'\n    case 'tool_use': return 'tool-call'\n    case 'server_tool_use': return 'native-tool-call'\n    default: return undefined\n  }\n}\n\n/** Accumulated token counts, filled from two different events. */\ninterface UsageAccumulator {\n  input: unknown\n  output: unknown\n  cacheRead: unknown\n  cacheWrite: unknown\n  seen: boolean\n}\n\nfunction absorbUsage(target: UsageAccumulator, usage: WireUsage | undefined): void {\n  if (typeof usage !== 'object' || usage === null) return\n  if ('input_tokens' in usage) target.input = usage.input_tokens\n  if ('output_tokens' in usage) target.output = usage.output_tokens\n  if ('cache_read_input_tokens' in usage && usage.cache_read_input_tokens !== null) {\n    target.cacheRead = usage.cache_read_input_tokens\n  }\n  if ('cache_creation_input_tokens' in usage && usage.cache_creation_input_tokens !== null) {\n    target.cacheWrite = usage.cache_creation_input_tokens\n  }\n  target.seen = true\n}\n\nfunction finalUsage(accumulated: UsageAccumulator): UsageCounters | undefined {\n  if (!accumulated.seen) return undefined\n  const output: Record<string, unknown> = {\n    ...accumulated.input === undefined ? {} : { inputTokens: accumulated.input },\n    ...accumulated.output === undefined ? {} : { outputTokens: accumulated.output },\n    // Cache omission/null is authoritative zero for this protocol. Invalid\n    // present values are retained so the accounting boundary can record them.\n    ...accumulated.cacheRead === undefined || accumulated.cacheRead === 0\n      ? {} : { cacheReadTokens: accumulated.cacheRead },\n    ...accumulated.cacheWrite === undefined || accumulated.cacheWrite === 0\n      ? {} : { cacheWriteTokens: accumulated.cacheWrite },\n  }\n  const counters = [\n    accumulated.input,\n    accumulated.cacheRead ?? 0,\n    accumulated.cacheWrite ?? 0,\n    accumulated.output,\n  ]\n  if (counters.every(validUsageCounter)) {\n    output.totalTokens = counters.reduce<number>((total, value) => total + value, 0)\n  }\n  return output as UsageCounters\n}\n\nfunction validUsageCounter(value: unknown): value is number {\n  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0\n}\n\n/** Map this API's stop reason onto ours. */\nfunction finishReason(stop: WireStopReason | null | undefined): FinishReason {\n  switch (stop) {\n    case 'tool_use': return { kind: 'tool-calls' }\n    case 'max_tokens': return { kind: 'max-tokens' }\n    case 'refusal':\n      return {\n        kind: 'error',\n        failure: {\n          message: 'the model refused to answer',\n          code: MODEL_ERROR_CODES.INVALID_REQUEST,\n        },\n      }\n    // `end_turn`, `stop_sequence`, and `pause_turn` all mean the turn produced a\n    // complete answer as far as a caller is concerned.\n    default: return { kind: 'stop' }\n  }\n}\n\n/** Build the authoritative block for a completed content block. */\nfunction closedBlock(open: OpenBlock): ContentBlock | undefined {\n  switch (open.kind) {\n    case 'text':\n      return {\n        type: 'text', text: open.text,\n        ...open.annotations.length === 0 ? {} : { annotations: open.annotations },\n      }\n    case 'reasoning': {\n      const state: AnthropicReasoningState = open.redactedData !== undefined\n        ? { kind: 'redacted_thinking', data: open.redactedData }\n        : {\n          kind: 'thinking',\n          ...open.signature === undefined ? {} : { signature: open.signature },\n        }\n      return { type: 'reasoning', text: open.text, providerState: state }\n    }\n    case 'tool-call':\n      return {\n        type: 'tool-call',\n        id: ToolCallId(open.callId),\n        name: open.name,\n        arguments: open.args.length > 0 ? open.args : '{}',\n      }\n    case 'native-tool-call': {\n      const parsed = parsedArguments(open.args, open.nativeCall?.input)\n      const call: WireServerToolUseBlock = open.nativeCall ?? {\n        type: 'server_tool_use', id: open.callId, name: 'web_search', input: parsed,\n      }\n      return {\n        type: 'native-tool-call', id: open.callId,\n        name: open.name === 'web_search' ? 'web-search' : open.name.replaceAll('_', '-'),\n        arguments: parsed,\n        content: [],\n        providerState: {\n          call: { ...call, input: parsed },\n          ...open.nativeResult === undefined ? {} : { result: open.nativeResult },\n        },\n      }\n    }\n    default:\n      return undefined\n  }\n}\n\nfunction parsedArguments(raw: string, fallback?: unknown): JsonValue {\n  if (raw.length === 0) return isJsonValue(fallback) ? fallback : {}\n  try {\n    const value: unknown = JSON.parse(raw)\n    return isJsonValue(value) ? value : {}\n  } catch {\n    return {}\n  }\n}\n\nfunction citationAnnotation(citation: WireCitation): TextAnnotation | undefined {\n  if (citation.type !== 'web_search_result_location' || typeof citation.url !== 'string') {\n    return undefined\n  }\n  return {\n    type: 'url-citation', url: citation.url,\n    ...typeof citation.title === 'string' ? { title: citation.title } : {},\n    providerState: structuredClone(citation),\n  }\n}\n\n/**\n * Translate one Messages SSE stream.\n *\n * Owns termination. There is no `[DONE]` sentinel: the stream ends on\n * `message_stop`, and a body that ends before that was truncated — a failure\n * rather than a short answer.\n * @param events - decoded SSE events.\n * @param displayName - provider name, used in diagnostics.\n * @returns the chunk stream.\n */\nexport async function* translateAnthropicStream(\n  events: AsyncIterable<ProtocolSseEvent>,\n  displayName: string,\n): AsyncGenerator<ProtocolStreamChunk> {\n  const open = new Map<number, OpenBlock>()\n  const usage: UsageAccumulator = {\n    input: undefined, output: undefined, cacheRead: undefined, cacheWrite: undefined, seen: false,\n  }\n  let stop: WireStopReason | null | undefined\n  let terminated = false\n  let emittedBlocks = 0\n\n  for await (const raw of events) {\n    let event: WireStreamEvent\n    try {\n      event = JSON.parse(raw.data) as WireStreamEvent\n    } catch (error: unknown) {\n      throw new ModelError(\n        `${displayName} sent a malformed stream event`,\n        MODEL_ERROR_CODES.MALFORMED_RESPONSE,\n        { cause: error },\n      )\n    }\n\n    switch (event.type) {\n      case 'message_start': {\n        absorbUsage(usage, event.message.usage)\n        break\n      }\n\n      case 'content_block_start': {\n        if (event.content_block.type === 'web_search_tool_result') {\n          const result = event.content_block\n          const owner = [...open.values()].find(entry => entry.kind === 'native-tool-call'\n            && entry.callId === result.tool_use_id)\n          if (owner !== undefined) {\n            owner.nativeResult = result\n            const block = closedBlock(owner)\n            if (block !== undefined && !owner.closed) {\n              owner.closed = true\n              yield {\n                type: 'block-end',\n                index: [...open.entries()].find(([, entry]) => entry === owner)?.[0] ?? event.index,\n                block,\n              }\n            }\n          }\n          break\n        }\n        const kind = blockKind(event.content_block.type)\n        if (kind === undefined) break\n        const block = event.content_block\n        const entry: OpenBlock = {\n          kind,\n          text: block.type === 'text'\n            ? block.text\n            : block.type === 'thinking' ? block.thinking : '',\n          args: '',\n          callId: block.type === 'tool_use' ? block.id : `block-${event.index}`,\n          name: block.type === 'tool_use' || block.type === 'server_tool_use' ? block.name : '',\n          signature: block.type === 'thinking' ? block.signature : undefined,\n          redactedData: block.type === 'redacted_thinking' ? block.data : undefined,\n          annotations: [],\n          nativeCall: block.type === 'server_tool_use' ? block : undefined,\n          nativeResult: undefined,\n          closed: false,\n        }\n        if (block.type === 'server_tool_use') {\n          entry.callId = block.id\n          entry.args = ''\n        }\n        open.set(event.index, entry)\n        emittedBlocks += 1\n        yield { type: 'block-start', index: event.index, blockType: kind }\n        break\n      }\n\n      case 'content_block_delta': {\n        const entry = open.get(event.index)\n        if (entry === undefined) break\n        const delta = event.delta\n        switch (delta.type) {\n          case 'text_delta':\n            entry.text += delta.text\n            yield { type: 'text-delta', index: event.index, text: delta.text }\n            break\n          case 'thinking_delta':\n            entry.text += delta.thinking\n            yield { type: 'reasoning-delta', index: event.index, text: delta.thinking }\n            break\n          case 'signature_delta':\n            // Arrives once, just before the block closes. It carries no visible\n            // content, so it produces no chunk — only the state needed to replay\n            // this thinking block on a later request.\n            entry.signature = delta.signature\n            break\n          case 'input_json_delta':\n            entry.args += delta.partial_json\n            if (entry.kind === 'tool-call') {\n              yield {\n                type: 'tool-call-delta',\n                index: event.index,\n                id: ToolCallId(entry.callId),\n                ...entry.name.length > 0 ? { name: entry.name } : {},\n                argumentsDelta: delta.partial_json,\n              }\n            }\n            break\n          case 'citations_delta': {\n            const annotation = citationAnnotation(delta.citation)\n            if (annotation !== undefined) entry.annotations.push(annotation)\n            break\n          }\n          default:\n            break\n        }\n        break\n      }\n\n      case 'content_block_stop': {\n        const entry = open.get(event.index)\n        if (entry === undefined) break\n        if (entry.kind === 'native-tool-call') break\n        const block = closedBlock(entry)\n        if (block !== undefined && !entry.closed) {\n          entry.closed = true\n          yield { type: 'block-end', index: event.index, block }\n        }\n        break\n      }\n\n      case 'message_delta': {\n        stop = event.delta.stop_reason\n        absorbUsage(usage, event.usage)\n        break\n      }\n\n      case 'message_stop': {\n        for (const [index, entry] of open) {\n          if (entry.kind !== 'native-tool-call' || entry.closed) continue\n          const block = closedBlock(entry)\n          if (block !== undefined) yield { type: 'block-end', index, block }\n          entry.closed = true\n        }\n        const mapped = finalUsage(usage)\n        if (mapped !== undefined) yield { type: 'usage', usage: mapped }\n        if (emittedBlocks === 0) {\n          // A clean stop with no content at all. Reported as a failure rather\n          // than an empty message, because an empty message ends the turn with\n          // nothing for the caller to act on — and it is safe to retry.\n          throw new ModelError(\n            `${displayName} returned a response with no content`,\n            'EMPTY_RESPONSE',\n          )\n        }\n        yield { type: 'finish', reason: finishReason(stop) }\n        terminated = true\n        return\n      }\n\n      case 'error': {\n        const detail = [event.error.type, event.error.message]\n          .filter((part): part is string => part !== undefined)\n          .join(' ')\n        throw new ModelError(\n          event.error.message ?? `${displayName} reported a stream error`,\n          // `overloaded_error` mid-stream is the common case and must stay\n          // retryable, which the shared 5xx mapping gives us.\n          event.error.type === 'overloaded_error'\n            ? MODEL_ERROR_CODES.SERVER\n            : anthropicStreamErrorCode(event.error.type, detail),\n        )\n      }\n\n      // `ping` and any future event carry nothing this protocol needs.\n      default:\n        break\n    }\n  }\n\n  if (!terminated) {\n    throw new ModelError(\n      `${displayName} stream ended before message_stop`,\n      MODEL_ERROR_CODES.STREAM_CLOSED,\n    )\n  }\n}\n\nfunction anthropicStreamErrorCode(type: string | undefined, detail: string): string {\n  if (type === 'authentication_error' || type === 'permission_error') {\n    return MODEL_ERROR_CODES.AUTH\n  }\n  if (isQuotaExceededError(detail)) return QUOTA_EXCEEDED_CODE\n  if (type === 'rate_limit_error') return MODEL_ERROR_CODES.RATE_LIMIT\n  if (type === 'api_error') return MODEL_ERROR_CODES.SERVER\n  if (isContextWindowExceededError(detail)) return CONTEXT_WINDOW_EXCEEDED_CODE\n  return MODEL_ERROR_CODES.INVALID_REQUEST\n}\n","/**\n * The Anthropic Messages protocol, as a reusable {@link WireProtocol}.\n *\n * @module ai-agent-sdk/providers/protocols/anthropic-messages\n */\n\nimport type {\n  ProtocolDefinition,\n  ProtocolRequest,\n  ProtocolSseEvent,\n  ProtocolStreamChunk,\n} from './contract.ts'\nimport type { ModelTarget, ResolvedModelInfo } from '@alvin0/ai-agent-sdk-core/provider'\nimport { serializeAnthropicRequest, type ThinkingBudgets } from './serialize.ts'\nimport { translateAnthropicStream } from './translate.ts'\n\n/** Protocol id, usable as a stable string in configuration. */\nexport const ANTHROPIC_MESSAGES_PROTOCOL_ID = 'anthropic-messages'\n\n/**\n * The API version header value.\n *\n * Mandatory on every request. Stable across the entire lifetime of this API — new\n * capabilities arrive as opt-in beta headers rather than a version bump — which is\n * why it lives on the protocol instead of being restated by each endpoint.\n */\nexport const ANTHROPIC_VERSION = '2023-06-01'\n\n/**\n * Default reasoning efforts, expressed as thinking-token budgets.\n *\n * Budgets rather than an opaque level because that is what this API takes. The\n * SDK's effort ids are a neutral surface over a provider-specific knob, and\n * mapping them here is the whole reason `ReasoningEffortId` is opaque.\n */\nexport const DEFAULT_THINKING_BUDGETS: ThinkingBudgets = Object.freeze({\n  off: 0,\n  low: 2_048,\n  medium: 8_192,\n  high: 24_576,\n})\n\n/** Per-endpoint knobs of the Messages protocol. */\nexport interface AnthropicDialect {\n  /** Effort id to thinking-token budget. */\n  readonly budgets: ThinkingBudgets\n  /** `anthropic-version` header value. */\n  readonly version: string\n  /** Opt-in beta features, sent as `anthropic-beta`. */\n  readonly beta: readonly string[]\n}\n\nconst DEFAULT_DIALECT: AnthropicDialect = Object.freeze({\n  budgets: DEFAULT_THINKING_BUDGETS,\n  version: ANTHROPIC_VERSION,\n  beta: Object.freeze([]),\n})\n\ninterface RuntimeProtocolRequest extends ProtocolRequest {\n  readonly model: ResolvedModelInfo\n  readonly connection: {\n    readonly baseUrl: string\n    readonly headers: Readonly<Record<string, string>>\n  }\n}\n\n/** Marker-based runtime view, kept structurally independent from provider-http. */\nexport interface AnthropicMessagesProtocolDefinition {\n  readonly kind: 'http-wire-protocol'\n  readonly apiVersion: 1\n  readonly id: string\n  readonly defaultDialect: AnthropicDialect\n  readonly exampleModel?: ModelTarget\n  readonly endpointPath: (request: RuntimeProtocolRequest, dialect: AnthropicDialect) => string\n  readonly protocolHeaders?: (dialect: AnthropicDialect) => Readonly<Record<string, string>>\n  readonly serialize: (\n    request: RuntimeProtocolRequest,\n    dialect: AnthropicDialect,\n  ) => Readonly<Record<string, unknown>>\n  readonly translate: (\n    events: AsyncIterable<ProtocolSseEvent>,\n    request: RuntimeProtocolRequest,\n    displayName: string,\n  ) => AsyncGenerator<ProtocolStreamChunk>\n}\n\n/** The Anthropic Messages wire protocol. */\nexport const anthropicMessagesProtocol: ProtocolDefinition<AnthropicDialect>\n  & AnthropicMessagesProtocolDefinition = Object.freeze({\n  kind: 'http-wire-protocol' as const,\n  apiVersion: 1 as const,\n  id: ANTHROPIC_MESSAGES_PROTOCOL_ID,\n  defaultDialect: DEFAULT_DIALECT,\n  endpointPath: () => '/v1/messages',\n  protocolHeaders: (dialect: AnthropicDialect) => ({\n    'anthropic-version': dialect.version,\n    ...dialect.beta.length === 0 ? {} : { 'anthropic-beta': dialect.beta.join(',') },\n  }),\n  serialize(request: ProtocolRequest, dialect: AnthropicDialect): Readonly<Record<string, unknown>> {\n    const body: unknown = serializeAnthropicRequest(request, { budgets: dialect.budgets })\n    return body as Readonly<Record<string, unknown>>\n  },\n  // Params are annotated because `Object.freeze` erases the contextual typing the\n  // `WireProtocol` annotation would otherwise supply.\n  translate: (\n    events: AsyncIterable<ProtocolSseEvent>,\n    _request: ProtocolRequest,\n    displayName: string,\n  ): AsyncGenerator<ProtocolStreamChunk> => translateAnthropicStream(events, displayName),\n})\n\nexport type { ThinkingBudgets }\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@alvin0/ai-agent-sdk-protocol-anthropic-messages",
+  "author": {
+    "name": "alvin0 - chaulamdinhai",
+    "email": "chaulamdinhai@gmail.com"
+  },
+  "version": "0.1.0",
+  "description": "Universal Anthropic Messages wire schema, serializer, translator, and dialect for ai-agent-sdk",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alvin0/ai-agent-sdk.git",
+    "directory": "packages/protocol-anthropic-messages"
+  },
+  "homepage": "https://github.com/alvin0/ai-agent-sdk/tree/main/packages/protocol-anthropic-messages#readme",
+  "bugs": {
+    "url": "https://github.com/alvin0/ai-agent-sdk/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "@alvin0/ai-agent-sdk-core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@alvin0/ai-agent-sdk-core": "^0.1.0",
+    "@arethetypeswrong/cli": "0.18.5",
+    "playwright": "1.62.1",
+    "publint": "0.3.24",
+    "tsdown": "0.22.14",
+    "typescript": "7.0.2",
+    "vitest": "4.1.11",
+    "wrangler": "4.127.1"
+  },
+  "aiAgentSdk": {
+    "runtime": "universal",
+    "coreApi": 1,
+    "roles": [
+      "wire-protocol"
+    ]
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true});require('node:fs').rmSync('artifacts',{recursive:true,force:true})\"",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --config vitest.config.ts",
+    "pack": "pnpm pack --pack-destination artifacts",
+    "test:pack": "node ../../scripts/test-packed-protocol.mts protocol-anthropic-messages",
+    "check:publint": "publint",
+    "check:types": "attw --profile esm-only --pack ."
+  }
+}