@warlock.js/ai-anthropic 4.1.1

package/esm/sdk.d.mts

@@ -0,0 +1,70 @@
+import { AnthropicModelConfig, AnthropicSDKConfig } from "./config.type.mjs";
+import { ModelContract, SDKAdapterContract } from "@warlock.js/ai";
+
+//#region ../../@warlock.js/ai-anthropic/src/sdk.d.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" }) });
+ */
+declare class AnthropicSDK implements SDKAdapterContract {
+  private readonly client;
+  private readonly provider;
+  private readonly pricing?;
+  constructor(config: AnthropicSDKConfig);
+  /**
+   * 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: AnthropicModelConfig): ModelContract;
+  /**
+   * 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.
+   */
+  count(text: string, _model?: string): Promise<number>;
+}
+//#endregion
+export { AnthropicSDK };
+//# sourceMappingURL=sdk.d.mts.map

package/esm/sdk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.d.mts","names":[],"sources":["../../../../../@warlock.js/ai-anthropic/src/sdk.ts"],"mappings":";;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;;;;;;;AA2C4D;;;;;;cA3C/C,YAAA,YAAwB,kBAAA;EAAA,iBAClB,MAAA;EAAA,iBACA,QAAA;EAAA,iBACA,OAAA;cAEE,MAAA,EAAQ,kBAAA;;;;;;;;;;;;;EAqBpB,KAAA,CAAM,MAAA,EAAQ,oBAAA,GAAuB,aAAA;;;;;;;;;;EAiB/B,KAAA,CAAM,IAAA,UAAc,MAAA,YAAkB,OAAA;AAAA"}

package/esm/sdk.mjs

@@ -0,0 +1,85 @@
+import { AnthropicModel } from "./model.mjs";
+import Anthropic from "@anthropic-ai/sdk";
+import { approximateTokenCount } from "@warlock.js/ai";
+
+//#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({
+			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 approximateTokenCount(text);
+	}
+};
+
+//#endregion
+export { AnthropicSDK };
+//# sourceMappingURL=sdk.mjs.map

package/esm/sdk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.mjs","names":[],"sources":["../../../../../@warlock.js/ai-anthropic/src/sdk.ts"],"sourcesContent":["import Anthropic from \"@anthropic-ai/sdk\";\nimport type { ModelContract, ModelPricing, SDKAdapterContract } from \"@warlock.js/ai\";\nimport { approximateTokenCount } from \"@warlock.js/ai\";\nimport type { AnthropicModelConfig, AnthropicSDKConfig } from \"./config.type\";\nimport { AnthropicModel } from \"./model\";\n\n/**\n * Anthropic-backed implementation of `SDKAdapterContract`.\n *\n * **Role.** The package entry point for Claude models via the official\n * `@anthropic-ai/sdk`. A single `AnthropicSDK` instance holds one live\n * `Anthropic` client, shared by every `ModelContract` it produces via\n * `model()`. Users construct one SDK per account and reuse it across\n * all agents, workflows, and supervisors that target Anthropic.\n *\n * **Responsibility.**\n * - Owns: a long-lived `Anthropic` client (authentication, base URL)\n *   and its lifetime scope. Factory for `AnthropicModel` instances —\n *   each model call gets a reference to the same client.\n * - Does NOT own: anything per-call (tool execution, message history,\n *   streaming loop) — those live in `AnthropicModel` and the agent\n *   runtime. Does NOT implement `embedder()`: Anthropic ships no\n *   first-party embeddings API (the contract marks it optional).\n *\n * Modeled as a class (see §4.2 of code-style.md — \"long-lived state\n * across many calls\"): the `Anthropic` client is heavy to construct\n * and designed to be reused; keeping it on `this` makes that reuse\n * explicit and aligns with the `new Anthropic(...)` upstream\n * convention.\n *\n * @example\n * const anthropic = new AnthropicSDK({ apiKey: process.env.ANTHROPIC_API_KEY! });\n * const model = anthropic.model({ name: \"claude-sonnet-4-6\", temperature: 0.7 });\n * const tokens = await anthropic.count(\"Hello world\");\n *\n * @example\n * // Compose into an `ai.anthropic` namespace for ergonomic agent wiring\n * const ai = { agent, tool, systemPrompt, anthropic: new AnthropicSDK({ apiKey }) };\n * const myAgent = ai.agent({ model: ai.anthropic.model({ name: \"claude-haiku-4-5\" }) });\n */\nexport class AnthropicSDK implements SDKAdapterContract {\n  private readonly client: Anthropic;\n  private readonly provider: string;\n  private readonly pricing?: Record<string, ModelPricing>;\n\n  public constructor(config: AnthropicSDKConfig) {\n    this.client = new Anthropic({\n      apiKey: config.apiKey,\n      baseURL: config.baseURL,\n    });\n    this.provider = config.provider ?? \"anthropic\";\n    this.pricing = config.pricing;\n  }\n\n  /**\n   * Build an `AnthropicModel` bound to this SDK's client. Each call\n   * returns a fresh model instance, but all instances share the\n   * underlying `Anthropic` client — connection pools, rate limits, and\n   * authentication stay unified across every model produced here. The\n   * SDK's `provider` label is forwarded so every model self-identifies\n   * as coming from the same upstream.\n   *\n   * Pricing resolution: per-model `config.pricing` wins; otherwise the\n   * SDK-level registry entry keyed by `config.name`; otherwise\n   * `undefined` (no cost computed).\n   */\n  public model(config: AnthropicModelConfig): ModelContract {\n    const resolvedPricing = config.pricing ?? this.pricing?.[config.name];\n    const resolvedConfig: AnthropicModelConfig =\n      resolvedPricing === config.pricing ? config : { ...config, pricing: resolvedPricing };\n\n    return new AnthropicModel(this.client, resolvedConfig, this.provider);\n  }\n\n  /**\n   * Rough token-count estimate for a given text. Uses the\n   * character-heuristic (`approximateTokenCount`) from the core package\n   * — good enough for budgeting and quota guards, not for billing.\n   * Anthropic does expose a `messages.countTokens` endpoint, but that\n   * is a network round-trip; `count()` is intentionally offline and\n   * synchronous-cost. The optional model id is reserved for future\n   * per-model tokenizer dispatch; currently ignored.\n   */\n  public async count(text: string, _model?: string): Promise<number> {\n    return approximateTokenCount(text);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,eAAb,MAAwD;CAKtD,AAAO,YAAY,QAA4B;EAC7C,KAAK,SAAS,IAAI,UAAU;GAC1B,QAAQ,OAAO;GACf,SAAS,OAAO;EAClB,CAAC;EACD,KAAK,WAAW,OAAO,YAAY;EACnC,KAAK,UAAU,OAAO;CACxB;;;;;;;;;;;;;CAcA,AAAO,MAAM,QAA6C;EACxD,MAAM,kBAAkB,OAAO,WAAW,KAAK,UAAU,OAAO;EAChE,MAAM,iBACJ,oBAAoB,OAAO,UAAU,SAAS;GAAE,GAAG;GAAQ,SAAS;EAAgB;EAEtF,OAAO,IAAI,eAAe,KAAK,QAAQ,gBAAgB,KAAK,QAAQ;CACtE;;;;;;;;;;CAWA,MAAa,MAAM,MAAc,QAAkC;EACjE,OAAO,sBAAsB,IAAI;CACnC;AACF"}

package/esm/utils/index.mjs

@@ -0,0 +1,6 @@
+import { mapStopReason } from "./map-stop-reason.mjs";
+import { toAnthropicMessages } from "./to-anthropic-messages.mjs";
+import { toAnthropicTools } from "./to-anthropic-tools.mjs";
+import { wrapAnthropicError } from "./wrap-anthropic-error.mjs";
+
+export {  };

package/esm/utils/map-stop-reason.mjs

@@ -0,0 +1,30 @@
+//#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
+export { mapStopReason };
+//# sourceMappingURL=map-stop-reason.mjs.map

package/esm/utils/map-stop-reason.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-stop-reason.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-anthropic/src/utils/map-stop-reason.ts"],"sourcesContent":["import type { FinishReason } from \"@warlock.js/ai\";\n\nconst stopReasonMap: Record<string, FinishReason> = {\n  end_turn: \"stop\",\n  stop_sequence: \"stop\",\n  max_tokens: \"length\",\n  tool_use: \"tool_calls\",\n};\n\n/**\n * Map Anthropic's `stop_reason` to the normalized `FinishReason` union.\n *\n * `end_turn` / `stop_sequence` are both natural stops. `max_tokens`\n * maps to `length`. `tool_use` maps to `tool_calls`. Everything else —\n * `refusal` (policy intervention), `pause_turn` (incomplete\n * long-running turn), `null`, or any value a future API version adds —\n * falls through to `\"error\"` so the agent treats the trip as a\n * non-clean terminal rather than silently accepting a partial result.\n *\n * @example\n * mapStopReason(\"end_turn\");  // \"stop\"\n * mapStopReason(\"tool_use\");  // \"tool_calls\"\n * mapStopReason(\"refusal\");   // \"error\"\n * mapStopReason(null);        // \"error\"\n */\nexport function mapStopReason(raw: string | null | undefined): FinishReason {\n  return stopReasonMap[raw ?? \"\"] ?? \"error\";\n}\n"],"mappings":";AAEA,MAAM,gBAA8C;CAClD,UAAU;CACV,eAAe;CACf,YAAY;CACZ,UAAU;AACZ;;;;;;;;;;;;;;;;;AAkBA,SAAgB,cAAc,KAA8C;CAC1E,OAAO,cAAc,OAAO,OAAO;AACrC"}

package/esm/utils/to-anthropic-messages.mjs

@@ -0,0 +1,125 @@
+//#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
+export { toAnthropicMessages };
+//# sourceMappingURL=to-anthropic-messages.mjs.map

package/esm/utils/to-anthropic-messages.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-anthropic-messages.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-anthropic/src/utils/to-anthropic-messages.ts"],"sourcesContent":["import type { ContentPart, Message } from \"@warlock.js/ai\";\nimport type Anthropic from \"@anthropic-ai/sdk\";\n\n/**\n * Result of splitting a vendor-neutral `Message[]` for the Anthropic\n * Messages API: the system prompt is hoisted to a top-level `system`\n * string (Anthropic has no `\"system\"` role inside `messages`), and the\n * remaining turns are mapped to `MessageParam[]`.\n */\nexport type AnthropicMessages = {\n  system: string | undefined;\n  messages: Anthropic.MessageParam[];\n};\n\nconst ANTHROPIC_IMAGE_MEDIA_TYPES = [\"image/jpeg\", \"image/png\", \"image/gif\", \"image/webp\"] as const;\n\ntype AnthropicImageMediaType = (typeof ANTHROPIC_IMAGE_MEDIA_TYPES)[number];\n\n/**\n * Convert vendor-neutral `Message[]` into Anthropic's request shape.\n *\n * Anthropic differs from the OpenAI Chat protocol in three ways this\n * function absorbs:\n *\n * 1. **No `system` role.** System messages are concatenated (newline-\n *    separated) and returned separately as the top-level `system`\n *    parameter.\n * 2. **Tool results are `user` turns.** A neutral `tool` message becomes\n *    a `user` message whose content is a single `tool_result` block\n *    keyed by `tool_use_id`.\n * 3. **Tool calls are `tool_use` content blocks.** An assistant message\n *    carrying `toolCalls` becomes an `assistant` message whose content\n *    is an optional leading `text` block followed by one `tool_use`\n *    block per call.\n *\n * Consecutive same-role turns are left as-is — the Messages API merges\n * them server-side.\n *\n * @example\n * const { system, messages } = toAnthropicMessages([\n *   { role: \"system\", content: \"Be concise.\" },\n *   { role: \"user\", content: \"Hi\" },\n * ]);\n * // system === \"Be concise.\"\n * // messages === [{ role: \"user\", content: \"Hi\" }]\n */\nexport function toAnthropicMessages(messages: Message[]): AnthropicMessages {\n  const systemParts: string[] = [];\n  const mapped: Anthropic.MessageParam[] = [];\n\n  for (const message of messages) {\n    if (message.role === \"system\") {\n      systemParts.push(stringifyContent(message.content));\n\n      continue;\n    }\n\n    if (message.role === \"tool\") {\n      mapped.push({\n        role: \"user\",\n        content: [\n          {\n            type: \"tool_result\",\n            tool_use_id: message.toolCallId ?? \"\",\n            content: stringifyContent(message.content),\n          },\n        ],\n      });\n\n      continue;\n    }\n\n    if (message.role === \"assistant\" && message.toolCalls && message.toolCalls.length > 0) {\n      const blocks: Anthropic.ContentBlockParam[] = [];\n      const text = stringifyContent(message.content);\n\n      if (text) {\n        blocks.push({ type: \"text\", text });\n      }\n\n      for (const toolCall of message.toolCalls) {\n        blocks.push({\n          type: \"tool_use\",\n          id: toolCall.id,\n          name: toolCall.name,\n          input: toolCall.input ?? {},\n        });\n      }\n\n      mapped.push({ role: \"assistant\", content: blocks });\n\n      continue;\n    }\n\n    if (message.role === \"user\" && Array.isArray(message.content)) {\n      mapped.push({\n        role: \"user\",\n        content: message.content.map(toAnthropicContentBlock),\n      });\n\n      continue;\n    }\n\n    mapped.push({\n      role: message.role === \"assistant\" ? \"assistant\" : \"user\",\n      content: stringifyContent(message.content),\n    });\n  }\n\n  return {\n    system: systemParts.length > 0 ? systemParts.join(\"\\n\\n\") : undefined,\n    messages: mapped,\n  };\n}\n\n/**\n * Multipart content is only meaningful on user messages — for any other\n * role collapse a `ContentPart[]` to its concatenated text so the wire\n * format stays valid. Plain strings pass through unchanged.\n */\nfunction stringifyContent(content: string | ContentPart[]): string {\n  if (typeof content === \"string\") {\n    return content;\n  }\n\n  return content\n    .filter((part): part is { type: \"text\"; text: string } => part.type === \"text\")\n    .map((part) => part.text)\n    .join(\"\");\n}\n\n/**\n * Map a single resolved `ContentPart` to an Anthropic content block.\n * Text passes straight through; images become an `image` block with a\n * `url` source (remote) or a `base64` source (inlined bytes). The\n * agent has already resolved every attachment before it reaches here,\n * so this never reads files or fetches URLs.\n */\nfunction toAnthropicContentBlock(part: ContentPart): Anthropic.ContentBlockParam {\n  if (part.type === \"text\") {\n    return { type: \"text\", text: part.text };\n  }\n\n  if (\"url\" in part.source) {\n    return { type: \"image\", source: { type: \"url\", url: part.source.url } };\n  }\n\n  return {\n    type: \"image\",\n    source: {\n      type: \"base64\",\n      media_type: part.source.mediaType as AnthropicImageMediaType,\n      data: part.source.base64,\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,oBAAoB,UAAwC;CAC1E,MAAM,cAAwB,CAAC;CAC/B,MAAM,SAAmC,CAAC;CAE1C,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,QAAQ,SAAS,UAAU;GAC7B,YAAY,KAAK,iBAAiB,QAAQ,OAAO,CAAC;GAElD;EACF;EAEA,IAAI,QAAQ,SAAS,QAAQ;GAC3B,OAAO,KAAK;IACV,MAAM;IACN,SAAS,CACP;KACE,MAAM;KACN,aAAa,QAAQ,cAAc;KACnC,SAAS,iBAAiB,QAAQ,OAAO;IAC3C,CACF;GACF,CAAC;GAED;EACF;EAEA,IAAI,QAAQ,SAAS,eAAe,QAAQ,aAAa,QAAQ,UAAU,SAAS,GAAG;GACrF,MAAM,SAAwC,CAAC;GAC/C,MAAM,OAAO,iBAAiB,QAAQ,OAAO;GAE7C,IAAI,MACF,OAAO,KAAK;IAAE,MAAM;IAAQ;GAAK,CAAC;GAGpC,KAAK,MAAM,YAAY,QAAQ,WAC7B,OAAO,KAAK;IACV,MAAM;IACN,IAAI,SAAS;IACb,MAAM,SAAS;IACf,OAAO,SAAS,SAAS,CAAC;GAC5B,CAAC;GAGH,OAAO,KAAK;IAAE,MAAM;IAAa,SAAS;GAAO,CAAC;GAElD;EACF;EAEA,IAAI,QAAQ,SAAS,UAAU,MAAM,QAAQ,QAAQ,OAAO,GAAG;GAC7D,OAAO,KAAK;IACV,MAAM;IACN,SAAS,QAAQ,QAAQ,IAAI,uBAAuB;GACtD,CAAC;GAED;EACF;EAEA,OAAO,KAAK;GACV,MAAM,QAAQ,SAAS,cAAc,cAAc;GACnD,SAAS,iBAAiB,QAAQ,OAAO;EAC3C,CAAC;CACH;CAEA,OAAO;EACL,QAAQ,YAAY,SAAS,IAAI,YAAY,KAAK,MAAM,IAAI;EAC5D,UAAU;CACZ;AACF;;;;;;AAOA,SAAS,iBAAiB,SAAyC;CACjE,IAAI,OAAO,YAAY,UACrB,OAAO;CAGT,OAAO,QACJ,QAAQ,SAAiD,KAAK,SAAS,MAAM,EAC7E,KAAK,SAAS,KAAK,IAAI,EACvB,KAAK,EAAE;AACZ;;;;;;;;AASA,SAAS,wBAAwB,MAAgD;CAC/E,IAAI,KAAK,SAAS,QAChB,OAAO;EAAE,MAAM;EAAQ,MAAM,KAAK;CAAK;CAGzC,IAAI,SAAS,KAAK,QAChB,OAAO;EAAE,MAAM;EAAS,QAAQ;GAAE,MAAM;GAAO,KAAK,KAAK,OAAO;EAAI;CAAE;CAGxE,OAAO;EACL,MAAM;EACN,QAAQ;GACN,MAAM;GACN,YAAY,KAAK,OAAO;GACxB,MAAM,KAAK,OAAO;EACpB;CACF;AACF"}

package/esm/utils/to-anthropic-tools.mjs

@@ -0,0 +1,37 @@
+import { extractJsonSchema } from "@warlock.js/ai";
+
+//#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 = extractJsonSchema(input);
+	if (schema && schema.type === "object") return schema;
+	return { type: "object" };
+}
+
+//#endregion
+export { toAnthropicTools };
+//# sourceMappingURL=to-anthropic-tools.mjs.map

package/esm/utils/to-anthropic-tools.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-anthropic-tools.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-anthropic/src/utils/to-anthropic-tools.ts"],"sourcesContent":["import { extractJsonSchema, type ToolConfig } from \"@warlock.js/ai\";\nimport type Anthropic from \"@anthropic-ai/sdk\";\n\n/**\n * Convert vendor-neutral `ToolConfig[]` into Anthropic's `tools` array.\n * Uses the shared `extractJsonSchema` helper; Anthropic requires the\n * input schema to be a JSON-Schema object, so a non-object extraction\n * is coerced into an empty-object schema rather than rejected — the\n * tool still registers and the model simply sees no parameters.\n *\n * @example\n * const tools = toAnthropicTools([weatherTool, calculatorTool]);\n * await client.messages.create({ model, max_tokens, messages, tools });\n */\nexport function toAnthropicTools(\n  tools: ToolConfig<unknown, unknown>[] | undefined,\n): Anthropic.Tool[] | undefined {\n  if (!tools || tools.length === 0) {\n    return undefined;\n  }\n\n  return tools.map((tool) => ({\n    name: tool.name,\n    description: tool.description,\n    input_schema: toInputSchema(tool.input),\n  }));\n}\n\n/**\n * Coerce the extracted JSON Schema into Anthropic's `Tool.InputSchema`\n * shape (root must be `{ type: \"object\" }`). Anything that isn't an\n * object schema degrades to a parameterless object so registration\n * never fails on a malformed extractor result.\n */\nfunction toInputSchema(input: ToolConfig<unknown, unknown>[\"input\"]): Anthropic.Tool.InputSchema {\n  const schema = extractJsonSchema(input);\n\n  if (schema && schema.type === \"object\") {\n    return schema as Anthropic.Tool.InputSchema;\n  }\n\n  return { type: \"object\" };\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,iBACd,OAC8B;CAC9B,IAAI,CAAC,SAAS,MAAM,WAAW,GAC7B;CAGF,OAAO,MAAM,KAAK,UAAU;EAC1B,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,cAAc,cAAc,KAAK,KAAK;CACxC,EAAE;AACJ;;;;;;;AAQA,SAAS,cAAc,OAA0E;CAC/F,MAAM,SAAS,kBAAkB,KAAK;CAEtC,IAAI,UAAU,OAAO,SAAS,UAC5B,OAAO;CAGT,OAAO,EAAE,MAAM,SAAS;AAC1B"}

package/esm/utils/wrap-anthropic-error.mjs

@@ -0,0 +1,158 @@
+import { APIConnectionTimeoutError, APIError } from "@anthropic-ai/sdk";
+import { AIError, ContextLengthExceededError, InvalidRequestError, ProviderAuthError, ProviderError, ProviderRateLimitError, ProviderTimeoutError, QuotaExceededError } from "@warlock.js/ai";
+
+//#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 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 ProviderTimeoutError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.type === "authentication_error" || shape.type === "permission_error") return new ProviderAuthError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.status === 401 || shape.status === 403) return new ProviderAuthError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.type === "billing_error") return new QuotaExceededError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.type === "rate_limit_error" || shape.status === 429) return new 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 ContextLengthExceededError(message, {
+			cause: thrown,
+			context
+		});
+		return new InvalidRequestError(message, {
+			cause: thrown,
+			context
+		});
+	}
+	return new 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 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 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
+export { wrapAnthropicError };
+//# sourceMappingURL=wrap-anthropic-error.mjs.map

package/esm/utils/wrap-anthropic-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-anthropic-error.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-anthropic/src/utils/wrap-anthropic-error.ts"],"sourcesContent":["import {\n  AIError,\n  ContextLengthExceededError,\n  InvalidRequestError,\n  ProviderAuthError,\n  ProviderError,\n  ProviderRateLimitError,\n  ProviderTimeoutError,\n  QuotaExceededError,\n} from \"@warlock.js/ai\";\nimport { APIConnectionTimeoutError, APIError } from \"@anthropic-ai/sdk\";\n\n/**\n * Raw-error fields the wrapper reads off an Anthropic SDK error.\n *\n * `APIError` exposes `status`, `type` (the `error.type` from the\n * response body, e.g. `\"rate_limit_error\"`), `message`, `headers`, and\n * `requestID`. We duck-type because wrapped retries, proxied errors,\n * and custom subclasses sometimes lose the `instanceof` relationship.\n */\ntype AnthropicErrorShape = {\n  status?: number;\n  type?: string | null;\n  message?: string;\n  headers?: HeaderBag | undefined;\n  name?: string;\n  requestId?: string;\n};\n\n/** Either a fetch `Headers` instance or a plain record (duck-typed tests). */\ntype HeaderBag = Headers | Record<string, string>;\n\n/**\n * Wrap any thrown value caught inside the Anthropic adapter into the\n * appropriate `@warlock.js/ai` `AIError` subclass.\n *\n * **Dispatch strategy.** Anthropic has no per-error machine `code`; the\n * stable identifier is `error.type` on the response body (surfaced as\n * `APIError.type`). Dispatch prefers `type`, falls back to `status`\n * when the body was stripped (common with proxies). Name-based\n * detection catches transport-layer timeouts that never produced an\n * HTTP response. The `invalid_request_error` branch additionally\n * sniffs the message for Anthropic's \"prompt is too long\" phrasing,\n * which is the only signal that a 400 was a context-length overflow.\n *\n * `AIError` instances pass through unchanged so `catch/throw wrap(e)`\n * pipelines never double-wrap.\n *\n * @example\n * try {\n *   return await this.client.messages.create(...);\n * } catch (thrown) {\n *   throw wrapAnthropicError(thrown);\n * }\n */\nexport function wrapAnthropicError(thrown: unknown): AIError {\n  if (thrown instanceof AIError) {\n    return thrown;\n  }\n\n  const shape = toShape(thrown);\n  const context = buildContext(shape);\n  const message = shape.message ?? (thrown instanceof Error ? thrown.message : String(thrown));\n\n  if (isTimeout(thrown, shape)) {\n    return new ProviderTimeoutError(message, { cause: thrown, context });\n  }\n\n  if (shape.type === \"authentication_error\" || shape.type === \"permission_error\") {\n    return new ProviderAuthError(message, { cause: thrown, context });\n  }\n\n  if (shape.status === 401 || shape.status === 403) {\n    return new ProviderAuthError(message, { cause: thrown, context });\n  }\n\n  if (shape.type === \"billing_error\") {\n    return new QuotaExceededError(message, { cause: thrown, context });\n  }\n\n  if (shape.type === \"rate_limit_error\" || shape.status === 429) {\n    return new ProviderRateLimitError(message, {\n      cause: thrown,\n      context,\n      retryAfter: parseRetryAfter(shape.headers),\n    });\n  }\n\n  if (shape.type === \"invalid_request_error\" || isClientStatus(shape.status)) {\n    if (/prompt is too long/i.test(message)) {\n      return new ContextLengthExceededError(message, { cause: thrown, context });\n    }\n\n    return new InvalidRequestError(message, { cause: thrown, context });\n  }\n\n  return new ProviderError(message, { cause: thrown, context });\n}\n\n/**\n * Read the raw error shape without depending on `instanceof APIError`\n * — proxies and re-wrappers strip the prototype chain. Duck-typing on\n * the visible fields is resilient to both.\n */\nfunction toShape(thrown: unknown): AnthropicErrorShape {\n  if (thrown instanceof APIError) {\n    return {\n      status: typeof thrown.status === \"number\" ? thrown.status : undefined,\n      type: thrown.type,\n      message: thrown.message,\n      headers: thrown.headers,\n      name: thrown.name,\n      requestId: thrown.requestID ?? undefined,\n    };\n  }\n\n  if (typeof thrown === \"object\" && thrown !== null) {\n    const raw = thrown as Record<string, unknown>;\n\n    return {\n      status: typeof raw.status === \"number\" ? raw.status : undefined,\n      type: typeof raw.type === \"string\" ? raw.type : undefined,\n      message: typeof raw.message === \"string\" ? raw.message : undefined,\n      headers: isHeaderBag(raw.headers) ? raw.headers : undefined,\n      name: typeof raw.name === \"string\" ? raw.name : undefined,\n      requestId: readRequestId(raw),\n    };\n  }\n\n  return {};\n}\n\n/**\n * Decide whether the thrown value represents a timeout. The Anthropic\n * SDK throws `APIConnectionTimeoutError` for transport-level timeouts;\n * Node surfaces `ETIMEDOUT` / `ECONNABORTED` on the socket layer.\n * Either signal counts.\n */\nfunction isTimeout(thrown: unknown, shape: AnthropicErrorShape): boolean {\n  if (thrown instanceof APIConnectionTimeoutError) {\n    return true;\n  }\n\n  if (shape.name === \"APIConnectionTimeoutError\") {\n    return true;\n  }\n\n  if (typeof thrown === \"object\" && thrown !== null) {\n    const code = (thrown as Record<string, unknown>).code;\n\n    if (code === \"ETIMEDOUT\" || code === \"ECONNABORTED\") {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/** True for HTTP 4xx — a client-side request problem, not a server fault. */\nfunction isClientStatus(status: number | undefined): boolean {\n  return typeof status === \"number\" && status >= 400 && status < 500;\n}\n\n/**\n * Attach the raw diagnostic fields to `error.context` so consumers\n * have everything the provider surfaced without each subclass having\n * to redeclare them. Never includes `cause` — that lives on\n * `error.cause`.\n */\nfunction buildContext(shape: AnthropicErrorShape): Record<string, unknown> {\n  const context: Record<string, unknown> = {};\n\n  if (shape.status !== undefined) {\n    context.status = shape.status;\n  }\n\n  if (shape.type) {\n    context.type = shape.type;\n  }\n\n  if (shape.requestId) {\n    context.requestId = shape.requestId;\n  }\n\n  return context;\n}\n\n/** Anthropic exposes the request id as `requestID`; some proxies use `request_id`. */\nfunction readRequestId(raw: Record<string, unknown>): string | undefined {\n  if (typeof raw.requestID === \"string\") {\n    return raw.requestID;\n  }\n\n  if (typeof raw.request_id === \"string\") {\n    return raw.request_id;\n  }\n\n  return undefined;\n}\n\nfunction isHeaderBag(value: unknown): value is HeaderBag {\n  return typeof value === \"object\" && value !== null;\n}\n\n/** Read a header value from either a `Headers` instance or a plain record. */\nfunction readHeader(headers: HeaderBag, name: string): string | undefined {\n  if (typeof (headers as Headers).get === \"function\") {\n    return (headers as Headers).get(name) ?? undefined;\n  }\n\n  const record = headers as Record<string, string>;\n\n  return record[name] ?? record[name.toLowerCase()];\n}\n\n/**\n * Parse the `Retry-After` response header (seconds per HTTP spec) into\n * milliseconds so consumers can feed it straight to `setTimeout`.\n * Returns `undefined` when missing or unparseable.\n */\nfunction parseRetryAfter(headers: HeaderBag | undefined): number | undefined {\n  if (!headers) {\n    return undefined;\n  }\n\n  const raw = readHeader(headers, \"retry-after\") ?? readHeader(headers, \"Retry-After\");\n\n  if (!raw) {\n    return undefined;\n  }\n\n  const seconds = Number(raw);\n\n  if (!Number.isFinite(seconds) || seconds < 0) {\n    return undefined;\n  }\n\n  return Math.round(seconds * 1000);\n}\n"],"mappings":"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"}