indusagi 0.12.19 → 0.12.21

package/dist/ai/providers/anthropic.js

@@ -10,41 +10,48 @@ import { parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, executeWithRetry, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
-// Stealth mode: Mimic Claude Code's tool naming exactly
-const claudeCodeVersion = "2.1.2";
-// Claude Code 2.x tool names (canonical casing)
-// Source: https://cchistory.mariozechner.at/data/prompts-2.1.11.md
-// To update: https://github.com/badlogic/cchistory
-const claudeCodeTools = [
-    "Read",
-    "Write",
-    "Edit",
-    "Bash",
-    "Grep",
-    "Glob",
-    "AskUserQuestion",
-    "EnterPlanMode",
-    "ExitPlanMode",
-    "KillShell",
-    "NotebookEdit",
-    "Skill",
-    "Task",
-    "TaskOutput",
-    "TodoWrite",
-    "WebFetch",
-    "WebSearch",
-];
-const ccToolLookup = new Map(claudeCodeTools.map((t) => [t.toLowerCase(), t]));
-// Convert tool name to CC canonical casing if it matches (case-insensitive)
-const toClaudeCodeName = (name) => ccToolLookup.get(name.toLowerCase()) ?? name;
-const fromClaudeCodeName = (name, tools) => {
-    if (tools && tools.length > 0) {
-        const lowerName = name.toLowerCase();
-        const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
-        if (matchedTool)
-            return matchedTool.name;
-    }
-    return name;
+const ClaudeCodeNameCodec = {
+    version: "2.1.2",
+    canonicalToolNames: [
+        "Read",
+        "Write",
+        "Edit",
+        "Bash",
+        "Grep",
+        "Glob",
+        "AskUserQuestion",
+        "EnterPlanMode",
+        "ExitPlanMode",
+        "KillShell",
+        "NotebookEdit",
+        "Skill",
+        "Task",
+        "TaskOutput",
+        "TodoWrite",
+        "WebFetch",
+        "WebSearch",
+    ],
+    lookup: undefined,
+    ensureLookup() {
+        if (!this.lookup) {
+            this.lookup = new Map(this.canonicalToolNames.map((toolName) => [toolName.toLowerCase(), toolName]));
+        }
+        return this.lookup;
+    },
+    encode(name) {
+        const lookup = this.ensureLookup();
+        return lookup.get(name.toLowerCase()) ?? name;
+    },
+    decode(name, tools) {
+        if (tools && tools.length > 0) {
+            const lowerName = name.toLowerCase();
+            const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
+            if (matchedTool) {
+                return matchedTool.name;
+            }
+        }
+        return name;
+    },
 };
 /**
  * Convert content blocks to Anthropic API format
@@ -89,6 +96,10 @@ function convertContentBlocks(content) {
  * Anthropic-specific `MessageCreateParamsStreaming`.
  */
 export class AnthropicRequestBuilder {
+    model;
+    context;
+    isOAuthToken;
+    options;
     constructor(model, context, isOAuthToken, options) {
         this.model = model;
         this.context = context;
@@ -119,6 +130,7 @@ function mergeHeaders(...headerSources) {
  * Wraps the Anthropic SDK streaming API and emits standardized assistant events.
  */
 export class AnthropicStreamHandler extends BaseStreamHandler {
+    executeFn;
     constructor(executeFn) {
         super();
         this.executeFn = executeFn;
@@ -141,6 +153,173 @@ export class AnthropicStreamHandler extends BaseStreamHandler {
             onEvent(event);
     }
 }
+class AnthropicEventReducer {
+    blocks;
+    output;
+    stream;
+    model;
+    contextTools;
+    oauthMode;
+    handlers;
+    constructor(blocks, output, stream, model, contextTools, oauthMode) {
+        this.blocks = blocks;
+        this.output = output;
+        this.stream = stream;
+        this.model = model;
+        this.contextTools = contextTools;
+        this.oauthMode = oauthMode;
+        this.handlers = {
+            message_start: (event) => this.onMessageStart(event),
+            content_block_start: (event) => this.onContentBlockStart(event),
+            content_block_delta: (event) => this.onContentBlockDelta(event),
+            content_block_stop: (event) => this.onContentBlockStop(event),
+            message_delta: (event) => this.onMessageDelta(event),
+        };
+    }
+    reduce(event) {
+        const handler = this.handlers[event.type];
+        if (handler) {
+            handler(event);
+        }
+    }
+    onMessageStart(event) {
+        this.updateUsage(event?.message?.usage);
+    }
+    onContentBlockStart(event) {
+        if (event.content_block.type === "text") {
+            const block = {
+                type: "text",
+                text: "",
+                index: event.index,
+            };
+            this.output.content.push(block);
+            this.stream.push({ type: "text_start", contentIndex: this.output.content.length - 1, partial: this.output });
+            return;
+        }
+        if (event.content_block.type === "thinking") {
+            const block = {
+                type: "thinking",
+                thinking: "",
+                thinkingSignature: "",
+                index: event.index,
+            };
+            this.output.content.push(block);
+            this.stream.push({ type: "thinking_start", contentIndex: this.output.content.length - 1, partial: this.output });
+            return;
+        }
+        if (event.content_block.type === "tool_use") {
+            const decodedName = this.oauthMode
+                ? ClaudeCodeNameCodec.decode(event.content_block.name, this.contextTools)
+                : event.content_block.name;
+            const block = {
+                type: "toolCall",
+                id: event.content_block.id,
+                name: decodedName,
+                arguments: event.content_block.input,
+                partialJson: "",
+                index: event.index,
+            };
+            this.output.content.push(block);
+            this.stream.push({ type: "toolcall_start", contentIndex: this.output.content.length - 1, partial: this.output });
+        }
+    }
+    onContentBlockDelta(event) {
+        const blockIndex = this.blocks.findIndex((block) => block.index === event.index);
+        const block = this.blocks[blockIndex];
+        if (!block) {
+            return;
+        }
+        if (event.delta.type === "text_delta" && block.type === "text") {
+            block.text += event.delta.text;
+            this.stream.push({
+                type: "text_delta",
+                contentIndex: blockIndex,
+                delta: event.delta.text,
+                partial: this.output,
+            });
+            return;
+        }
+        if (event.delta.type === "thinking_delta" && block.type === "thinking") {
+            block.thinking += event.delta.thinking;
+            this.stream.push({
+                type: "thinking_delta",
+                contentIndex: blockIndex,
+                delta: event.delta.thinking,
+                partial: this.output,
+            });
+            return;
+        }
+        if (event.delta.type === "input_json_delta" && block.type === "toolCall") {
+            block.partialJson += event.delta.partial_json;
+            block.arguments = parseStreamingJson(block.partialJson);
+            this.stream.push({
+                type: "toolcall_delta",
+                contentIndex: blockIndex,
+                delta: event.delta.partial_json,
+                partial: this.output,
+            });
+            return;
+        }
+        if (event.delta.type === "signature_delta" && block.type === "thinking") {
+            block.thinkingSignature = block.thinkingSignature || "";
+            block.thinkingSignature += event.delta.signature;
+        }
+    }
+    onContentBlockStop(event) {
+        const blockIndex = this.blocks.findIndex((block) => block.index === event.index);
+        const block = this.blocks[blockIndex];
+        if (!block) {
+            return;
+        }
+        delete block.index;
+        if (block.type === "text") {
+            this.stream.push({
+                type: "text_end",
+                contentIndex: blockIndex,
+                content: block.text,
+                partial: this.output,
+            });
+            return;
+        }
+        if (block.type === "thinking") {
+            this.stream.push({
+                type: "thinking_end",
+                contentIndex: blockIndex,
+                content: block.thinking,
+                partial: this.output,
+            });
+            return;
+        }
+        if (block.type === "toolCall") {
+            block.arguments = parseStreamingJson(block.partialJson);
+            delete block.partialJson;
+            this.stream.push({
+                type: "toolcall_end",
+                contentIndex: blockIndex,
+                toolCall: block,
+                partial: this.output,
+            });
+        }
+    }
+    onMessageDelta(event) {
+        if (event.delta.stop_reason) {
+            this.output.stopReason = mapProviderStopReason(event.delta.stop_reason, "anthropic");
+        }
+        this.updateUsage(event.usage);
+    }
+    updateUsage(usage) {
+        if (!usage) {
+            return;
+        }
+        this.output.usage.input = usage.input_tokens || 0;
+        this.output.usage.output = usage.output_tokens || 0;
+        this.output.usage.cacheRead = usage.cache_read_input_tokens || 0;
+        this.output.usage.cacheWrite = usage.cache_creation_input_tokens || 0;
+        this.output.usage.totalTokens =
+            this.output.usage.input + this.output.usage.output + this.output.usage.cacheRead + this.output.usage.cacheWrite;
+        calculateCost(this.model, this.output.usage);
+    }
+}
 export const streamAnthropic = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
     const output = createAssistantMessageOutput(model);
@@ -154,152 +333,11 @@ export const streamAnthropic = (model, context, options) => {
             events.start();
             const blocks = output.content;
             const streamHandler = new AnthropicStreamHandler();
+            const reducer = new AnthropicEventReducer(blocks, output, stream, model, context.tools, isOAuthToken);
             await executeWithRetry(async () => {
                 const anthropicStream = client.messages.stream({ ...params, stream: true }, { signal: options?.signal });
                 await streamHandler.process(anthropicStream, (event) => {
-                    if (event.type === "message_start") {
-                        // Capture initial token usage from message_start event
-                        // This ensures we have input token counts even if the stream is aborted early
-                        output.usage.input = event.message.usage.input_tokens || 0;
-                        output.usage.output = event.message.usage.output_tokens || 0;
-                        output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
-                        output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
-                        // Anthropic doesn't provide total_tokens, compute from components
-                        output.usage.totalTokens =
-                            output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-                        calculateCost(model, output.usage);
-                    }
-                    else if (event.type === "content_block_start") {
-                        if (event.content_block.type === "text") {
-                            const block = {
-                                type: "text",
-                                text: "",
-                                index: event.index,
-                            };
-                            output.content.push(block);
-                            stream.push({ type: "text_start", contentIndex: output.content.length - 1, partial: output });
-                        }
-                        else if (event.content_block.type === "thinking") {
-                            const block = {
-                                type: "thinking",
-                                thinking: "",
-                                thinkingSignature: "",
-                                index: event.index,
-                            };
-                            output.content.push(block);
-                            stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
-                        }
-                        else if (event.content_block.type === "tool_use") {
-                            const block = {
-                                type: "toolCall",
-                                id: event.content_block.id,
-                                name: isOAuthToken
-                                    ? fromClaudeCodeName(event.content_block.name, context.tools)
-                                    : event.content_block.name,
-                                arguments: event.content_block.input,
-                                partialJson: "",
-                                index: event.index,
-                            };
-                            output.content.push(block);
-                            stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
-                        }
-                    }
-                    else if (event.type === "content_block_delta") {
-                        if (event.delta.type === "text_delta") {
-                            const index = blocks.findIndex((b) => b.index === event.index);
-                            const block = blocks[index];
-                            if (block && block.type === "text") {
-                                block.text += event.delta.text;
-                                stream.push({
-                                    type: "text_delta",
-                                    contentIndex: index,
-                                    delta: event.delta.text,
-                                    partial: output,
-                                });
-                            }
-                        }
-                        else if (event.delta.type === "thinking_delta") {
-                            const index = blocks.findIndex((b) => b.index === event.index);
-                            const block = blocks[index];
-                            if (block && block.type === "thinking") {
-                                block.thinking += event.delta.thinking;
-                                stream.push({
-                                    type: "thinking_delta",
-                                    contentIndex: index,
-                                    delta: event.delta.thinking,
-                                    partial: output,
-                                });
-                            }
-                        }
-                        else if (event.delta.type === "input_json_delta") {
-                            const index = blocks.findIndex((b) => b.index === event.index);
-                            const block = blocks[index];
-                            if (block && block.type === "toolCall") {
-                                block.partialJson += event.delta.partial_json;
-                                block.arguments = parseStreamingJson(block.partialJson);
-                                stream.push({
-                                    type: "toolcall_delta",
-                                    contentIndex: index,
-                                    delta: event.delta.partial_json,
-                                    partial: output,
-                                });
-                            }
-                        }
-                        else if (event.delta.type === "signature_delta") {
-                            const index = blocks.findIndex((b) => b.index === event.index);
-                            const block = blocks[index];
-                            if (block && block.type === "thinking") {
-                                block.thinkingSignature = block.thinkingSignature || "";
-                                block.thinkingSignature += event.delta.signature;
-                            }
-                        }
-                    }
-                    else if (event.type === "content_block_stop") {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block) {
-                            delete block.index;
-                            if (block.type === "text") {
-                                stream.push({
-                                    type: "text_end",
-                                    contentIndex: index,
-                                    content: block.text,
-                                    partial: output,
-                                });
-                            }
-                            else if (block.type === "thinking") {
-                                stream.push({
-                                    type: "thinking_end",
-                                    contentIndex: index,
-                                    content: block.thinking,
-                                    partial: output,
-                                });
-                            }
-                            else if (block.type === "toolCall") {
-                                block.arguments = parseStreamingJson(block.partialJson);
-                                delete block.partialJson;
-                                stream.push({
-                                    type: "toolcall_end",
-                                    contentIndex: index,
-                                    toolCall: block,
-                                    partial: output,
-                                });
-                            }
-                        }
-                    }
-                    else if (event.type === "message_delta") {
-                        if (event.delta.stop_reason) {
-                            output.stopReason = mapProviderStopReason(event.delta.stop_reason, "anthropic");
-                        }
-                        output.usage.input = event.usage.input_tokens || 0;
-                        output.usage.output = event.usage.output_tokens || 0;
-                        output.usage.cacheRead = event.usage.cache_read_input_tokens || 0;
-                        output.usage.cacheWrite = event.usage.cache_creation_input_tokens || 0;
-                        // Anthropic doesn't provide total_tokens, compute from components
-                        output.usage.totalTokens =
-                            output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-                        calculateCost(model, output.usage);
-                    }
+                    reducer.reduce(event);
                 });
             }, {
                 maxAttempts: options?.signal ? 1 : 3,
@@ -358,7 +396,7 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders) {
             accept: "application/json",
             "anthropic-dangerous-direct-browser-access": "true",
             "anthropic-beta": `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}`,
-            "user-agent": `claude-cli/${claudeCodeVersion} (external, cli)`,
+            "user-agent": `claude-cli/${ClaudeCodeNameCodec.version} (external, cli)`,
             "x-app": "cli",
         }, model.headers, optionsHeaders);
         const client = new Anthropic({
@@ -446,164 +484,182 @@ function buildParams(model, context, isOAuthToken, options) {
     return params;
 }
 // Normalize tool call IDs to match Anthropic's required pattern and length
-function convertMessages(messages, model, isOAuthToken) {
-    const params = [];
-    // Transform messages for cross-provider compatibility
-    const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
-    for (let i = 0; i < transformedMessages.length; i++) {
-        const msg = transformedMessages[i];
-        if (msg.role === "user") {
-            if (typeof msg.content === "string") {
-                if (msg.content.trim().length > 0) {
-                    params.push({
-                        role: "user",
-                        content: sanitizeSurrogates(msg.content),
-                    });
-                }
+class AnthropicMessageComposer {
+    model;
+    oauthMode;
+    constructor(model, oauthMode) {
+        this.model = model;
+        this.oauthMode = oauthMode;
+    }
+    compose(messages) {
+        const params = [];
+        const transformedMessages = transformMessages(messages, this.model, normalizeToolCallId);
+        for (let i = 0; i < transformedMessages.length; i++) {
+            const message = transformedMessages[i];
+            if (message.role === "user") {
+                const userParam = this.composeUserMessage(message);
+                if (userParam)
+                    params.push(userParam);
+                continue;
             }
-            else {
-                const blocks = msg.content.map((item) => {
-                    if (item.type === "text") {
-                        return {
-                            type: "text",
-                            text: sanitizeSurrogates(item.text),
-                        };
-                    }
-                    else {
-                        return {
-                            type: "image",
-                            source: {
-                                type: "base64",
-                                media_type: item.mimeType,
-                                data: item.data,
-                            },
-                        };
-                    }
-                });
-                let filteredBlocks = !model?.input.includes("image") ? blocks.filter((b) => b.type !== "image") : blocks;
-                filteredBlocks = filteredBlocks.filter((b) => {
-                    if (b.type === "text") {
-                        return b.text.trim().length > 0;
-                    }
-                    return true;
-                });
-                if (filteredBlocks.length === 0)
-                    continue;
-                params.push({
-                    role: "user",
-                    content: filteredBlocks,
-                });
+            if (message.role === "assistant") {
+                const assistantParam = this.composeAssistantMessage(message);
+                if (assistantParam)
+                    params.push(assistantParam);
+                continue;
             }
+            const groupedToolResults = this.composeToolResultBatch(transformedMessages, i);
+            params.push(groupedToolResults.param);
+            i = groupedToolResults.nextIndex;
         }
-        else if (msg.role === "assistant") {
-            const blocks = [];
-            for (const block of msg.content) {
-                if (block.type === "text") {
-                    if (block.text.trim().length === 0)
-                        continue;
-                    blocks.push({
-                        type: "text",
-                        text: sanitizeSurrogates(block.text),
-                    });
-                }
-                else if (block.type === "thinking") {
-                    if (block.thinking.trim().length === 0)
-                        continue;
-                    // If thinking signature is missing/empty (e.g., from aborted stream),
-                    // convert to plain text block without <thinking> tags to avoid API rejection
-                    // and prevent Claude from mimicking the tags in responses
-                    if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
-                        blocks.push({
-                            type: "text",
-                            text: sanitizeSurrogates(block.thinking),
-                        });
-                    }
-                    else {
-                        blocks.push({
-                            type: "thinking",
-                            thinking: sanitizeSurrogates(block.thinking),
-                            signature: block.thinkingSignature,
-                        });
-                    }
+        applyCacheControlToLatestUserMessage(params);
+        return params;
+    }
+    composeUserMessage(message) {
+        if (typeof message.content === "string") {
+            if (message.content.trim().length === 0) {
+                return undefined;
+            }
+            return {
+                role: "user",
+                content: sanitizeSurrogates(message.content),
+            };
+        }
+        const blocks = message.content.map((item) => {
+            if (item.type === "text") {
+                return {
+                    type: "text",
+                    text: sanitizeSurrogates(item.text),
+                };
+            }
+            return {
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: item.mimeType,
+                    data: item.data,
+                },
+            };
+        });
+        let filteredBlocks = !this.model?.input.includes("image") ? blocks.filter((block) => block.type !== "image") : blocks;
+        filteredBlocks = filteredBlocks.filter((block) => (block.type === "text" ? block.text.trim().length > 0 : true));
+        if (filteredBlocks.length === 0) {
+            return undefined;
+        }
+        return {
+            role: "user",
+            content: filteredBlocks,
+        };
+    }
+    composeAssistantMessage(message) {
+        const blocks = [];
+        for (const block of message.content) {
+            if (block.type === "text") {
+                if (block.text.trim().length === 0)
+                    continue;
+                blocks.push({ type: "text", text: sanitizeSurrogates(block.text) });
+                continue;
+            }
+            if (block.type === "thinking") {
+                if (block.thinking.trim().length === 0)
+                    continue;
+                if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
+                    blocks.push({ type: "text", text: sanitizeSurrogates(block.thinking) });
                 }
-                else if (block.type === "toolCall") {
+                else {
                     blocks.push({
-                        type: "tool_use",
-                        id: block.id,
-                        name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
-                        input: block.arguments,
+                        type: "thinking",
+                        thinking: sanitizeSurrogates(block.thinking),
+                        signature: block.thinkingSignature,
                     });
                 }
-            }
-            if (blocks.length === 0)
                 continue;
-            params.push({
-                role: "assistant",
-                content: blocks,
-            });
+            }
+            if (block.type === "toolCall") {
+                blocks.push({
+                    type: "tool_use",
+                    id: block.id,
+                    name: this.oauthMode ? ClaudeCodeNameCodec.encode(block.name) : block.name,
+                    input: block.arguments,
+                });
+            }
+        }
+        if (blocks.length === 0) {
+            return undefined;
         }
-        else if (msg.role === "toolResult") {
-            // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint
-            const toolResults = [];
-            // Add the current tool result
+        return {
+            role: "assistant",
+            content: blocks,
+        };
+    }
+    composeToolResultBatch(messages, startIndex) {
+        const toolResults = [];
+        const first = messages[startIndex];
+        toolResults.push({
+            type: "tool_result",
+            tool_use_id: first.toolCallId,
+            content: convertContentBlocks(first.content),
+            is_error: first.isError,
+        });
+        let cursor = startIndex + 1;
+        while (cursor < messages.length && messages[cursor].role === "toolResult") {
+            const next = messages[cursor];
             toolResults.push({
                 type: "tool_result",
-                tool_use_id: msg.toolCallId,
-                content: convertContentBlocks(msg.content),
-                is_error: msg.isError,
-            });
-            // Look ahead for consecutive toolResult messages
-            let j = i + 1;
-            while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                const nextMsg = transformedMessages[j]; // We know it's a toolResult
-                toolResults.push({
-                    type: "tool_result",
-                    tool_use_id: nextMsg.toolCallId,
-                    content: convertContentBlocks(nextMsg.content),
-                    is_error: nextMsg.isError,
-                });
-                j++;
-            }
-            // Skip the messages we've already processed
-            i = j - 1;
-            // Add a single user message with all tool results
-            params.push({
-                role: "user",
-                content: toolResults,
+                tool_use_id: next.toolCallId,
+                content: convertContentBlocks(next.content),
+                is_error: next.isError,
             });
+            cursor++;
         }
+        return {
+            param: { role: "user", content: toolResults },
+            nextIndex: cursor - 1,
+        };
     }
-    // Add cache_control to the last user message to cache conversation history
-    if (params.length > 0) {
-        const lastMessage = params[params.length - 1];
-        if (lastMessage.role === "user") {
-            // Add cache control to the last content block
-            if (Array.isArray(lastMessage.content)) {
-                const lastBlock = lastMessage.content[lastMessage.content.length - 1];
-                if (lastBlock &&
-                    (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result")) {
-                    lastBlock.cache_control = { type: "ephemeral" };
-                }
-            }
-        }
+}
+class AnthropicToolMapper {
+    oauthMode;
+    constructor(oauthMode) {
+        this.oauthMode = oauthMode;
     }
-    return params;
+    map(tools) {
+        if (!tools)
+            return [];
+        return tools.map((tool) => {
+            const jsonSchema = tool.parameters;
+            return {
+                name: this.oauthMode ? ClaudeCodeNameCodec.encode(tool.name) : tool.name,
+                description: tool.description,
+                input_schema: {
+                    type: "object",
+                    properties: jsonSchema.properties || {},
+                    required: jsonSchema.required || [],
+                },
+            };
+        });
+    }
+}
+function applyCacheControlToLatestUserMessage(params) {
+    if (params.length === 0)
+        return;
+    const lastMessage = params[params.length - 1];
+    if (lastMessage.role !== "user")
+        return;
+    if (!Array.isArray(lastMessage.content))
+        return;
+    const lastBlock = lastMessage.content[lastMessage.content.length - 1];
+    if (!lastBlock)
+        return;
+    if (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result") {
+        lastBlock.cache_control = { type: "ephemeral" };
+    }
+}
+function convertMessages(messages, model, isOAuthToken) {
+    return new AnthropicMessageComposer(model, isOAuthToken).compose(messages);
 }
 function convertTools(tools, isOAuthToken) {
-    if (!tools)
-        return [];
-    return tools.map((tool) => {
-        const jsonSchema = tool.parameters; // TypeBox already generates JSON Schema
-        return {
-            name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
-            description: tool.description,
-            input_schema: {
-                type: "object",
-                properties: jsonSchema.properties || {},
-                required: jsonSchema.required || [],
-            },
-        };
-    });
+    return new AnthropicToolMapper(isOAuthToken).map(tools);
 }
 function mapStopReason(reason) {
     switch (reason) {
@@ -619,10 +675,8 @@ function mapStopReason(reason) {
             return "stop";
         case "stop_sequence":
             return "stop"; // We don't supply stop sequences, so this should never happen
-        default: {
-            const _exhaustive = reason;
-            throw new Error(`Unhandled stop reason: ${_exhaustive}`);
-        }
+        default:
+            return "stop";
     }
 }
 //# sourceMappingURL=anthropic.js.map