@happyvertical/ai 0.96.1 → 0.98.0

package/README.md

@@ -64,6 +64,16 @@ const bifrost = await getAI({
   defaultModel: process.env.BIFROST_MODEL,
 });
 
+// LiteLLM and Bifrost getModels() list gateway audio models with their own
+// capabilities: transcription models (whisper, transcribe, speech-to-text
+// tokens) report ['transcription'] and TTS models (tts, speech tokens) report
+// ['speech']. Markers match whole model-ID tokens, not substrings. They are
+// never auto-selected for chat, vision, embeddings, or image generation.
+// Moderation and rerank models stay filtered out of the listing.
+const transcribers = (await bifrost.getModels()).filter((model) =>
+  model.capabilities.includes('transcription'),
+);
+
 // Ollama (local by default)
 const ollama = await getAI({
   type: 'ollama',
@@ -329,7 +339,8 @@ LiteLLM uses the same SDK surface, mapping projects to LiteLLM teams and virtual
 Every generative provider constructor applies the same safe defaults, including
 instances created directly instead of through `getAI()`:
 
-- 4,096 output tokens per request
+- 4,096 output tokens when the caller passes no `maxTokens` (`defaultOutputTokens`)
+- a 131,072-token output ceiling (`maxOutputTokens`), so an explicit `maxTokens` is bounded by the model, not this package
 - 1,024 reasoning tokens per request
 - one generated image per request
 - a 120-second provider timeout
@@ -382,6 +393,48 @@ effective token ceilings plus sanitized `usageTags`; prompts, responses, and
 credentials are never included. Legacy `thinkingLevel` options remain available
 as deprecated aliases and are normalized through the reasoning ceiling.
 
+## Continuing Truncated Replies
+
+When a reply stops because it hit its output limit (`finishReason: 'length'`:
+OpenAI-compatible `length`, Anthropic/Bedrock `max_tokens`, Gemini
+`MAX_TOKENS`, Ollama `length`), `getAI()` clients can ask the model to carry on
+and return one stitched reply. It is **off by default**: each continuation is a
+full extra request (up to `1 + maxContinuations` times the spend), which should
+be a deliberate choice, and the generation guardrails above apply to every part.
+
+```typescript
+const result = await ai.chat(messages, { continueOnLength: true });
+// or { continueOnLength: { maxContinuations: 2 } }  (default 3)
+// or set it as the client default: getAI({ ..., continueOnLength: true })
+
+result.content;   // stitched text
+result.parts;     // requests used (set when continuation ran)
+result.truncated; // true if the reply still ended on the limit
+```
+
+- Each continuation re-sends the conversation with the partial reply as an
+  assistant turn plus a "continue exactly where you stopped" user turn, and any
+  text the model repeats at the seam (12+ characters) is trimmed. When a part
+  ends a sentence and the next starts a new one without a space, the space is
+  restored.
+- `chat`, `complete`, `message`, and `stream` all support it (Ollama's
+  `complete` switches from `/generate` to a one-message chat when it is on); a stream stays one
+  continuous stream (the first characters of each continuation are held briefly
+  so a repeated seam can be trimmed). `onProgress` receives only the stitched text.
+- `usage` on the result is the sum across parts. Provider `onUsage` hooks still
+  fire once per upstream request, so their sum equals the total.
+- Tool calls and `responseFormat: { type: 'json_object' }` are never continued
+  (stitching them is unsafe); the reply is returned as-is with `truncated: true`.
+- With `rateLimit` pacing, every part is its own paced request: a rate-limit
+  retry repeats only the part that was rejected, never the parts already paid for.
+- A reply that hits the limit before producing any text (reasoning used the
+  whole budget) is not continued; it is returned with `truncated: true`.
+- Aborting through `signal` stops before the next part is requested. A part
+  that fails throws the error; the partial text is not returned.
+- `truncated: true` is also set when continuation is off and the reply hit the limit.
+- Streaming adapters report the finish reason through `ChatOptions.onFinishReason`;
+  a continued stream reports it once, with the last part's reason.
+
 ## Opt-In Rate-Limit Pacing
 
 Use `rateLimit` when multiple calls share the same provider budget and you want
@@ -424,12 +477,24 @@ in-process retry wrapper is applied. Provider retries still default to zero.
 | `cooldownMs` | `number` | `0` | Minimum delay after a successful call before the next call with the same key |
 | `initialDelayMs` | `number` | `5000` | Fallback retry delay when the provider does not return `Retry-After` |
 | `maxAttempts` | `number` | `1` | Total attempts, including the initial call; increase explicitly only for an approved workload |
+| `maxRetryDelayMs` | `number` | `60000` | Longest reset wait still retried; a limit that resets further away is not retried and its error has `retryable: false` |
 | `requestsPerMinute` | `number` | provider-specific | Used by `qwen3-tts` local token-bucket limiting |
 | `maxConcurrent` | `number` | provider-specific | Used by `qwen3-tts` local concurrency limiting |
 
 - If `key` is omitted, `@happyvertical/ai` derives a provider-scoped key from the configured credentials
 - Setting any of `key`, `cooldownMs`, `initialDelayMs`, or `maxAttempts` also opts in when `enabled` is omitted
 - Only normalized rate-limit failures are retried
+- The request `timeout` covers the whole call from the caller's side: time
+  queued behind other calls on the same key, cooldown and retry waits, and the
+  request itself, which gets only what is left. A call still queued at its
+  deadline fails with `AIError` code `AI_TIMEOUT` and never reaches the provider.
+  When a rate limit has closed the key past the deadline, the call fails at once
+  with a `RateLimitError` carrying the original `reason` and the remaining
+  `retryAfterMs`. A retry that cannot finish before the deadline is not started.
+  Aborting `signal` releases a queued call (`AI_ABORTED`). Methods without
+  request controls (`embed`, `getModels`, speech) use the client `timeout` for
+  their queue wait when one is set. With `continueOnLength`, each part is its
+  own request with its own timeout.
 - `stream()` is left unchanged; pacing is applied to the promise-returning request methods
 
 Example quota-sensitive batch workload:
@@ -524,13 +589,28 @@ All extend `AIError`: `AuthenticationError`, `RateLimitError`, `ModelNotFoundErr
 
 - `AIError.retryable` distinguishes retryable failures from terminal ones
 - `RateLimitError.retryAfter` exposes provider retry hints in seconds when available
+- `RateLimitError.reason` keeps the provider's own text (for example
+  `token limit exceeded (277867/250000, resets every 1h)`), and the message
+  includes it, so callers can say why a call was refused
+- `RateLimitError.retryAfterMs` is the time until the limit resets when the
+  provider said so: `Retry-After`, a reset header (`x-ratelimit-reset-*`,
+  `anthropic-ratelimit-*-reset`), or text such as "try again in 20s"
+- `RateLimitError.limitWindowMs` is set when the provider names a limit window
+  but no reset time ("resets every 1h"); the limit lifts within that time
+- `error.cause` is the provider error it was mapped from
+- `RateLimitError.retryable` is `false` when the limit resets more than a
+  minute away (`retryAfterMs`, else `limitWindowMs`; `rateLimit.maxRetryDelayMs`
+  changes the threshold). Job runners should not re-run such a job soon; they
+  can reschedule it after `retryAfterMs ?? limitWindowMs`
 
 ```typescript
 try {
   await ai.chat(messages);
 } catch (error) {
-  if (error instanceof RateLimitError && error.retryable) {
-    console.log('retry after seconds:', error.retryAfter);
+  if (error instanceof RateLimitError) {
+    console.log('why:', error.reason);
+    if (error.retryable) console.log('retry after seconds:', error.retryAfter);
+    else console.log('lifts in ms:', error.retryAfterMs ?? error.limitWindowMs);
   }
 }
 ```
@@ -564,6 +644,46 @@ if (response.toolCalls) {
 }
 ```
 
+To continue the loop, replay the assistant turn with `tool_calls` unchanged
+and answer each call with a `role: 'tool'` message carrying its
+`tool_call_id`. Every chat provider maps this to its native pairing
+(`tool_call_id` for OpenAI-compatible APIs including Bifrost and LiteLLM,
+`tool_use_id` for Anthropic, `toolUseId` for Bedrock, `functionResponse` for
+Gemini, `tool_name` for Ollama). `name` on the tool message is optional; it is
+resolved from the matching call when a provider needs it.
+
+```typescript
+const call = response.toolCalls[0];
+const followUp = await ai.chat([
+  { role: 'user', content: 'What is the weather in Tokyo?' },
+  { role: 'assistant', content: response.content, tool_calls: response.toolCalls },
+  { role: 'tool', tool_call_id: call.id, content: JSON.stringify({ tempC: 21 }) },
+], { tools });
+```
+
+Replay `response.toolCalls` as returned, and keep every field if you persist
+the conversation: provider-specific replay data rides on the tool calls.
+Gemini 3 needs `thoughtSignature`, and Anthropic with extended thinking
+(`reasoning.maxTokens`) needs `thinkingBlocks` (the signed thinking that opened
+the tool-calling turn). If an Anthropic tool loop's latest `tool_use` turn has
+no `thinkingBlocks`, that request is sent without extended thinking instead of
+failing.
+Gemini replays only calls that have a result, and when a Gemini 3 step has no
+`thoughtSignature` it sends Google's documented placeholder signature, which
+avoids the 400 but lowers reasoning quality, so persist the real one.
+
+A loop's final round usually asks for a plain answer (`toolChoice: 'none'`,
+often with no `tools`) while replaying the tool history. Anthropic and Bedrock
+reject tool history without declared tools, so both declare a minimal
+definition for each tool the history references. Anthropic sends
+`tool_choice: { type: 'none' }`; Bedrock Converse has no "none" choice, so it
+keeps the tools, omits `toolChoice`, and adds a system instruction not to call
+tools (an instruction, not a guarantee; check `finishReason`).
+
+`stream()` yields text only and never returns tool calls, so run tool-calling
+rounds with `chat()`. Anthropic streams ignore `tools`/`toolChoice` and declare
+tools only when the replayed history needs them, with `tool_choice` none.
+
 ## Usage Tracking
 
 Track token usage, costs, and performance across all providers with the `onUsage` callback:

package/dist/chunks/{anthropic-CD9Ud7a5.js → anthropic-6ZDF32jo.js}

@@ -1,7 +1,7 @@
-import { a as ContextLengthError, c as extractTextContent, o as ModelNotFoundError, r as AuthenticationError, s as RateLimitError, t as AIError } from "./types-BpnNcTU1.js";
-import { n as extractRetryAfterSeconds } from "./rate-limit-BVW_1Tey.js";
-import { a as normalizeBaseAIOptions, c as prepareRequestControls, o as normalizeChatOptions } from "./safety-BKswBoqy.js";
+import { a as ContextLengthError, l as extractTextContent, r as AuthenticationError, s as ModelNotFoundError, t as AIError } from "./types-DB5W6_F-.js";
+import { c as normalizeChatOptions, n as rateLimitErrorFrom, s as normalizeBaseAIOptions, u as prepareRequestControls } from "./rate-limit-BzWfHA0e.js";
 import { t as emitUsage } from "./usage-C1Y1Nlg4.js";
+import { r as parseToolArguments } from "./tool-messages-0ND35mYX.js";
 //#region src/shared/providers/anthropic.ts
 /**
 * Anthropic Claude provider implementation
@@ -103,18 +103,11 @@ var AnthropicProvider = class {
 				top_p: options.topP,
 				stop_sequences: Array.isArray(options.stop) ? options.stop : options.stop ? [options.stop] : void 0,
 				system: system || void 0,
-				tools: options.tools && options.tools.length > 0 ? options.tools.map((tool) => ({
-					name: tool.function.name,
-					description: tool.function.description || "",
-					input_schema: tool.function.parameters || { type: "object" }
-				})) : void 0,
-				tool_choice: this.mapToolChoice(options.toolChoice),
+				...this.mapToolParams(options, anthropicMessages),
 				stream: false
 			};
-			if ((options.reasoning?.maxTokens || 0) > 0) requestParams.thinking = {
-				type: "enabled",
-				budget_tokens: options.reasoning?.maxTokens
-			};
+			const thinking = this.mapThinking(options, anthropicMessages);
+			if (thinking) requestParams.thinking = thinking;
 			if (options.responseFormat?.type === "json_object") {
 				const jsonInstruction = "\n\nIMPORTANT: You must respond with valid JSON only. Do not include any explanatory text outside the JSON object.";
 				requestParams.system = requestParams.system ? requestParams.system + jsonInstruction : jsonInstruction.trim();
@@ -132,6 +125,8 @@ var AnthropicProvider = class {
 					arguments: JSON.stringify(block.input)
 				}
 			}));
+			const thinkingBlocks = extractThinkingBlocks(response.content);
+			if (toolCalls.length > 0 && thinkingBlocks.length > 0) toolCalls[0].thinkingBlocks = thinkingBlocks;
 			const usage = {
 				promptTokens: response.usage.input_tokens,
 				completionTokens: response.usage.output_tokens,
@@ -169,7 +164,8 @@ var AnthropicProvider = class {
 			signal: options.signal,
 			timeout: options.timeout,
 			reasoning: options.reasoning,
-			usageTags: options.usageTags
+			usageTags: options.usageTags,
+			continueOnLength: options.continueOnLength
 		});
 	}
 	/**
@@ -215,7 +211,8 @@ var AnthropicProvider = class {
 			signal: options.signal,
 			timeout: options.timeout,
 			reasoning: options.reasoning,
-			usageTags: options.usageTags
+			usageTags: options.usageTags,
+			continueOnLength: options.continueOnLength
 		})).content;
 	}
 	async embed(_text, _options = {}) {
@@ -230,6 +227,15 @@ var AnthropicProvider = class {
 	async generateImage(_prompt, _options = {}) {
 		throw new AIError("Anthropic Claude does not support image generation. Use OpenAI or Gemini.", "NOT_SUPPORTED", "anthropic");
 	}
+	/**
+	* Streams a chat completion as text chunks.
+	*
+	* Streams yield text only and never surface tool calls, so `options.tools`
+	* and `options.toolChoice` are ignored: tools are declared only when the
+	* replayed history contains `tool_use` blocks (Anthropic requires it), with
+	* `tool_choice: { type: 'none' }`. Use `chat()` for rounds that may call
+	* tools.
+	*/
 	async *stream(messages, options = {}) {
 		const startTime = Date.now();
 		let controls;
@@ -247,20 +253,24 @@ var AnthropicProvider = class {
 				top_p: options.topP,
 				stop_sequences: Array.isArray(options.stop) ? options.stop : options.stop ? [options.stop] : void 0,
 				system: system || void 0,
+				...this.mapHistoryToolParams(anthropicMessages),
 				stream: true
 			};
-			if ((options.reasoning?.maxTokens || 0) > 0) requestParams.thinking = {
-				type: "enabled",
-				budget_tokens: options.reasoning?.maxTokens
-			};
+			const thinking = this.mapThinking(options, anthropicMessages);
+			if (thinking) requestParams.thinking = thinking;
 			const stream = await this.client.messages.create(requestParams, {
 				signal: controls.signal,
 				timeout: controls.timeout
 			});
-			for await (const chunk of stream) if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-				if (options.onProgress) options.onProgress(chunk.delta.text);
-				yield chunk.delta.text;
+			let streamStopReason = null;
+			for await (const chunk of stream) {
+				if (chunk.type === "message_delta" && chunk.delta?.stop_reason) streamStopReason = chunk.delta.stop_reason;
+				if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+					if (options.onProgress) options.onProgress(chunk.delta.text);
+					yield chunk.delta.text;
+				}
 			}
+			options.onFinishReason?.(this.mapFinishReason(streamStopReason) ?? "stop");
 			emitUsage(this.options, "anthropic", "stream", model, void 0, startTime, options.usageTags);
 		} catch (error) {
 			if (controls?.didTimeout()) throw new AIError(`AI request timed out after ${controls.timeout}ms`, "AI_TIMEOUT", "anthropic", options.model);
@@ -400,13 +410,68 @@ var AnthropicProvider = class {
 	async getVoices(_options) {
 		throw new AIError("Voice listing is not supported by Anthropic provider. Use Qwen3-TTS provider.", "NOT_IMPLEMENTED", "anthropic");
 	}
+	/**
+	* Maps internal messages to Anthropic Messages API turns.
+	*
+	* Assistant `tool_calls` become `tool_use` blocks and `role: 'tool'`
+	* results become `tool_result` blocks paired by `tool_call_id`
+	* (`tool_use_id`). Consecutive tool results are grouped into one user turn,
+	* as Anthropic requires every result for a turn to follow it directly.
+	* Only answered calls are replayed as `tool_use`, and only results whose
+	* `tool_call_id` matches a replayed call become `tool_result`. A result
+	* without `tool_call_id`, or one answering no replayed call, falls back to
+	* plain text (and a call left unanswered keeps only its text).
+	*/
 	mapMessagesToAnthropic(messages) {
 		let system;
 		const anthropicMessages = [];
+		const answeredToolCallIds = new Set(messages.filter((message) => message.role === "tool" && message.tool_call_id).map((message) => message.tool_call_id));
+		const replayedToolUseIds = /* @__PURE__ */ new Set();
+		for (const message of messages) {
+			if (message.role !== "assistant") continue;
+			for (const toolCall of message.tool_calls || []) if (answeredToolCallIds.has(toolCall.id)) replayedToolUseIds.add(toolCall.id);
+		}
 		for (const message of messages) {
 			const textContent = extractTextContent(message.content);
-			if (message.role === "system") system = system ? `${system}\n\n${textContent}` : textContent;
-			else anthropicMessages.push({
+			if (message.role === "system") {
+				system = system ? `${system}\n\n${textContent}` : textContent;
+				continue;
+			}
+			if (message.role === "tool" && message.tool_call_id && replayedToolUseIds.has(message.tool_call_id)) {
+				const block = {
+					type: "tool_result",
+					tool_use_id: message.tool_call_id,
+					content: textContent
+				};
+				const previous = anthropicMessages[anthropicMessages.length - 1];
+				if (previous?.role === "user" && Array.isArray(previous.content) && previous.content.every((part) => part.type === "tool_result")) previous.content.push(block);
+				else anthropicMessages.push({
+					role: "user",
+					content: [block]
+				});
+				continue;
+			}
+			const toolCalls = message.role === "assistant" ? (message.tool_calls || []).filter((toolCall) => answeredToolCallIds.has(toolCall.id)) : [];
+			if (toolCalls.length > 0) {
+				const content = [];
+				for (const toolCall of toolCalls) for (const block of toolCall.thinkingBlocks || []) content.push({ ...block });
+				if (textContent) content.push({
+					type: "text",
+					text: textContent
+				});
+				for (const toolCall of toolCalls) content.push({
+					type: "tool_use",
+					id: toolCall.id,
+					name: toolCall.function.name,
+					input: parseToolArguments(toolCall.function.arguments)
+				});
+				anthropicMessages.push({
+					role: "assistant",
+					content
+				});
+				continue;
+			}
+			anthropicMessages.push({
 				role: message.role === "assistant" ? "assistant" : "user",
 				content: textContent
 			});
@@ -416,9 +481,81 @@ var AnthropicProvider = class {
 			anthropicMessages
 		};
 	}
+	/**
+	* Builds the `tools` / `tool_choice` request fields.
+	*
+	* Anthropic rejects a request whose history contains `tool_use` or
+	* `tool_result` blocks unless `tools` is declared. A tool loop's final,
+	* tool-less round (no `tools`, typically `toolChoice: 'none'`) still
+	* replays that history, so when the caller declares no tools but the
+	* history uses some, this declares a minimal definition for each tool the
+	* history references and sets `tool_choice: { type: 'none' }` so the model
+	* answers in text instead of calling them.
+	*/
+	mapToolParams(options, anthropicMessages) {
+		const tools = this.mapTools(options);
+		if (tools) return {
+			tools,
+			tool_choice: this.mapToolChoice(options.toolChoice)
+		};
+		return this.mapHistoryToolParams(anthropicMessages);
+	}
+	/**
+	* Declares a minimal definition for each tool the replayed history
+	* references, with `tool_choice: { type: 'none' }`, or nothing when the
+	* history has no `tool_use` blocks. Used for tool-less rounds and for
+	* every stream (streams never yield tool calls).
+	*/
+	mapHistoryToolParams(anthropicMessages) {
+		const historyToolNames = /* @__PURE__ */ new Set();
+		for (const message of anthropicMessages) {
+			if (!Array.isArray(message.content)) continue;
+			for (const block of message.content) if (block.type === "tool_use") historyToolNames.add(block.name);
+		}
+		if (historyToolNames.size === 0) return {};
+		return {
+			tools: [...historyToolNames].map((name) => ({
+				name,
+				description: "Used earlier in this conversation; not available for this turn.",
+				input_schema: { type: "object" }
+			})),
+			tool_choice: { type: "none" }
+		};
+	}
+	/**
+	* Builds the `thinking` request field for `options.reasoning.maxTokens`.
+	*
+	* While thinking is enabled, Anthropic requires the assistant turn of an
+	* in-progress tool loop (the last assistant turn, when it holds `tool_use`)
+	* to start with its thinking blocks. They are replayed from
+	* `AIToolCall.thinkingBlocks`; when that turn has none (the history came
+	* from another provider, a store that dropped the field, or a call made
+	* without thinking), thinking is left off for this request rather than
+	* sending a request Anthropic would reject.
+	*/
+	mapThinking(options, anthropicMessages) {
+		const budget = options.reasoning?.maxTokens || 0;
+		if (budget <= 0) return void 0;
+		const lastAssistant = [...anthropicMessages].reverse().find((message) => message.role === "assistant");
+		if (lastAssistant && Array.isArray(lastAssistant.content) && lastAssistant.content.some((block) => block.type === "tool_use")) {
+			const firstType = lastAssistant.content[0]?.type;
+			if (firstType !== "thinking" && firstType !== "redacted_thinking") return;
+		}
+		return {
+			type: "enabled",
+			budget_tokens: budget
+		};
+	}
+	mapTools(options) {
+		return options.tools && options.tools.length > 0 ? options.tools.map((tool) => ({
+			name: tool.function.name,
+			description: tool.function.description || "",
+			input_schema: tool.function.parameters || { type: "object" }
+		})) : void 0;
+	}
 	mapToolChoice(toolChoice) {
 		if (!toolChoice || toolChoice === "auto") return { type: "auto" };
-		if (toolChoice === "none") return;
+		if (toolChoice === "none") return { type: "none" };
 		if (typeof toolChoice === "object" && toolChoice.type === "function") return {
 			type: "tool",
 			name: toolChoice.function.name
@@ -440,7 +577,7 @@ var AnthropicProvider = class {
 			const apiError = error;
 			switch (apiError.status) {
 				case 401: return new AuthenticationError("anthropic");
-				case 429: return new RateLimitError("anthropic", extractRetryAfterSeconds(error));
+				case 429: return rateLimitErrorFrom("anthropic", error);
 				case 404: return new ModelNotFoundError(apiError.message || "Model not found", "anthropic");
 				case 413: return new ContextLengthError("anthropic");
 			}
@@ -448,7 +585,24 @@ var AnthropicProvider = class {
 		return new AIError(error instanceof Error ? error.message : "Unknown Anthropic error occurred", "UNKNOWN_ERROR", "anthropic");
 	}
 };
+/**
+* Thinking and redacted-thinking blocks from an Anthropic response, copied
+* with only the fields the API accepts back.
+*/
+function extractThinkingBlocks(content) {
+	const blocks = [];
+	for (const block of content || []) if (block?.type === "thinking") blocks.push({
+		type: "thinking",
+		thinking: block.thinking,
+		signature: block.signature
+	});
+	else if (block?.type === "redacted_thinking") blocks.push({
+		type: "redacted_thinking",
+		data: block.data
+	});
+	return blocks;
+}
 //#endregion
 export { AnthropicProvider };
 
-//# sourceMappingURL=anthropic-CD9Ud7a5.js.map
+//# sourceMappingURL=anthropic-6ZDF32jo.js.map

package/dist/chunks/anthropic-6ZDF32jo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-6ZDF32jo.js","names":[],"sources":["../../src/shared/providers/anthropic.ts"],"sourcesContent":["/**\n * Anthropic Claude provider implementation\n *\n * Provides a standardized interface for interacting with Anthropic's Claude models,\n * including chat completions, streaming responses, and vision capabilities.\n * Note: Claude models do not support embeddings - use OpenAI or another provider for that.\n */\n\nimport { rateLimitErrorFrom } from '../rate-limit';\nimport {\n  normalizeBaseAIOptions,\n  normalizeChatOptions,\n  type PreparedRequestControls,\n  prepareRequestControls,\n} from '../safety';\nimport { parseToolArguments } from '../tool-messages';\nimport type {\n  AICapabilities,\n  AIInterface,\n  AIMessage,\n  AIModel,\n  AIResponse,\n  AIThinkingBlock,\n  AIToolCall,\n  AnthropicOptions,\n  ChatOptions,\n  CompletionOptions,\n  EmbeddingOptions,\n  EmbeddingResponse,\n  ImageDescriptionOptions,\n  ImageEmbeddingOptions,\n  ImageGenerationOptions,\n  ImageGenerationResponse,\n  MessageOptions,\n  TokenUsage,\n  TTSOptions,\n  TTSResponse,\n  VideoGenerationJob,\n  VideoGenerationOptions,\n  VideoGenerationResult,\n  VideoGenerationStatusResult,\n  Voice,\n  VoiceCloneOptions,\n  VoiceDesignOptions,\n  VoiceListOptions,\n} from '../types';\nimport {\n  AIError,\n  AuthenticationError,\n  ContextLengthError,\n  extractTextContent,\n  ModelNotFoundError,\n} from '../types';\nimport { emitUsage } from './usage';\n\ntype AnthropicContentBlock =\n  | AIThinkingBlock\n  | { type: 'text'; text: string }\n  | {\n      type: 'tool_use';\n      id: string;\n      name: string;\n      input: Record<string, unknown>;\n    }\n  | { type: 'tool_result'; tool_use_id: string; content: string };\n\ninterface AnthropicMessage {\n  role: 'user' | 'assistant';\n  content: string | AnthropicContentBlock[];\n}\n\n// Note: This implementation will require @anthropic-ai/sdk package\n// For now, this is a placeholder that defines the interface\n\n/**\n * Anthropic Claude provider implementation that handles all interactions with Anthropic's API.\n * Supports Claude models, streaming, vision capabilities, and function calling.\n * Does not support embeddings (use OpenAI or another provider for embeddings).\n */\nexport class AnthropicProvider implements AIInterface {\n  private options: AnthropicOptions;\n  private client: any; // Will be Anthropic instance from @anthropic-ai/sdk\n\n  /**\n   * Creates a new Anthropic provider instance\n   * @param options - Configuration options for the Anthropic provider\n   */\n  constructor(options: AnthropicOptions) {\n    this.options = normalizeBaseAIOptions({\n      defaultModel: 'claude-3-5-sonnet-20241022',\n      anthropicVersion: '2023-06-01',\n      ...options,\n    });\n\n    // Initialize Anthropic client\n    this.initializeClientSync();\n  }\n\n  private initializeClientSync() {\n    try {\n      // Dynamic import in constructor - this will work if the package is installed\n      import('@anthropic-ai/sdk')\n        .then(({ Anthropic }) => {\n          this.client = new Anthropic({\n            apiKey: this.options.apiKey,\n            baseURL: this.options.baseUrl,\n            timeout: this.options.timeout,\n            maxRetries: this.options.maxRetries,\n            defaultHeaders: {\n              'anthropic-version': this.options.anthropicVersion,\n              ...this.options.headers,\n            },\n          });\n        })\n        .catch(() => {\n          // Client will be null and we'll handle it in methods\n        });\n    } catch (_error) {\n      // Client will be null and we'll handle it in methods\n    }\n  }\n\n  /**\n   * Ensures the Anthropic client is initialized by dynamically importing the SDK\n   * @throws {AIError} When the Anthropic SDK cannot be loaded\n   * @private\n   */\n  private async ensureClient() {\n    if (!this.client) {\n      try {\n        const { Anthropic } = await import('@anthropic-ai/sdk');\n        this.client = new Anthropic({\n          apiKey: this.options.apiKey,\n          baseURL: this.options.baseUrl,\n          timeout: this.options.timeout,\n          maxRetries: this.options.maxRetries,\n          defaultHeaders: {\n            'anthropic-version': this.options.anthropicVersion,\n            ...this.options.headers,\n          },\n        });\n      } catch (_error) {\n        throw new AIError(\n          'Failed to initialize Anthropic client. Make sure @anthropic-ai/sdk is installed.',\n          'INITIALIZATION_ERROR',\n          'anthropic',\n        );\n      }\n    }\n  }\n\n  /**\n   * Generate a chat completion using Claude models\n   * @param messages - Array of conversation messages\n   * @param options - Optional configuration for the chat completion\n   * @returns Promise resolving to the AI response with content and metadata\n   * @throws {AIError} When the API request fails or SDK is not available\n   *\n   * @example\n   * ```typescript\n   * const response = await provider.chat([\n   *   { role: 'system', content: 'You are a helpful assistant.' },\n   *   { role: 'user', content: 'Explain quantum computing' }\n   * ], {\n   *   model: 'claude-3-5-sonnet-20241022',\n   *   maxTokens: 1000\n   * });\n   * ```\n   */\n  async chat(\n    messages: AIMessage[],\n    options: ChatOptions = {},\n  ): Promise<AIResponse> {\n    const startTime = Date.now();\n    let controls: PreparedRequestControls | undefined;\n    try {\n      await this.ensureClient();\n\n      const { system, anthropicMessages } =\n        this.mapMessagesToAnthropic(messages);\n\n      const model = options.model || this.options.defaultModel;\n      options = normalizeChatOptions(this.options, options, 'anthropic', model);\n      controls = prepareRequestControls(this.options, options);\n\n      // Build request parameters\n      const requestParams: Record<string, any> = {\n        model,\n        messages: anthropicMessages,\n        max_tokens: options.maxTokens,\n        temperature: options.temperature,\n        top_p: options.topP,\n        stop_sequences: Array.isArray(options.stop)\n          ? options.stop\n          : options.stop\n            ? [options.stop]\n            : undefined,\n        system: system || undefined,\n        ...this.mapToolParams(options, anthropicMessages),\n        stream: false,\n      };\n      const thinking = this.mapThinking(options, anthropicMessages);\n      if (thinking) {\n        requestParams.thinking = thinking;\n      }\n\n      // Add response format if specified\n      if (options.responseFormat?.type === 'json_object') {\n        const jsonInstruction =\n          '\\n\\nIMPORTANT: You must respond with valid JSON only. Do not include any explanatory text outside the JSON object.';\n        requestParams.system = requestParams.system\n          ? requestParams.system + jsonInstruction\n          : jsonInstruction.trim();\n      }\n\n      const response = await this.client.messages.create(requestParams, {\n        signal: controls.signal,\n        timeout: controls.timeout,\n      });\n\n      // Extract text content and tool calls from response\n      const textContent = response.content\n        .filter((block: any) => block.type === 'text')\n        .map((block: any) => block.text)\n        .join('');\n\n      const toolCalls: AIToolCall[] = response.content\n        .filter((block: any) => block.type === 'tool_use')\n        .map((block: any) => ({\n          id: block.id,\n          type: 'function' as const,\n          function: {\n            name: block.name,\n            arguments: JSON.stringify(block.input),\n          },\n        }));\n\n      // Extended thinking: the replayed tool_use turn must start with these\n      // blocks (signatures intact), so they ride on the first tool call.\n      const thinkingBlocks = extractThinkingBlocks(response.content);\n      if (toolCalls.length > 0 && thinkingBlocks.length > 0) {\n        toolCalls[0].thinkingBlocks = thinkingBlocks;\n      }\n\n      const usage: TokenUsage = {\n        promptTokens: response.usage.input_tokens,\n        completionTokens: response.usage.output_tokens,\n        totalTokens: response.usage.input_tokens + response.usage.output_tokens,\n      };\n      emitUsage(\n        this.options,\n        'anthropic',\n        'chat',\n        response.model || model,\n        usage,\n        startTime,\n        options.usageTags,\n      );\n\n      return {\n        content: textContent,\n        model: response.model,\n        finishReason: this.mapFinishReason(response.stop_reason),\n        usage,\n        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,\n      };\n    } catch (error) {\n      if (controls?.didTimeout()) {\n        throw new AIError(\n          `AI request timed out after ${controls.timeout}ms`,\n          'AI_TIMEOUT',\n          'anthropic',\n          options.model,\n        );\n      }\n      if (options.signal?.aborted) {\n        throw new AIError(\n          'AI request aborted by caller',\n          'AI_ABORTED',\n          'anthropic',\n          options.model,\n        );\n      }\n      throw this.mapError(error);\n    } finally {\n      controls?.cleanup();\n    }\n  }\n\n  async complete(\n    prompt: string,\n    options: CompletionOptions = {},\n  ): Promise<AIResponse> {\n    return this.chat([{ role: 'user', content: prompt }], {\n      model: options.model,\n      maxTokens: options.maxTokens,\n      temperature: options.temperature,\n      topP: options.topP,\n      n: options.n,\n      stop: options.stop,\n      stream: options.stream,\n      onProgress: options.onProgress,\n      signal: options.signal,\n      timeout: options.timeout,\n      reasoning: options.reasoning,\n      usageTags: options.usageTags,\n      continueOnLength: options.continueOnLength,\n    });\n  }\n\n  /**\n   * Simple message interface for single-turn interactions with optional history\n   *\n   * @param text - The message text to send\n   * @param options - Configuration options including history, model, etc.\n   * @returns Promise resolving to the response content string\n   *\n   * @example\n   * ```typescript\n   * // Simple usage\n   * const response = await provider.message('Hello!');\n   *\n   * // With history\n   * const response = await provider.message('What was my question?', {\n   *   history: [\n   *     { role: 'user', content: 'What is 2+2?' },\n   *     { role: 'assistant', content: '4' }\n   *   ]\n   * });\n   * ```\n   */\n  async message(text: string, options: MessageOptions = {}): Promise<string> {\n    // Build messages array from history + current message\n    const messages: AIMessage[] = [\n      ...(options.history || []),\n      { role: options.role || 'user', content: text },\n    ];\n\n    const response = await this.chat(messages, {\n      model: options.model,\n      maxTokens: options.maxTokens,\n      temperature: options.temperature,\n      topP: options.topP,\n      stop: options.stop,\n      stream: options.stream,\n      frequencyPenalty: options.frequencyPenalty,\n      presencePenalty: options.presencePenalty,\n      responseFormat: options.responseFormat,\n      seed: options.seed,\n      tools: options.tools,\n      toolChoice: options.toolChoice,\n      onProgress: options.onProgress,\n      signal: options.signal,\n      timeout: options.timeout,\n      reasoning: options.reasoning,\n      usageTags: options.usageTags,\n      continueOnLength: options.continueOnLength,\n    });\n\n    return response.content;\n  }\n\n  async embed(\n    _text: string | string[],\n    _options: EmbeddingOptions = {},\n  ): Promise<EmbeddingResponse> {\n    // Anthropic Claude doesn't provide embeddings API\n    throw new AIError(\n      'Anthropic Claude does not support embeddings. Use OpenAI or another provider for embeddings.',\n      'NOT_SUPPORTED',\n      'anthropic',\n    );\n  }\n\n  async embedImage(\n    _image: string | Buffer,\n    _options: ImageEmbeddingOptions = {},\n  ): Promise<EmbeddingResponse> {\n    throw new AIError(\n      'Anthropic Claude does not support image embeddings. Use OpenAI or Gemini.',\n      'NOT_SUPPORTED',\n      'anthropic',\n    );\n  }\n\n  async describeImage(\n    _image: string | Buffer,\n    _prompt?: string,\n    _options: ImageDescriptionOptions = {},\n  ): Promise<string> {\n    // Note: Claude does support vision, but we're keeping this as a stub for now\n    // A full implementation could use the chat API with image content\n    throw new AIError(\n      'Image description is not yet implemented for Anthropic. Use OpenAI or Gemini.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  async generateImage(\n    _prompt: string,\n    _options: ImageGenerationOptions = {},\n  ): Promise<ImageGenerationResponse> {\n    throw new AIError(\n      'Anthropic Claude does not support image generation. Use OpenAI or Gemini.',\n      'NOT_SUPPORTED',\n      'anthropic',\n    );\n  }\n\n  /**\n   * Streams a chat completion as text chunks.\n   *\n   * Streams yield text only and never surface tool calls, so `options.tools`\n   * and `options.toolChoice` are ignored: tools are declared only when the\n   * replayed history contains `tool_use` blocks (Anthropic requires it), with\n   * `tool_choice: { type: 'none' }`. Use `chat()` for rounds that may call\n   * tools.\n   */\n  async *stream(\n    messages: AIMessage[],\n    options: ChatOptions = {},\n  ): AsyncIterable<string> {\n    const startTime = Date.now();\n    let controls: PreparedRequestControls | undefined;\n    try {\n      await this.ensureClient();\n\n      const { system, anthropicMessages } =\n        this.mapMessagesToAnthropic(messages);\n\n      const model = options.model || this.options.defaultModel;\n      options = normalizeChatOptions(this.options, options, 'anthropic', model);\n      controls = prepareRequestControls(this.options, options);\n\n      const requestParams: Record<string, any> = {\n        model,\n        messages: anthropicMessages,\n        max_tokens: options.maxTokens,\n        temperature: options.temperature,\n        top_p: options.topP,\n        stop_sequences: Array.isArray(options.stop)\n          ? options.stop\n          : options.stop\n            ? [options.stop]\n            : undefined,\n        system: system || undefined,\n        // stream() yields text only, so a tool call would be lost: declare\n        // tools only when the replayed history requires it, with\n        // tool_choice none.\n        ...this.mapHistoryToolParams(anthropicMessages),\n        stream: true,\n      };\n      const thinking = this.mapThinking(options, anthropicMessages);\n      if (thinking) {\n        requestParams.thinking = thinking;\n      }\n      const stream = await this.client.messages.create(requestParams, {\n        signal: controls.signal,\n        timeout: controls.timeout,\n      });\n\n      let streamStopReason: string | null = null;\n      for await (const chunk of stream) {\n        if (chunk.type === 'message_delta' && chunk.delta?.stop_reason) {\n          streamStopReason = chunk.delta.stop_reason;\n        }\n        if (\n          chunk.type === 'content_block_delta' &&\n          chunk.delta.type === 'text_delta'\n        ) {\n          if (options.onProgress) {\n            options.onProgress(chunk.delta.text);\n          }\n          yield chunk.delta.text;\n        }\n      }\n      options.onFinishReason?.(\n        this.mapFinishReason(streamStopReason) ?? 'stop',\n      );\n\n      emitUsage(\n        this.options,\n        'anthropic',\n        'stream',\n        model!,\n        undefined,\n        startTime,\n        options.usageTags,\n      );\n    } catch (error) {\n      if (controls?.didTimeout()) {\n        throw new AIError(\n          `AI request timed out after ${controls.timeout}ms`,\n          'AI_TIMEOUT',\n          'anthropic',\n          options.model,\n        );\n      }\n      if (options.signal?.aborted) {\n        throw new AIError(\n          'AI request aborted by caller',\n          'AI_ABORTED',\n          'anthropic',\n          options.model,\n        );\n      }\n      throw this.mapError(error);\n    } finally {\n      controls?.cleanup();\n    }\n  }\n\n  async countTokens(text: string): Promise<number> {\n    // Anthropic doesn't provide a direct token counting API\n    // This is an approximation - Claude uses a different tokenizer than OpenAI\n    return Math.ceil(text.length / 3.5); // Slightly different ratio for Claude\n  }\n\n  async getModels(): Promise<AIModel[]> {\n    // Return static list of known Claude models\n    return [\n      {\n        id: 'claude-3-5-sonnet-20241022',\n        name: 'Claude 3.5 Sonnet',\n        description: 'Most intelligent Claude model with balanced performance',\n        contextLength: 200000,\n        capabilities: ['text', 'chat', 'vision', 'functions'],\n        supportsFunctions: true,\n        supportsVision: true,\n      },\n      {\n        id: 'claude-3-5-haiku-20241022',\n        name: 'Claude 3.5 Haiku',\n        description: 'Fastest Claude model for simple tasks',\n        contextLength: 200000,\n        capabilities: ['text', 'chat', 'vision'],\n        supportsFunctions: true,\n        supportsVision: true,\n      },\n      {\n        id: 'claude-3-opus-20240229',\n        name: 'Claude 3 Opus',\n        description: 'Most powerful Claude model for complex tasks',\n        contextLength: 200000,\n        capabilities: ['text', 'chat', 'vision', 'functions'],\n        supportsFunctions: true,\n        supportsVision: true,\n      },\n      {\n        id: 'claude-3-sonnet-20240229',\n        name: 'Claude 3 Sonnet',\n        description: 'Balanced Claude model for most tasks',\n        contextLength: 200000,\n        capabilities: ['text', 'chat', 'vision'],\n        supportsFunctions: true,\n        supportsVision: true,\n      },\n      {\n        id: 'claude-3-haiku-20240307',\n        name: 'Claude 3 Haiku',\n        description: 'Fast Claude model for simple tasks',\n        contextLength: 200000,\n        capabilities: ['text', 'chat', 'vision'],\n        supportsFunctions: false,\n        supportsVision: true,\n      },\n    ];\n  }\n\n  async getCapabilities(): Promise<AICapabilities> {\n    return {\n      chat: true,\n      completion: true,\n      embeddings: false, // Claude doesn't support embeddings\n      streaming: true,\n      functions: true,\n      vision: true,\n      fineTuning: false,\n      imageEmbeddings: false,\n      imageGeneration: false,\n      videoGeneration: false,\n      tts: false,\n      voiceCloning: false,\n      voiceDesign: false,\n      maxContextLength: 200000,\n      supportedOperations: [\n        'chat',\n        'completion',\n        'streaming',\n        'functions',\n        'vision',\n      ],\n    };\n  }\n\n  // ============================================================================\n  // Video Generation Methods (Not supported - use gemini, byteplus-modelark,\n  // or openai-compat-video provider)\n  // ============================================================================\n\n  async submitVideoGenerationJob(\n    _options: VideoGenerationOptions,\n  ): Promise<VideoGenerationJob> {\n    throw new AIError(\n      'Video generation is not supported by Anthropic provider. Use gemini, byteplus-modelark, or openai-compat-video provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  async getVideoGenerationJob(\n    _handle: VideoGenerationJob,\n  ): Promise<VideoGenerationStatusResult> {\n    throw new AIError(\n      'Video generation is not supported by Anthropic provider. Use gemini, byteplus-modelark, or openai-compat-video provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  async fetchVideoGenerationResult(\n    _handle: VideoGenerationJob,\n  ): Promise<VideoGenerationResult> {\n    throw new AIError(\n      'Video generation is not supported by Anthropic provider. Use gemini, byteplus-modelark, or openai-compat-video provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  async cancelVideoGenerationJob(_handle: VideoGenerationJob): Promise<void> {\n    throw new AIError(\n      'Video generation is not supported by Anthropic provider. Use gemini, byteplus-modelark, or openai-compat-video provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  async validateVideoGenerationAccess(): Promise<boolean> {\n    throw new AIError(\n      'Video generation is not supported by Anthropic provider. Use gemini, byteplus-modelark, or openai-compat-video provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  // ============================================================================\n  // TTS Methods (Not supported - use Qwen3-TTS provider)\n  // ============================================================================\n\n  async synthesizeSpeech(\n    _text: string,\n    _options?: TTSOptions,\n  ): Promise<TTSResponse> {\n    throw new AIError(\n      'TTS is not supported by Anthropic provider. Use Qwen3-TTS provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  streamSpeech(_text: string, _options?: TTSOptions): AsyncIterable<Buffer> {\n    const error = new AIError(\n      'TTS streaming is not supported by Anthropic provider. Use Qwen3-TTS provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n    return {\n      [Symbol.asyncIterator]: () => ({\n        next: () => Promise.reject(error),\n      }),\n    };\n  }\n\n  async cloneVoice(_options: VoiceCloneOptions): Promise<Voice> {\n    throw new AIError(\n      'Voice cloning is not supported by Anthropic provider. Use Qwen3-TTS provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  async designVoice(_options: VoiceDesignOptions): Promise<Voice> {\n    throw new AIError(\n      'Voice design is not supported by Anthropic provider. Use Qwen3-TTS provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  async getVoices(_options?: VoiceListOptions): Promise<Voice[]> {\n    throw new AIError(\n      'Voice listing is not supported by Anthropic provider. Use Qwen3-TTS provider.',\n      'NOT_IMPLEMENTED',\n      'anthropic',\n    );\n  }\n\n  /**\n   * Maps internal messages to Anthropic Messages API turns.\n   *\n   * Assistant `tool_calls` become `tool_use` blocks and `role: 'tool'`\n   * results become `tool_result` blocks paired by `tool_call_id`\n   * (`tool_use_id`). Consecutive tool results are grouped into one user turn,\n   * as Anthropic requires every result for a turn to follow it directly.\n   * Only answered calls are replayed as `tool_use`, and only results whose\n   * `tool_call_id` matches a replayed call become `tool_result`. A result\n   * without `tool_call_id`, or one answering no replayed call, falls back to\n   * plain text (and a call left unanswered keeps only its text).\n   */\n  private mapMessagesToAnthropic(messages: AIMessage[]): {\n    system?: string;\n    anthropicMessages: AnthropicMessage[];\n  } {\n    // Anthropic handles system messages separately\n    let system: string | undefined;\n    const anthropicMessages: AnthropicMessage[] = [];\n    const answeredToolCallIds = new Set(\n      messages\n        .filter((message) => message.role === 'tool' && message.tool_call_id)\n        .map((message) => message.tool_call_id as string),\n    );\n    // Calls replayed as tool_use: those with an answer. Only results for\n    // these ids become tool_result blocks; any other result is an orphan\n    // Anthropic would reject, so it falls back to plain text.\n    const replayedToolUseIds = new Set<string>();\n    for (const message of messages) {\n      if (message.role !== 'assistant') continue;\n      for (const toolCall of message.tool_calls || []) {\n        if (answeredToolCallIds.has(toolCall.id)) {\n          replayedToolUseIds.add(toolCall.id);\n        }\n      }\n    }\n\n    for (const message of messages) {\n      const textContent = extractTextContent(message.content);\n      if (message.role === 'system') {\n        // Combine multiple system messages\n        system = system ? `${system}\\n\\n${textContent}` : textContent;\n        continue;\n      }\n\n      if (\n        message.role === 'tool' &&\n        message.tool_call_id &&\n        replayedToolUseIds.has(message.tool_call_id)\n      ) {\n        const block: AnthropicContentBlock = {\n          type: 'tool_result',\n          tool_use_id: message.tool_call_id,\n          content: textContent,\n        };\n        const previous = anthropicMessages[anthropicMessages.length - 1];\n        if (\n          previous?.role === 'user' &&\n          Array.isArray(previous.content) &&\n          previous.content.every((part) => part.type === 'tool_result')\n        ) {\n          previous.content.push(block);\n        } else {\n          anthropicMessages.push({ role: 'user', content: [block] });\n        }\n        continue;\n      }\n\n      const toolCalls =\n        message.role === 'assistant'\n          ? (message.tool_calls || []).filter((toolCall) =>\n              answeredToolCallIds.has(toolCall.id),\n            )\n          : [];\n      if (toolCalls.length > 0) {\n        const content: AnthropicContentBlock[] = [];\n        for (const toolCall of toolCalls) {\n          for (const block of toolCall.thinkingBlocks || []) {\n            content.push({ ...block });\n          }\n        }\n        if (textContent) {\n          content.push({ type: 'text', text: textContent });\n        }\n        for (const toolCall of toolCalls) {\n          content.push({\n            type: 'tool_use',\n            id: toolCall.id,\n            name: toolCall.function.name,\n            input: parseToolArguments(toolCall.function.arguments),\n          });\n        }\n        anthropicMessages.push({ role: 'assistant', content });\n        continue;\n      }\n\n      anthropicMessages.push({\n        role: message.role === 'assistant' ? 'assistant' : 'user',\n        content: textContent,\n      });\n    }\n\n    return { system, anthropicMessages };\n  }\n\n  /**\n   * Builds the `tools` / `tool_choice` request fields.\n   *\n   * Anthropic rejects a request whose history contains `tool_use` or\n   * `tool_result` blocks unless `tools` is declared. A tool loop's final,\n   * tool-less round (no `tools`, typically `toolChoice: 'none'`) still\n   * replays that history, so when the caller declares no tools but the\n   * history uses some, this declares a minimal definition for each tool the\n   * history references and sets `tool_choice: { type: 'none' }` so the model\n   * answers in text instead of calling them.\n   */\n  private mapToolParams(\n    options: ChatOptions,\n    anthropicMessages: AnthropicMessage[],\n  ): { tools?: Record<string, any>[]; tool_choice?: Record<string, any> } {\n    const tools = this.mapTools(options);\n    if (tools) {\n      return { tools, tool_choice: this.mapToolChoice(options.toolChoice) };\n    }\n    return this.mapHistoryToolParams(anthropicMessages);\n  }\n\n  /**\n   * Declares a minimal definition for each tool the replayed history\n   * references, with `tool_choice: { type: 'none' }`, or nothing when the\n   * history has no `tool_use` blocks. Used for tool-less rounds and for\n   * every stream (streams never yield tool calls).\n   */\n  private mapHistoryToolParams(anthropicMessages: AnthropicMessage[]): {\n    tools?: Record<string, any>[];\n    tool_choice?: Record<string, any>;\n  } {\n    // mapMessagesToAnthropic emits tool_result only for ids it replayed as\n    // tool_use (orphan results become text), so tool_use names cover every\n    // tool the history references.\n    const historyToolNames = new Set<string>();\n    for (const message of anthropicMessages) {\n      if (!Array.isArray(message.content)) continue;\n      for (const block of message.content) {\n        if (block.type === 'tool_use') historyToolNames.add(block.name);\n      }\n    }\n    if (historyToolNames.size === 0) {\n      return {};\n    }\n\n    return {\n      tools: [...historyToolNames].map((name) => ({\n        name,\n        description:\n          'Used earlier in this conversation; not available for this turn.',\n        input_schema: { type: 'object' },\n      })),\n      tool_choice: { type: 'none' },\n    };\n  }\n\n  /**\n   * Builds the `thinking` request field for `options.reasoning.maxTokens`.\n   *\n   * While thinking is enabled, Anthropic requires the assistant turn of an\n   * in-progress tool loop (the last assistant turn, when it holds `tool_use`)\n   * to start with its thinking blocks. They are replayed from\n   * `AIToolCall.thinkingBlocks`; when that turn has none (the history came\n   * from another provider, a store that dropped the field, or a call made\n   * without thinking), thinking is left off for this request rather than\n   * sending a request Anthropic would reject.\n   */\n  private mapThinking(\n    options: ChatOptions,\n    anthropicMessages: AnthropicMessage[],\n  ): { type: 'enabled'; budget_tokens: number } | undefined {\n    const budget = options.reasoning?.maxTokens || 0;\n    if (budget <= 0) return undefined;\n\n    const lastAssistant = [...anthropicMessages]\n      .reverse()\n      .find((message) => message.role === 'assistant');\n    if (\n      lastAssistant &&\n      Array.isArray(lastAssistant.content) &&\n      lastAssistant.content.some((block) => block.type === 'tool_use')\n    ) {\n      const firstType = lastAssistant.content[0]?.type;\n      if (firstType !== 'thinking' && firstType !== 'redacted_thinking') {\n        return undefined;\n      }\n    }\n\n    return { type: 'enabled', budget_tokens: budget };\n  }\n\n  private mapTools(options: ChatOptions): Record<string, any>[] | undefined {\n    return options.tools && options.tools.length > 0\n      ? options.tools.map((tool) => ({\n          name: tool.function.name,\n          description: tool.function.description || '',\n          input_schema: tool.function.parameters || { type: 'object' },\n        }))\n      : undefined;\n  }\n\n  private mapToolChoice(\n    toolChoice?:\n      | 'auto'\n      | 'none'\n      | { type: 'function'; function: { name: string } },\n  ): any {\n    if (!toolChoice || toolChoice === 'auto') {\n      return { type: 'auto' };\n    }\n\n    if (toolChoice === 'none') {\n      return { type: 'none' };\n    }\n\n    if (typeof toolChoice === 'object' && toolChoice.type === 'function') {\n      return {\n        type: 'tool',\n        name: toolChoice.function.name,\n      };\n    }\n\n    return { type: 'auto' };\n  }\n\n  private mapFinishReason(reason: string | null): AIResponse['finishReason'] {\n    switch (reason) {\n      case 'end_turn':\n        return 'stop';\n      case 'max_tokens':\n        return 'length';\n      case 'stop_sequence':\n        return 'stop';\n      case 'tool_use':\n        return 'tool_calls';\n      default:\n        return 'stop';\n    }\n  }\n\n  private mapError(error: unknown): AIError {\n    if (error instanceof AIError) {\n      return error;\n    }\n\n    // Map common HTTP status codes from Anthropic API\n    if (typeof error === 'object' && error !== null && 'status' in error) {\n      const apiError = error as { status: number; message?: string };\n      switch (apiError.status) {\n        case 401:\n          return new AuthenticationError('anthropic');\n        case 429:\n          return rateLimitErrorFrom('anthropic', error);\n        case 404:\n          return new ModelNotFoundError(\n            apiError.message || 'Model not found',\n            'anthropic',\n          );\n        case 413:\n          return new ContextLengthError('anthropic');\n      }\n    }\n\n    const errorMessage =\n      error instanceof Error\n        ? error.message\n        : 'Unknown Anthropic error occurred';\n    return new AIError(errorMessage, 'UNKNOWN_ERROR', 'anthropic');\n  }\n}\n\n/**\n * Thinking and redacted-thinking blocks from an Anthropic response, copied\n * with only the fields the API accepts back.\n */\nfunction extractThinkingBlocks(content: any[]): AIThinkingBlock[] {\n  const blocks: AIThinkingBlock[] = [];\n  for (const block of content || []) {\n    if (block?.type === 'thinking') {\n      blocks.push({\n        type: 'thinking',\n        thinking: block.thinking,\n        signature: block.signature,\n      });\n    } else if (block?.type === 'redacted_thinking') {\n      blocks.push({ type: 'redacted_thinking', data: block.data });\n    }\n  }\n  return blocks;\n}\n"],"mappings":"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"}