@warlock.js/ai-anthropic 4.1.1

package/cjs/index.cjs

@@ -0,0 +1,785 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let _anthropic_ai_sdk = require("@anthropic-ai/sdk");
+_anthropic_ai_sdk = __toESM(_anthropic_ai_sdk, 1);
+let _warlock_js_ai = require("@warlock.js/ai");
+let _warlock_js_logger = require("@warlock.js/logger");
+
+//#region ../../@warlock.js/ai-anthropic/src/known-vision-models.ts
+/**
+* Model-name prefixes for Claude families that accept image input
+* (vision) on the Messages API.
+*
+* Every Claude 3, Claude 3.5/3.7, and Claude 4 family model is
+* multimodal, so the list covers both the dotted legacy naming
+* (`claude-3-haiku-...`, `claude-3-5-sonnet-...`) and the current
+* `claude-<tier>-4-*` naming (`claude-opus-4-7`, `claude-sonnet-4-6`,
+* `claude-haiku-4-5`). Pre-3 families (`claude-2`, `claude-instant`)
+* are text-only and intentionally absent.
+*
+* Matched as a prefix so dated variants (`claude-opus-4-20250514`) are
+* covered without listing every release tag. Devs can always override
+* per-model via `anthropic.model({ name, vision: true | false })` —
+* explicit config wins over inference in either direction.
+*/
+const VISION_CAPABLE_PREFIXES = [
+	"claude-3",
+	"claude-4",
+	"claude-opus-4",
+	"claude-sonnet-4",
+	"claude-haiku-4"
+];
+/**
+* Infer whether a given Claude model name supports vision based on the
+* known-prefix list. Unknown models default to `false` so that passing
+* an image attachment to an unsupported model surfaces a clear,
+* agent-side capability error instead of an opaque Anthropic 400.
+*
+* @example
+* inferVisionCapability("claude-sonnet-4-6");      // → true
+* inferVisionCapability("claude-3-5-sonnet-latest"); // → true
+* inferVisionCapability("claude-2.1");             // → false
+* inferVisionCapability("custom-proxy-llm");       // → false
+*/
+function inferVisionCapability(modelName) {
+	const normalized = modelName.toLowerCase();
+	return VISION_CAPABLE_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-anthropic/src/utils/map-stop-reason.ts
+const stopReasonMap = {
+	end_turn: "stop",
+	stop_sequence: "stop",
+	max_tokens: "length",
+	tool_use: "tool_calls"
+};
+/**
+* Map Anthropic's `stop_reason` to the normalized `FinishReason` union.
+*
+* `end_turn` / `stop_sequence` are both natural stops. `max_tokens`
+* maps to `length`. `tool_use` maps to `tool_calls`. Everything else —
+* `refusal` (policy intervention), `pause_turn` (incomplete
+* long-running turn), `null`, or any value a future API version adds —
+* falls through to `"error"` so the agent treats the trip as a
+* non-clean terminal rather than silently accepting a partial result.
+*
+* @example
+* mapStopReason("end_turn");  // "stop"
+* mapStopReason("tool_use");  // "tool_calls"
+* mapStopReason("refusal");   // "error"
+* mapStopReason(null);        // "error"
+*/
+function mapStopReason(raw) {
+	return stopReasonMap[raw ?? ""] ?? "error";
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-anthropic/src/utils/to-anthropic-messages.ts
+/**
+* Convert vendor-neutral `Message[]` into Anthropic's request shape.
+*
+* Anthropic differs from the OpenAI Chat protocol in three ways this
+* function absorbs:
+*
+* 1. **No `system` role.** System messages are concatenated (newline-
+*    separated) and returned separately as the top-level `system`
+*    parameter.
+* 2. **Tool results are `user` turns.** A neutral `tool` message becomes
+*    a `user` message whose content is a single `tool_result` block
+*    keyed by `tool_use_id`.
+* 3. **Tool calls are `tool_use` content blocks.** An assistant message
+*    carrying `toolCalls` becomes an `assistant` message whose content
+*    is an optional leading `text` block followed by one `tool_use`
+*    block per call.
+*
+* Consecutive same-role turns are left as-is — the Messages API merges
+* them server-side.
+*
+* @example
+* const { system, messages } = toAnthropicMessages([
+*   { role: "system", content: "Be concise." },
+*   { role: "user", content: "Hi" },
+* ]);
+* // system === "Be concise."
+* // messages === [{ role: "user", content: "Hi" }]
+*/
+function toAnthropicMessages(messages) {
+	const systemParts = [];
+	const mapped = [];
+	for (const message of messages) {
+		if (message.role === "system") {
+			systemParts.push(stringifyContent(message.content));
+			continue;
+		}
+		if (message.role === "tool") {
+			mapped.push({
+				role: "user",
+				content: [{
+					type: "tool_result",
+					tool_use_id: message.toolCallId ?? "",
+					content: stringifyContent(message.content)
+				}]
+			});
+			continue;
+		}
+		if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+			const blocks = [];
+			const text = stringifyContent(message.content);
+			if (text) blocks.push({
+				type: "text",
+				text
+			});
+			for (const toolCall of message.toolCalls) blocks.push({
+				type: "tool_use",
+				id: toolCall.id,
+				name: toolCall.name,
+				input: toolCall.input ?? {}
+			});
+			mapped.push({
+				role: "assistant",
+				content: blocks
+			});
+			continue;
+		}
+		if (message.role === "user" && Array.isArray(message.content)) {
+			mapped.push({
+				role: "user",
+				content: message.content.map(toAnthropicContentBlock)
+			});
+			continue;
+		}
+		mapped.push({
+			role: message.role === "assistant" ? "assistant" : "user",
+			content: stringifyContent(message.content)
+		});
+	}
+	return {
+		system: systemParts.length > 0 ? systemParts.join("\n\n") : void 0,
+		messages: mapped
+	};
+}
+/**
+* Multipart content is only meaningful on user messages — for any other
+* role collapse a `ContentPart[]` to its concatenated text so the wire
+* format stays valid. Plain strings pass through unchanged.
+*/
+function stringifyContent(content) {
+	if (typeof content === "string") return content;
+	return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+/**
+* Map a single resolved `ContentPart` to an Anthropic content block.
+* Text passes straight through; images become an `image` block with a
+* `url` source (remote) or a `base64` source (inlined bytes). The
+* agent has already resolved every attachment before it reaches here,
+* so this never reads files or fetches URLs.
+*/
+function toAnthropicContentBlock(part) {
+	if (part.type === "text") return {
+		type: "text",
+		text: part.text
+	};
+	if ("url" in part.source) return {
+		type: "image",
+		source: {
+			type: "url",
+			url: part.source.url
+		}
+	};
+	return {
+		type: "image",
+		source: {
+			type: "base64",
+			media_type: part.source.mediaType,
+			data: part.source.base64
+		}
+	};
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-anthropic/src/utils/to-anthropic-tools.ts
+/**
+* Convert vendor-neutral `ToolConfig[]` into Anthropic's `tools` array.
+* Uses the shared `extractJsonSchema` helper; Anthropic requires the
+* input schema to be a JSON-Schema object, so a non-object extraction
+* is coerced into an empty-object schema rather than rejected — the
+* tool still registers and the model simply sees no parameters.
+*
+* @example
+* const tools = toAnthropicTools([weatherTool, calculatorTool]);
+* await client.messages.create({ model, max_tokens, messages, tools });
+*/
+function toAnthropicTools(tools) {
+	if (!tools || tools.length === 0) return;
+	return tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		input_schema: toInputSchema(tool.input)
+	}));
+}
+/**
+* Coerce the extracted JSON Schema into Anthropic's `Tool.InputSchema`
+* shape (root must be `{ type: "object" }`). Anything that isn't an
+* object schema degrades to a parameterless object so registration
+* never fails on a malformed extractor result.
+*/
+function toInputSchema(input) {
+	const schema = (0, _warlock_js_ai.extractJsonSchema)(input);
+	if (schema && schema.type === "object") return schema;
+	return { type: "object" };
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-anthropic/src/utils/wrap-anthropic-error.ts
+/**
+* Wrap any thrown value caught inside the Anthropic adapter into the
+* appropriate `@warlock.js/ai` `AIError` subclass.
+*
+* **Dispatch strategy.** Anthropic has no per-error machine `code`; the
+* stable identifier is `error.type` on the response body (surfaced as
+* `APIError.type`). Dispatch prefers `type`, falls back to `status`
+* when the body was stripped (common with proxies). Name-based
+* detection catches transport-layer timeouts that never produced an
+* HTTP response. The `invalid_request_error` branch additionally
+* sniffs the message for Anthropic's "prompt is too long" phrasing,
+* which is the only signal that a 400 was a context-length overflow.
+*
+* `AIError` instances pass through unchanged so `catch/throw wrap(e)`
+* pipelines never double-wrap.
+*
+* @example
+* try {
+*   return await this.client.messages.create(...);
+* } catch (thrown) {
+*   throw wrapAnthropicError(thrown);
+* }
+*/
+function wrapAnthropicError(thrown) {
+	if (thrown instanceof _warlock_js_ai.AIError) return thrown;
+	const shape = toShape(thrown);
+	const context = buildContext(shape);
+	const message = shape.message ?? (thrown instanceof Error ? thrown.message : String(thrown));
+	if (isTimeout(thrown, shape)) return new _warlock_js_ai.ProviderTimeoutError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.type === "authentication_error" || shape.type === "permission_error") return new _warlock_js_ai.ProviderAuthError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.status === 401 || shape.status === 403) return new _warlock_js_ai.ProviderAuthError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.type === "billing_error") return new _warlock_js_ai.QuotaExceededError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.type === "rate_limit_error" || shape.status === 429) return new _warlock_js_ai.ProviderRateLimitError(message, {
+		cause: thrown,
+		context,
+		retryAfter: parseRetryAfter(shape.headers)
+	});
+	if (shape.type === "invalid_request_error" || isClientStatus(shape.status)) {
+		if (/prompt is too long/i.test(message)) return new _warlock_js_ai.ContextLengthExceededError(message, {
+			cause: thrown,
+			context
+		});
+		return new _warlock_js_ai.InvalidRequestError(message, {
+			cause: thrown,
+			context
+		});
+	}
+	return new _warlock_js_ai.ProviderError(message, {
+		cause: thrown,
+		context
+	});
+}
+/**
+* Read the raw error shape without depending on `instanceof APIError`
+* — proxies and re-wrappers strip the prototype chain. Duck-typing on
+* the visible fields is resilient to both.
+*/
+function toShape(thrown) {
+	if (thrown instanceof _anthropic_ai_sdk.APIError) return {
+		status: typeof thrown.status === "number" ? thrown.status : void 0,
+		type: thrown.type,
+		message: thrown.message,
+		headers: thrown.headers,
+		name: thrown.name,
+		requestId: thrown.requestID ?? void 0
+	};
+	if (typeof thrown === "object" && thrown !== null) {
+		const raw = thrown;
+		return {
+			status: typeof raw.status === "number" ? raw.status : void 0,
+			type: typeof raw.type === "string" ? raw.type : void 0,
+			message: typeof raw.message === "string" ? raw.message : void 0,
+			headers: isHeaderBag(raw.headers) ? raw.headers : void 0,
+			name: typeof raw.name === "string" ? raw.name : void 0,
+			requestId: readRequestId(raw)
+		};
+	}
+	return {};
+}
+/**
+* Decide whether the thrown value represents a timeout. The Anthropic
+* SDK throws `APIConnectionTimeoutError` for transport-level timeouts;
+* Node surfaces `ETIMEDOUT` / `ECONNABORTED` on the socket layer.
+* Either signal counts.
+*/
+function isTimeout(thrown, shape) {
+	if (thrown instanceof _anthropic_ai_sdk.APIConnectionTimeoutError) return true;
+	if (shape.name === "APIConnectionTimeoutError") return true;
+	if (typeof thrown === "object" && thrown !== null) {
+		const code = thrown.code;
+		if (code === "ETIMEDOUT" || code === "ECONNABORTED") return true;
+	}
+	return false;
+}
+/** True for HTTP 4xx — a client-side request problem, not a server fault. */
+function isClientStatus(status) {
+	return typeof status === "number" && status >= 400 && status < 500;
+}
+/**
+* Attach the raw diagnostic fields to `error.context` so consumers
+* have everything the provider surfaced without each subclass having
+* to redeclare them. Never includes `cause` — that lives on
+* `error.cause`.
+*/
+function buildContext(shape) {
+	const context = {};
+	if (shape.status !== void 0) context.status = shape.status;
+	if (shape.type) context.type = shape.type;
+	if (shape.requestId) context.requestId = shape.requestId;
+	return context;
+}
+/** Anthropic exposes the request id as `requestID`; some proxies use `request_id`. */
+function readRequestId(raw) {
+	if (typeof raw.requestID === "string") return raw.requestID;
+	if (typeof raw.request_id === "string") return raw.request_id;
+}
+function isHeaderBag(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Read a header value from either a `Headers` instance or a plain record. */
+function readHeader(headers, name) {
+	if (typeof headers.get === "function") return headers.get(name) ?? void 0;
+	const record = headers;
+	return record[name] ?? record[name.toLowerCase()];
+}
+/**
+* Parse the `Retry-After` response header (seconds per HTTP spec) into
+* milliseconds so consumers can feed it straight to `setTimeout`.
+* Returns `undefined` when missing or unparseable.
+*/
+function parseRetryAfter(headers) {
+	if (!headers) return;
+	const raw = readHeader(headers, "retry-after") ?? readHeader(headers, "Retry-After");
+	if (!raw) return;
+	const seconds = Number(raw);
+	if (!Number.isFinite(seconds) || seconds < 0) return;
+	return Math.round(seconds * 1e3);
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-anthropic/src/model.ts
+const LOG_MODULE = "ai.anthropic";
+/**
+* Anthropic requires `max_tokens` on every request (unlike OpenAI,
+* where it is optional). When neither the per-call option nor the
+* model config supplies one, fall back to a generous default so a
+* caller who never thought about token caps still gets a complete
+* answer instead of a 400.
+*/
+const DEFAULT_MAX_TOKENS = 4096;
+/**
+* Anthropic-backed implementation of `ModelContract`.
+*
+* **Role.** The provider-facing bridge between the vendor-neutral
+* `@warlock.js/ai` agent runtime and the official `@anthropic-ai/sdk`
+* Messages API. Agents, workflows, and supervisors never talk to
+* Anthropic directly — they hold a `ModelContract`, and this class is
+* what makes that contract concrete for Claude models.
+*
+* **Responsibility.**
+* - Owns: a long-lived `Anthropic` client + frozen `ModelConfig`
+*   (name, temperature, maxTokens) used as defaults for every call.
+* - Owns: translating vendor-neutral `Message[]` / `ToolConfig[]` into
+*   Anthropic wire shapes (system hoisting, `tool_use` / `tool_result`
+*   blocks) on the way out, and translating Anthropic's content-block
+*   response (text, tool calls, stop reason, usage) back into the
+*   neutral shapes on the way in.
+* - Does NOT own: dispatching tools, deciding whether to loop, tracking
+*   conversation history, or retrying on failure — those are agent
+*   concerns. The model is a stateless (per-call) protocol adapter.
+*
+* Because it holds a live client and shared defaults, it is modeled as
+* a class (see §4.2 of code-style.md — "long-lived state across
+* calls").
+*
+* @example
+* import Anthropic from "@anthropic-ai/sdk";
+* const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+* const model = new AnthropicModel(client, { name: "claude-sonnet-4-6" });
+*
+* const myAgent = agent({
+*   model,
+*   systemPrompt: "You are a helpful assistant.",
+*   tools: [searchTool],
+* });
+*
+* const result = await myAgent.execute("Summarize today's news.");
+*/
+var AnthropicModel = class {
+	constructor(client, config, provider = "anthropic") {
+		this.logger = _warlock_js_logger.log;
+		this.client = client;
+		this.config = config;
+		this.name = config.name;
+		this.provider = provider;
+		this.pricing = config.pricing;
+		this.capabilities = {
+			structuredOutput: config.structuredOutput ?? true,
+			vision: config.vision ?? inferVisionCapability(config.name)
+		};
+	}
+	/**
+	* Single-shot completion. Sends the full message list to the Messages
+	* endpoint, waits for the terminal response, and reshapes it into a
+	* vendor-neutral `ModelResponse`. Per-call `options` override the
+	* instance's `ModelConfig` defaults for this call only.
+	*/
+	async complete(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting call to messages.create", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: false,
+			toolCount: options?.tools?.length ?? 0
+		});
+		let response;
+		try {
+			response = await this.client.messages.create({
+				...this.buildParams(messages, options),
+				stream: false
+			}, options?.signal ? { signal: options.signal } : void 0);
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		const finishReason = mapStopReason(response.stop_reason);
+		const usage = this.extractUsage(response.usage);
+		const toolCalls = this.extractToolCalls(response.content);
+		this.logger.debug(LOG_MODULE, "response", "call to messages.create succeeded", {
+			finishReason,
+			usage
+		});
+		return {
+			content: this.extractText(response.content),
+			finishReason,
+			usage,
+			toolCalls
+		};
+	}
+	/**
+	* Incremental streaming completion. Yields neutral `ModelStreamChunk`s
+	* — `delta` for text tokens, `tool-call` once a `tool_use` block's
+	* arguments have fully accumulated, and a terminal `done` carrying the
+	* final finish reason + usage totals. Callers consume it with
+	* `for await`.
+	*/
+	async *stream(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting streaming call to messages.create", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: true,
+			toolCount: options?.tools?.length ?? 0
+		});
+		let stream;
+		try {
+			stream = await this.client.messages.create({
+				...this.buildParams(messages, options),
+				stream: true
+			}, options?.signal ? { signal: options.signal } : void 0);
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		let rawStopReason = null;
+		const usage = {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		const toolBlocks = /* @__PURE__ */ new Map();
+		try {
+			for await (const event of stream) {
+				if (event.type === "message_start") {
+					usage.input = event.message.usage.input_tokens ?? 0;
+					const cached = event.message.usage.cache_read_input_tokens;
+					if (cached !== null && cached !== void 0 && cached > 0) usage.cachedTokens = cached;
+					continue;
+				}
+				if (event.type === "content_block_start") {
+					const block = event.content_block;
+					if (block.type === "tool_use") toolBlocks.set(event.index, {
+						id: block.id,
+						name: block.name,
+						json: ""
+					});
+					continue;
+				}
+				if (event.type === "content_block_delta") {
+					if (event.delta.type === "text_delta") yield {
+						type: "delta",
+						content: event.delta.text
+					};
+					else if (event.delta.type === "input_json_delta") {
+						const accumulator = toolBlocks.get(event.index);
+						if (accumulator) accumulator.json += event.delta.partial_json;
+					}
+					continue;
+				}
+				if (event.type === "content_block_stop") {
+					const accumulator = toolBlocks.get(event.index);
+					if (accumulator) {
+						yield {
+							type: "tool-call",
+							id: accumulator.id,
+							name: accumulator.name,
+							input: (0, _warlock_js_ai.safeJsonParse)(accumulator.json, {})
+						};
+						toolBlocks.delete(event.index);
+					}
+					continue;
+				}
+				if (event.type === "message_delta") {
+					rawStopReason = event.delta.stop_reason ?? rawStopReason;
+					usage.output = event.usage.output_tokens ?? usage.output;
+				}
+			}
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		usage.total = usage.input + usage.output;
+		const finishReason = mapStopReason(rawStopReason);
+		this.logger.debug(LOG_MODULE, "response", "Streaming call to messages.create succeeded", {
+			finishReason,
+			usage
+		});
+		yield {
+			type: "done",
+			finishReason,
+			usage
+		};
+	}
+	/**
+	* Assemble the Anthropic request body shared by `complete()` and
+	* `stream()` (each adds its own `stream` literal so the SDK's create
+	* overload resolves to the right return type). Hoists the system
+	* prompt out of `messages`, resolves `max_tokens` (required by
+	* Anthropic) with the documented default, and conditionally attaches
+	* temperature, tools, and native structured output.
+	*/
+	buildParams(messages, options) {
+		const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
+		const temperature = options?.temperature ?? this.config.temperature;
+		return {
+			model: this.name,
+			max_tokens: options?.maxTokens ?? this.config.maxTokens ?? DEFAULT_MAX_TOKENS,
+			messages: anthropicMessages,
+			...system ? { system } : {},
+			...temperature !== void 0 ? { temperature } : {},
+			...this.buildTools(options?.tools),
+			...this.buildStructuredOutput(options?.responseSchema)
+		};
+	}
+	/**
+	* Spread-friendly tools fragment. Returns an empty object when no
+	* tools were supplied so the caller can unconditionally spread it.
+	*/
+	buildTools(tools) {
+		const mapped = toAnthropicTools(tools);
+		return mapped ? { tools: mapped } : {};
+	}
+	/**
+	* Translate the neutral `responseSchema` option into Anthropic's
+	* native `output_config.format` (JSON-schema structured outputs).
+	*
+	* Only emitted when the model declares the `structuredOutput`
+	* capability AND the schema is a proper root-object JSON Schema —
+	* Anthropic rejects non-object roots. When the capability is off
+	* (config override) or the schema is non-object, returns an empty
+	* object: the agent has already injected a soft schema hint into the
+	* system prompt as the fallback, and client-side `validate()` still
+	* enforces shape.
+	*/
+	buildStructuredOutput(responseSchema) {
+		if (!responseSchema || !this.capabilities.structuredOutput) return {};
+		if (responseSchema.type !== "object" || typeof responseSchema.properties !== "object") return {};
+		return { output_config: { format: {
+			type: "json_schema",
+			schema: responseSchema
+		} } };
+	}
+	/**
+	* Concatenate every `text` content block into the single neutral
+	* `content` string. `tool_use` and other block types are ignored
+	* here — tool calls are surfaced separately via `extractToolCalls`.
+	*/
+	extractText(content) {
+		return content.filter((block) => block.type === "text").map((block) => block.text).join("");
+	}
+	/**
+	* Reshape Anthropic's `tool_use` content blocks into the neutral
+	* `ModelToolCallRequest[]`. Returns `undefined` when the model
+	* requested no tools so callers can branch on presence.
+	*/
+	extractToolCalls(content) {
+		const toolUses = content.filter((block) => block.type === "tool_use");
+		if (toolUses.length === 0) return;
+		return toolUses.map((block) => ({
+			id: block.id,
+			name: block.name,
+			input: block.input ?? {}
+		}));
+	}
+	/**
+	* Normalize Anthropic's `usage` block into the neutral `Usage` shape.
+	* Anthropic reports `input_tokens` / `output_tokens` separately with
+	* no pre-summed total, so `total` is computed. Cache-read tokens are
+	* surfaced as `cachedTokens` only when non-zero.
+	*/
+	extractUsage(raw) {
+		const input = raw.input_tokens ?? 0;
+		const output = raw.output_tokens ?? 0;
+		const cached = raw.cache_read_input_tokens;
+		return {
+			input,
+			output,
+			total: input + output,
+			...cached !== null && cached !== void 0 && cached > 0 ? { cachedTokens: cached } : {}
+		};
+	}
+	/**
+	* Wrap a thrown provider error into the typed `AIError` hierarchy and
+	* emit the standard error log line before it propagates. Shared by
+	* every catch site so the log shape stays identical.
+	*/
+	logAndWrap(thrown) {
+		const wrapped = wrapAnthropicError(thrown);
+		this.logger.error(LOG_MODULE, "error", wrapped.message, {
+			code: wrapped.code,
+			context: wrapped.context
+		});
+		return wrapped;
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/ai-anthropic/src/sdk.ts
+/**
+* Anthropic-backed implementation of `SDKAdapterContract`.
+*
+* **Role.** The package entry point for Claude models via the official
+* `@anthropic-ai/sdk`. A single `AnthropicSDK` instance holds one live
+* `Anthropic` client, shared by every `ModelContract` it produces via
+* `model()`. Users construct one SDK per account and reuse it across
+* all agents, workflows, and supervisors that target Anthropic.
+*
+* **Responsibility.**
+* - Owns: a long-lived `Anthropic` client (authentication, base URL)
+*   and its lifetime scope. Factory for `AnthropicModel` instances —
+*   each model call gets a reference to the same client.
+* - Does NOT own: anything per-call (tool execution, message history,
+*   streaming loop) — those live in `AnthropicModel` and the agent
+*   runtime. Does NOT implement `embedder()`: Anthropic ships no
+*   first-party embeddings API (the contract marks it optional).
+*
+* Modeled as a class (see §4.2 of code-style.md — "long-lived state
+* across many calls"): the `Anthropic` client is heavy to construct
+* and designed to be reused; keeping it on `this` makes that reuse
+* explicit and aligns with the `new Anthropic(...)` upstream
+* convention.
+*
+* @example
+* const anthropic = new AnthropicSDK({ apiKey: process.env.ANTHROPIC_API_KEY! });
+* const model = anthropic.model({ name: "claude-sonnet-4-6", temperature: 0.7 });
+* const tokens = await anthropic.count("Hello world");
+*
+* @example
+* // Compose into an `ai.anthropic` namespace for ergonomic agent wiring
+* const ai = { agent, tool, systemPrompt, anthropic: new AnthropicSDK({ apiKey }) };
+* const myAgent = ai.agent({ model: ai.anthropic.model({ name: "claude-haiku-4-5" }) });
+*/
+var AnthropicSDK = class {
+	constructor(config) {
+		this.client = new _anthropic_ai_sdk.default({
+			apiKey: config.apiKey,
+			baseURL: config.baseURL
+		});
+		this.provider = config.provider ?? "anthropic";
+		this.pricing = config.pricing;
+	}
+	/**
+	* Build an `AnthropicModel` bound to this SDK's client. Each call
+	* returns a fresh model instance, but all instances share the
+	* underlying `Anthropic` client — connection pools, rate limits, and
+	* authentication stay unified across every model produced here. The
+	* SDK's `provider` label is forwarded so every model self-identifies
+	* as coming from the same upstream.
+	*
+	* Pricing resolution: per-model `config.pricing` wins; otherwise the
+	* SDK-level registry entry keyed by `config.name`; otherwise
+	* `undefined` (no cost computed).
+	*/
+	model(config) {
+		const resolvedPricing = config.pricing ?? this.pricing?.[config.name];
+		const resolvedConfig = resolvedPricing === config.pricing ? config : {
+			...config,
+			pricing: resolvedPricing
+		};
+		return new AnthropicModel(this.client, resolvedConfig, this.provider);
+	}
+	/**
+	* Rough token-count estimate for a given text. Uses the
+	* character-heuristic (`approximateTokenCount`) from the core package
+	* — good enough for budgeting and quota guards, not for billing.
+	* Anthropic does expose a `messages.countTokens` endpoint, but that
+	* is a network round-trip; `count()` is intentionally offline and
+	* synchronous-cost. The optional model id is reserved for future
+	* per-model tokenizer dispatch; currently ignored.
+	*/
+	async count(text, _model) {
+		return (0, _warlock_js_ai.approximateTokenCount)(text);
+	}
+};
+
+//#endregion
+exports.AnthropicSDK = AnthropicSDK;
+//# sourceMappingURL=index.cjs.map