@aigne/anthropic 0.14.16-beta.2 → 0.14.16-beta.20

package/CHANGELOG.md

@@ -1,5 +1,232 @@
 # Changelog
 
+## [0.14.16-beta.20](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.19...anthropic-v0.14.16-beta.20) (2026-01-13)
+
+
+### Bug Fixes
+
+* **anthropic:** handle null content blocks in streaming responses ([9fefd6f](https://github.com/AIGNE-io/aigne-framework/commit/9fefd6fcca58bb8a59616560f86a04a0015f6aca))
+
+## [0.14.16-beta.19](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.18...anthropic-v0.14.16-beta.19) (2026-01-13)
+
+
+### Bug Fixes
+
+* **anthropic:** simplify structured output with output tool pattern ([#899](https://github.com/AIGNE-io/aigne-framework/issues/899)) ([a6033c8](https://github.com/AIGNE-io/aigne-framework/commit/a6033c8a9ccf5e8ff6bcb14bc68c43a990ce2fa2))
+* **anthropic:** update structured output tool name to generate_json ([897e94d](https://github.com/AIGNE-io/aigne-framework/commit/897e94d82a1bbfa46ae13038a58a65cba6a3b259))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.18
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.18
+
+## [0.14.16-beta.18](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.17...anthropic-v0.14.16-beta.18) (2026-01-12)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.17
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.17
+
+## [0.14.16-beta.17](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.16...anthropic-v0.14.16-beta.17) (2026-01-12)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.16
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.16
+
+## [0.14.16-beta.16](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.15...anthropic-v0.14.16-beta.16) (2026-01-10)
+
+
+### Bug Fixes
+
+* **core:** simplify token-estimator logic for remaining characters ([45d43cc](https://github.com/AIGNE-io/aigne-framework/commit/45d43ccd3afd636cfb459eea2e6551e8f9c53765))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.15
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.15
+
+## [0.14.16-beta.15](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.14...anthropic-v0.14.16-beta.15) (2026-01-09)
+
+
+### Bug Fixes
+
+* **core:** default enable auto breakpoints for chat model ([d4a6b83](https://github.com/AIGNE-io/aigne-framework/commit/d4a6b8323d6c83be45669885b32febb545bdf797))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.14
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.14
+
+## [0.14.16-beta.14](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.13...anthropic-v0.14.16-beta.14) (2026-01-08)
+
+
+### Bug Fixes
+
+* bump version ([696560f](https://github.com/AIGNE-io/aigne-framework/commit/696560fa2673eddcb4d00ac0523fbbbde7273cb3))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.13
+    * @aigne/platform-helpers bumped to 0.6.7-beta.1
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.13
+
+## [0.14.16-beta.13](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.12...anthropic-v0.14.16-beta.13) (2026-01-07)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.12
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.12
+
+## [0.14.16-beta.12](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.11...anthropic-v0.14.16-beta.12) (2026-01-06)
+
+
+### Bug Fixes
+
+* **core:** preserve Agent Skill in session compact and support complex tool result content ([#876](https://github.com/AIGNE-io/aigne-framework/issues/876)) ([edb86ae](https://github.com/AIGNE-io/aigne-framework/commit/edb86ae2b9cfe56a8f08b276f843606e310566cf))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.11
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.11
+
+## [0.14.16-beta.11](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.10...anthropic-v0.14.16-beta.11) (2026-01-06)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.10
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.10
+
+## [0.14.16-beta.10](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.9...anthropic-v0.14.16-beta.10) (2026-01-02)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.9
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.9
+
+## [0.14.16-beta.9](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.8...anthropic-v0.14.16-beta.9) (2025-12-31)
+
+
+### Features
+
+* add session compact support for AIAgent ([#863](https://github.com/AIGNE-io/aigne-framework/issues/863)) ([9010918](https://github.com/AIGNE-io/aigne-framework/commit/9010918cd3f18b02b5c60ddc9ed5c34b568d0b28))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.8
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.8
+
+## [0.14.16-beta.8](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.7...anthropic-v0.14.16-beta.8) (2025-12-26)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.7
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.7
+
+## [0.14.16-beta.7](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.6...anthropic-v0.14.16-beta.7) (2025-12-25)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.6
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.6
+
+## [0.14.16-beta.6](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.5...anthropic-v0.14.16-beta.6) (2025-12-25)
+
+
+### Bug Fixes
+
+* **models:** support cache the last message for anthropic chat model ([#853](https://github.com/AIGNE-io/aigne-framework/issues/853)) ([bd08e44](https://github.com/AIGNE-io/aigne-framework/commit/bd08e44b28c46ac9a85234f0100d6dd144703c9d))
+
+## [0.14.16-beta.5](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.4...anthropic-v0.14.16-beta.5) (2025-12-25)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.5
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.5
+
+## [0.14.16-beta.4](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.3...anthropic-v0.14.16-beta.4) (2025-12-24)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.4
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.4
+
+## [0.14.16-beta.3](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.2...anthropic-v0.14.16-beta.3) (2025-12-19)
+
+
+### Features
+
+* add prompt caching for OpenAI/Gemini/Anthropic and cache token display ([#838](https://github.com/AIGNE-io/aigne-framework/issues/838)) ([46c628f](https://github.com/AIGNE-io/aigne-framework/commit/46c628f180572ea1b955d1a9888aad6145204842))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.72.0-beta.3
+  * devDependencies
+    * @aigne/test-utils bumped to 0.5.69-beta.3
+
 ## [0.14.16-beta.2](https://github.com/AIGNE-io/aigne-framework/compare/anthropic-v0.14.16-beta.1...anthropic-v0.14.16-beta.2) (2025-12-19)
 
 

package/lib/cjs/anthropic-chat-model.d.ts

@@ -124,19 +124,22 @@ export declare class AnthropicChatModel extends ChatModel {
         reasoningEffort?: number | "minimal" | "low" | "medium" | "high" | {
             $get: string;
         } | undefined;
+        cacheConfig?: import("@aigne/core").CacheConfig | {
+            $get: string;
+        } | undefined;
     }> | undefined;
     get credential(): {
         apiKey: string | undefined;
         model: string;
     };
+    countTokens(input: ChatModelInput): Promise<number>;
+    private getMessageCreateParams;
     private getMaxTokens;
     /**
      * Process the input using Claude's chat model
      * @param input - The input to process
      * @returns The processed output from the model
      */
-    process(input: ChatModelInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
-    private _process;
-    private extractResultFromAnthropicStream;
-    private requestStructuredOutput;
+    process(input: ChatModelInput, _options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    private processInput;
 }

package/lib/cjs/anthropic-chat-model.js

@@ -6,13 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnthropicChatModel = exports.claudeChatModelOptionsSchema = void 0;
 const core_1 = require("@aigne/core");
 const json_schema_js_1 = require("@aigne/core/utils/json-schema.js");
-const logger_js_1 = require("@aigne/core/utils/logger.js");
-const model_utils_js_1 = require("@aigne/core/utils/model-utils.js");
-const stream_utils_js_1 = require("@aigne/core/utils/stream-utils.js");
 const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const zod_1 = require("zod");
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
+const OUTPUT_FUNCTION_NAME = "generate_json";
 /**
  * @hidden
  */
@@ -82,6 +80,23 @@ class AnthropicChatModel extends core_1.ChatModel {
             model: this.options?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL,
         };
     }
+    async countTokens(input) {
+        const request = await this.getMessageCreateParams(input);
+        return (await this.client.messages.countTokens((0, type_utils_js_1.omit)(request, "max_tokens"))).input_tokens;
+    }
+    async getMessageCreateParams(input) {
+        const { modelOptions = {} } = input;
+        const model = modelOptions.model || this.credential.model;
+        const disableParallelToolUse = modelOptions.parallelToolCalls === false;
+        return {
+            model,
+            temperature: modelOptions.temperature,
+            top_p: modelOptions.topP,
+            max_tokens: this.getMaxTokens(model),
+            ...(await convertMessages(input)),
+            ...convertTools({ ...input, disableParallelToolUse }),
+        };
+    }
     getMaxTokens(model) {
         const matchers = [
             [/claude-opus-4-/, 32000],
@@ -102,186 +117,131 @@ class AnthropicChatModel extends core_1.ChatModel {
      * @param input - The input to process
      * @returns The processed output from the model
      */
-    process(input, options) {
-        return this._process(input, options);
+    process(input, _options) {
+        return this.processInput(input);
     }
-    async _process(input, _options) {
-        const { modelOptions = {} } = input;
-        const model = modelOptions.model || this.credential.model;
-        const disableParallelToolUse = modelOptions.parallelToolCalls === false;
-        const body = {
-            model,
-            temperature: modelOptions.temperature,
-            top_p: modelOptions.topP,
-            // TODO: make dynamic based on model https://docs.anthropic.com/en/docs/about-claude/models/all-models
-            max_tokens: this.getMaxTokens(model),
-            ...(await convertMessages(input)),
-            ...convertTools({ ...input, disableParallelToolUse }),
-        };
-        // Claude does not support json_schema response and tool calls in the same request,
-        // so we need to handle the case where tools are not used and responseFormat is json
-        if (!input.tools?.length && input.responseFormat?.type === "json_schema") {
-            return this.requestStructuredOutput(body, input.responseFormat);
+    async *processInput(input) {
+        const body = await this.getMessageCreateParams(input);
+        const stream = this.client.messages.stream({ ...body, stream: true });
+        const blocks = [];
+        let usage;
+        let json;
+        for await (const chunk of stream) {
+            if (chunk.type === "message_start") {
+                yield { delta: { json: { model: chunk.message.model } } };
+                const { input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens, } = chunk.message.usage;
+                usage = {
+                    inputTokens: input_tokens,
+                    outputTokens: output_tokens,
+                    cacheCreationInputTokens: cache_creation_input_tokens ?? undefined,
+                    cacheReadInputTokens: cache_read_input_tokens ?? undefined,
+                };
+            }
+            if (chunk.type === "message_delta" && usage) {
+                usage.outputTokens = chunk.usage.output_tokens;
+            }
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                yield { delta: { text: { text: chunk.delta.text } } };
+            }
+            if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
+                blocks[chunk.index] = {
+                    type: "function",
+                    id: chunk.content_block.id,
+                    function: { name: chunk.content_block.name, arguments: {} },
+                    args: "",
+                };
+            }
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
+                const call = blocks[chunk.index];
+                if (!call)
+                    throw new Error("Tool call not found");
+                call.args += chunk.delta.partial_json;
+            }
         }
-        const stream = this.client.messages.stream({
-            ...body,
-            stream: true,
-        });
-        if (input.responseFormat?.type !== "json_schema") {
-            return this.extractResultFromAnthropicStream(stream, true);
+        const toolCalls = blocks.filter(type_utils_js_1.isNonNullable);
+        // Separate output tool from business tool calls
+        const outputToolCall = toolCalls.find((c) => c.function.name === OUTPUT_FUNCTION_NAME);
+        const businessToolCalls = toolCalls
+            .filter((c) => c.function.name !== OUTPUT_FUNCTION_NAME)
+            .map(({ args, ...c }) => ({
+            ...c,
+            function: {
+                ...c.function,
+                arguments: args.trim() ? (0, json_schema_js_1.parseJSON)(args) : {},
+            },
+        }))
+            .filter(type_utils_js_1.isNonNullable);
+        if (outputToolCall) {
+            json = outputToolCall.args.trim() ? (0, json_schema_js_1.parseJSON)(outputToolCall.args) : {};
         }
-        const result = await this.extractResultFromAnthropicStream(stream);
-        // Just return the result if it has tool calls
-        if (result.toolCalls?.length)
-            return result;
-        // Try to parse the text response as JSON
-        // If it matches the json_schema, return it as json
-        const json = (0, core_1.safeParseJSON)(result.text || "");
-        const validated = this.validateJsonSchema(input.responseFormat.jsonSchema.schema, json, {
-            safe: true,
-        });
-        if (validated.success) {
-            return { ...result, json: validated.data, text: undefined };
+        if (businessToolCalls.length) {
+            yield { delta: { json: { toolCalls: businessToolCalls } } };
         }
-        logger_js_1.logger.warn(`AnthropicChatModel: Text response does not match JSON schema, trying to use tool to extract json `, { text: result.text });
-        // Claude doesn't support json_schema response and tool calls in the same request,
-        // so we need to make a separate request for json_schema response when the tool calls is empty
-        const output = await this.requestStructuredOutput(body, input.responseFormat);
-        return {
-            ...output,
-            // merge usage from both requests
-            usage: (0, model_utils_js_1.mergeUsage)(result.usage, output.usage),
-        };
-    }
-    async extractResultFromAnthropicStream(stream, streaming) {
-        const result = new ReadableStream({
-            async start(controller) {
-                try {
-                    const toolCalls = [];
-                    let usage;
-                    let model;
-                    for await (const chunk of stream) {
-                        if (chunk.type === "message_start") {
-                            if (!model) {
-                                model = chunk.message.model;
-                                controller.enqueue({ delta: { json: { model } } });
-                            }
-                            const { input_tokens, output_tokens } = chunk.message.usage;
-                            usage = {
-                                inputTokens: input_tokens,
-                                outputTokens: output_tokens,
-                            };
-                        }
-                        if (chunk.type === "message_delta" && usage) {
-                            usage.outputTokens = chunk.usage.output_tokens;
-                        }
-                        // handle streaming text
-                        if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-                            controller.enqueue({
-                                delta: { text: { text: chunk.delta.text } },
-                            });
-                        }
-                        if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
-                            toolCalls[chunk.index] = {
-                                type: "function",
-                                id: chunk.content_block.id,
-                                function: {
-                                    name: chunk.content_block.name,
-                                    arguments: {},
-                                },
-                                args: "",
-                            };
-                        }
-                        if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
-                            const call = toolCalls[chunk.index];
-                            if (!call)
-                                throw new Error("Tool call not found");
-                            call.args += chunk.delta.partial_json;
-                        }
-                    }
-                    controller.enqueue({ delta: { json: { usage } } });
-                    if (toolCalls.length) {
-                        controller.enqueue({
-                            delta: {
-                                json: {
-                                    toolCalls: toolCalls
-                                        .map(({ args, ...c }) => ({
-                                        ...c,
-                                        function: {
-                                            ...c.function,
-                                            // NOTE: claude may return a blank string for empty object (the tool's input schema is a empty object)
-                                            arguments: args.trim() ? (0, json_schema_js_1.parseJSON)(args) : {},
-                                        },
-                                    }))
-                                        .filter(type_utils_js_1.isNonNullable),
-                                },
-                            },
-                        });
-                    }
-                    controller.close();
-                }
-                catch (error) {
-                    controller.error(error);
-                }
-            },
-        });
-        return streaming ? result : await (0, stream_utils_js_1.agentResponseStreamToObject)(result);
-    }
-    async requestStructuredOutput(body, responseFormat) {
-        if (responseFormat?.type !== "json_schema") {
-            throw new Error("Expected json_schema response format");
+        if (json !== undefined) {
+            yield { delta: { json: { json: json } } };
         }
-        const result = await this.client.messages.create({
-            ...body,
-            tools: [
-                {
-                    name: "generate_json",
-                    description: "Generate a json result by given context",
-                    input_schema: responseFormat.jsonSchema.schema,
-                },
-            ],
-            tool_choice: {
-                type: "tool",
-                name: "generate_json",
-                disable_parallel_tool_use: true,
-            },
-            stream: false,
-        });
-        const jsonTool = result.content.find((i) => i.type === "tool_use" && i.name === "generate_json");
-        if (!jsonTool)
-            throw new Error("Json tool not found");
-        return {
-            json: jsonTool.input,
-            model: result.model,
-            usage: {
-                inputTokens: result.usage.input_tokens,
-                outputTokens: result.usage.output_tokens,
-            },
-        };
+        yield { delta: { json: { usage } } };
     }
 }
 exports.AnthropicChatModel = AnthropicChatModel;
-async function convertMessages({ messages, responseFormat, tools }) {
-    const systemMessages = [];
+/**
+ * Parse cache configuration from model options
+ */
+function parseCacheConfig(modelOptions) {
+    const cacheConfig = modelOptions?.cacheConfig || {};
+    const shouldCache = cacheConfig.enabled !== false; // Default: enabled
+    const ttl = cacheConfig.ttl === "1h" ? "1h" : "5m"; // Default: 5m
+    const strategy = cacheConfig.strategy || "auto"; // Default: auto
+    const autoBreakpoints = {
+        tools: cacheConfig.autoBreakpoints?.tools !== false, // Default: true
+        system: cacheConfig.autoBreakpoints?.system !== false, // Default: true
+        lastMessage: cacheConfig.autoBreakpoints?.lastMessage === true, // Default: false
+    };
+    return {
+        shouldCache,
+        ttl,
+        strategy,
+        autoBreakpoints,
+    };
+}
+async function convertMessages({ messages, modelOptions }) {
+    const systemBlocks = [];
     const msgs = [];
+    // Extract cache configuration with defaults
+    const { shouldCache, strategy, autoBreakpoints, ...cacheConfig } = parseCacheConfig(modelOptions);
+    const ttl = cacheConfig.ttl === "1h" ? "1h" : undefined;
     for (const msg of messages) {
         if (msg.role === "system") {
-            if (typeof msg.content !== "string")
-                throw new Error("System message must have content");
-            systemMessages.push(msg.content);
+            if (typeof msg.content === "string") {
+                const block = {
+                    type: "text",
+                    text: msg.content,
+                };
+                systemBlocks.push(block);
+            }
+            else if (Array.isArray(msg.content)) {
+                systemBlocks.push(...msg.content.map((item) => {
+                    if (item.type !== "text")
+                        throw new Error("System message only supports text content blocks");
+                    return { type: "text", text: item.text };
+                }));
+            }
+            else {
+                throw new Error("System message must have string or array content");
+            }
         }
         else if (msg.role === "tool") {
             if (!msg.toolCallId)
                 throw new Error("Tool message must have toolCallId");
-            if (typeof msg.content !== "string")
-                throw new Error("Tool message must have string content");
+            if (!msg.content)
+                throw new Error("Tool message must have content");
             msgs.push({
                 role: "user",
                 content: [
                     {
                         type: "tool_result",
                         tool_use_id: msg.toolCallId,
-                        content: msg.content,
+                        content: await convertContent(msg.content),
                     },
                 ],
             });
@@ -311,19 +271,60 @@ async function convertMessages({ messages, responseFormat, tools }) {
             }
         }
     }
-    // If there are tools and responseFormat is json_schema, we need to add a system message
-    // to inform the model about the expected json schema, then trying to parse the response as json
-    if (tools?.length && responseFormat?.type === "json_schema") {
-        systemMessages.push(`You should provide a json response with schema: ${JSON.stringify(responseFormat.jsonSchema.schema)}`);
+    // Apply cache_control to the last system block if auto strategy is enabled
+    if (shouldCache && strategy === "auto") {
+        if (autoBreakpoints.system && systemBlocks.length > 0) {
+            const lastBlock = systemBlocks[systemBlocks.length - 1];
+            if (lastBlock) {
+                lastBlock.cache_control = { type: "ephemeral", ttl };
+            }
+        }
+        if (autoBreakpoints.lastMessage) {
+            const lastMsg = msgs[msgs.length - 1];
+            if (lastMsg) {
+                if (typeof lastMsg.content === "string") {
+                    lastMsg.content = [
+                        { type: "text", text: lastMsg.content, cache_control: { type: "ephemeral", ttl } },
+                    ];
+                }
+                else if (Array.isArray(lastMsg.content)) {
+                    const lastBlock = lastMsg.content[lastMsg.content.length - 1];
+                    if (lastBlock &&
+                        lastBlock.type !== "thinking" &&
+                        lastBlock.type !== "redacted_thinking") {
+                        lastBlock.cache_control = { type: "ephemeral", ttl };
+                    }
+                }
+            }
+        }
+    }
+    // Manual cache control: apply user-specified cacheControl from system messages
+    if (shouldCache && strategy === "manual") {
+        for (const [index, msg] of messages.entries()) {
+            const msgWithCache = msg;
+            if (msg.role === "system" && msgWithCache.cacheControl) {
+                const block = systemBlocks[index];
+                if (block) {
+                    block.cache_control = {
+                        type: msgWithCache.cacheControl.type,
+                        ...(msgWithCache.cacheControl.ttl && { ttl: msgWithCache.cacheControl.ttl }),
+                    };
+                }
+            }
+        }
     }
-    const system = systemMessages.join("\n").trim() || undefined;
     // Claude requires at least one message, so we add a system message if there are no messages
     if (msgs.length === 0) {
-        if (!system)
+        if (systemBlocks.length === 0)
             throw new Error("No messages provided");
-        return { messages: [{ role: "user", content: system }] };
+        // Convert system blocks to a single user message
+        const systemText = systemBlocks.map((b) => b.text).join("\n");
+        return { messages: [{ role: "user", content: systemText }] };
     }
-    return { messages: msgs, system };
+    return {
+        messages: msgs,
+        system: systemBlocks.length > 0 ? systemBlocks : undefined,
+    };
 }
 async function convertContent(content) {
     if (typeof content === "string")
@@ -348,38 +349,64 @@ async function convertContent(content) {
     }
     throw new Error("Invalid chat message content");
 }
-function convertTools({ tools, toolChoice, disableParallelToolUse, }) {
-    let choice;
-    if (typeof toolChoice === "object" && "type" in toolChoice && toolChoice.type === "function") {
-        choice = {
-            type: "tool",
-            name: toolChoice.function.name,
-            disable_parallel_tool_use: disableParallelToolUse,
-        };
-    }
-    else if (toolChoice === "required") {
-        choice = { type: "any", disable_parallel_tool_use: disableParallelToolUse };
-    }
-    else if (toolChoice === "auto") {
-        choice = {
-            type: "auto",
-            disable_parallel_tool_use: disableParallelToolUse,
+function convertTools({ tools, toolChoice, disableParallelToolUse, modelOptions, responseFormat, }) {
+    // Extract cache configuration with defaults
+    const { shouldCache, ttl, strategy, autoBreakpoints } = parseCacheConfig(modelOptions);
+    const shouldCacheTools = shouldCache && strategy === "auto" && autoBreakpoints.tools;
+    // Convert business tools
+    const convertedTools = (tools ?? []).map((i) => {
+        const tool = {
+            name: i.function.name,
+            description: i.function.description,
+            input_schema: (0, type_utils_js_1.isEmpty)(i.function.parameters)
+                ? { type: "object" }
+                : i.function.parameters,
         };
+        // Manual cache mode: apply tool-specific cacheControl
+        if (shouldCache && strategy === "manual" && i.cacheControl) {
+            tool.cache_control = {
+                type: i.cacheControl.type,
+                ...(i.cacheControl.ttl && { ttl: i.cacheControl.ttl }),
+            };
+        }
+        return tool;
+    });
+    // Add output tool for structured output
+    if (responseFormat?.type === "json_schema") {
+        convertedTools.push({
+            name: OUTPUT_FUNCTION_NAME,
+            description: "Generate a json result by given context",
+            input_schema: responseFormat.jsonSchema.schema,
+        });
     }
-    else if (toolChoice === "none") {
-        choice = { type: "none" };
+    // Auto cache mode: add cache_control to the last tool
+    if (shouldCacheTools && convertedTools.length) {
+        const lastTool = convertedTools[convertedTools.length - 1];
+        if (lastTool) {
+            lastTool.cache_control = { type: "ephemeral", ...(ttl === "1h" && { ttl: "1h" }) };
+        }
     }
+    // Determine tool choice
+    const choice = responseFormat?.type === "json_schema"
+        ? // For structured output: force output tool if no business tools, otherwise let model choose
+            tools?.length
+                ? { type: "any", disable_parallel_tool_use: disableParallelToolUse }
+                : { type: "tool", name: OUTPUT_FUNCTION_NAME, disable_parallel_tool_use: true }
+        : typeof toolChoice === "object" && "type" in toolChoice && toolChoice.type === "function"
+            ? {
+                type: "tool",
+                name: toolChoice.function.name,
+                disable_parallel_tool_use: disableParallelToolUse,
+            }
+            : toolChoice === "required"
+                ? { type: "any", disable_parallel_tool_use: disableParallelToolUse }
+                : toolChoice === "auto"
+                    ? { type: "auto", disable_parallel_tool_use: disableParallelToolUse }
+                    : toolChoice === "none"
+                        ? { type: "none" }
+                        : undefined;
     return {
-        tools: tools?.length
-            ? tools.map((i) => ({
-                name: i.function.name,
-                description: i.function.description,
-                input_schema: (0, type_utils_js_1.isEmpty)(i.function.parameters)
-                    ? { type: "object" }
-                    : i.function.parameters,
-            }))
-            : undefined,
+        tools: convertedTools.length ? convertedTools : undefined,
         tool_choice: choice,
     };
 }
-// safeParseJSON is now imported from @aigne/core

package/lib/dts/anthropic-chat-model.d.ts

@@ -124,19 +124,22 @@ export declare class AnthropicChatModel extends ChatModel {
         reasoningEffort?: number | "minimal" | "low" | "medium" | "high" | {
             $get: string;
         } | undefined;
+        cacheConfig?: import("@aigne/core").CacheConfig | {
+            $get: string;
+        } | undefined;
     }> | undefined;
     get credential(): {
         apiKey: string | undefined;
         model: string;
     };
+    countTokens(input: ChatModelInput): Promise<number>;
+    private getMessageCreateParams;
     private getMaxTokens;
     /**
      * Process the input using Claude's chat model
      * @param input - The input to process
      * @returns The processed output from the model
      */
-    process(input: ChatModelInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
-    private _process;
-    private extractResultFromAnthropicStream;
-    private requestStructuredOutput;
+    process(input: ChatModelInput, _options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    private processInput;
 }

package/lib/esm/anthropic-chat-model.d.ts

@@ -124,19 +124,22 @@ export declare class AnthropicChatModel extends ChatModel {
         reasoningEffort?: number | "minimal" | "low" | "medium" | "high" | {
             $get: string;
         } | undefined;
+        cacheConfig?: import("@aigne/core").CacheConfig | {
+            $get: string;
+        } | undefined;
     }> | undefined;
     get credential(): {
         apiKey: string | undefined;
         model: string;
     };
+    countTokens(input: ChatModelInput): Promise<number>;
+    private getMessageCreateParams;
     private getMaxTokens;
     /**
      * Process the input using Claude's chat model
      * @param input - The input to process
      * @returns The processed output from the model
      */
-    process(input: ChatModelInput, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
-    private _process;
-    private extractResultFromAnthropicStream;
-    private requestStructuredOutput;
+    process(input: ChatModelInput, _options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    private processInput;
 }

package/lib/esm/anthropic-chat-model.js

@@ -1,12 +1,10 @@
-import { ChatModel, safeParseJSON, } from "@aigne/core";
+import { ChatModel, } from "@aigne/core";
 import { parseJSON } from "@aigne/core/utils/json-schema.js";
-import { logger } from "@aigne/core/utils/logger.js";
-import { mergeUsage } from "@aigne/core/utils/model-utils.js";
-import { agentResponseStreamToObject } from "@aigne/core/utils/stream-utils.js";
-import { checkArguments, isEmpty, isNonNullable, } from "@aigne/core/utils/type-utils.js";
+import { checkArguments, isEmpty, isNonNullable, omit, } from "@aigne/core/utils/type-utils.js";
 import Anthropic from "@anthropic-ai/sdk";
 import { z } from "zod";
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
+const OUTPUT_FUNCTION_NAME = "generate_json";
 /**
  * @hidden
  */
@@ -76,6 +74,23 @@ export class AnthropicChatModel extends ChatModel {
             model: this.options?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL,
         };
     }
+    async countTokens(input) {
+        const request = await this.getMessageCreateParams(input);
+        return (await this.client.messages.countTokens(omit(request, "max_tokens"))).input_tokens;
+    }
+    async getMessageCreateParams(input) {
+        const { modelOptions = {} } = input;
+        const model = modelOptions.model || this.credential.model;
+        const disableParallelToolUse = modelOptions.parallelToolCalls === false;
+        return {
+            model,
+            temperature: modelOptions.temperature,
+            top_p: modelOptions.topP,
+            max_tokens: this.getMaxTokens(model),
+            ...(await convertMessages(input)),
+            ...convertTools({ ...input, disableParallelToolUse }),
+        };
+    }
     getMaxTokens(model) {
         const matchers = [
             [/claude-opus-4-/, 32000],
@@ -96,185 +111,130 @@ export class AnthropicChatModel extends ChatModel {
      * @param input - The input to process
      * @returns The processed output from the model
      */
-    process(input, options) {
-        return this._process(input, options);
+    process(input, _options) {
+        return this.processInput(input);
     }
-    async _process(input, _options) {
-        const { modelOptions = {} } = input;
-        const model = modelOptions.model || this.credential.model;
-        const disableParallelToolUse = modelOptions.parallelToolCalls === false;
-        const body = {
-            model,
-            temperature: modelOptions.temperature,
-            top_p: modelOptions.topP,
-            // TODO: make dynamic based on model https://docs.anthropic.com/en/docs/about-claude/models/all-models
-            max_tokens: this.getMaxTokens(model),
-            ...(await convertMessages(input)),
-            ...convertTools({ ...input, disableParallelToolUse }),
-        };
-        // Claude does not support json_schema response and tool calls in the same request,
-        // so we need to handle the case where tools are not used and responseFormat is json
-        if (!input.tools?.length && input.responseFormat?.type === "json_schema") {
-            return this.requestStructuredOutput(body, input.responseFormat);
+    async *processInput(input) {
+        const body = await this.getMessageCreateParams(input);
+        const stream = this.client.messages.stream({ ...body, stream: true });
+        const blocks = [];
+        let usage;
+        let json;
+        for await (const chunk of stream) {
+            if (chunk.type === "message_start") {
+                yield { delta: { json: { model: chunk.message.model } } };
+                const { input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens, } = chunk.message.usage;
+                usage = {
+                    inputTokens: input_tokens,
+                    outputTokens: output_tokens,
+                    cacheCreationInputTokens: cache_creation_input_tokens ?? undefined,
+                    cacheReadInputTokens: cache_read_input_tokens ?? undefined,
+                };
+            }
+            if (chunk.type === "message_delta" && usage) {
+                usage.outputTokens = chunk.usage.output_tokens;
+            }
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                yield { delta: { text: { text: chunk.delta.text } } };
+            }
+            if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
+                blocks[chunk.index] = {
+                    type: "function",
+                    id: chunk.content_block.id,
+                    function: { name: chunk.content_block.name, arguments: {} },
+                    args: "",
+                };
+            }
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
+                const call = blocks[chunk.index];
+                if (!call)
+                    throw new Error("Tool call not found");
+                call.args += chunk.delta.partial_json;
+            }
         }
-        const stream = this.client.messages.stream({
-            ...body,
-            stream: true,
-        });
-        if (input.responseFormat?.type !== "json_schema") {
-            return this.extractResultFromAnthropicStream(stream, true);
+        const toolCalls = blocks.filter(isNonNullable);
+        // Separate output tool from business tool calls
+        const outputToolCall = toolCalls.find((c) => c.function.name === OUTPUT_FUNCTION_NAME);
+        const businessToolCalls = toolCalls
+            .filter((c) => c.function.name !== OUTPUT_FUNCTION_NAME)
+            .map(({ args, ...c }) => ({
+            ...c,
+            function: {
+                ...c.function,
+                arguments: args.trim() ? parseJSON(args) : {},
+            },
+        }))
+            .filter(isNonNullable);
+        if (outputToolCall) {
+            json = outputToolCall.args.trim() ? parseJSON(outputToolCall.args) : {};
         }
-        const result = await this.extractResultFromAnthropicStream(stream);
-        // Just return the result if it has tool calls
-        if (result.toolCalls?.length)
-            return result;
-        // Try to parse the text response as JSON
-        // If it matches the json_schema, return it as json
-        const json = safeParseJSON(result.text || "");
-        const validated = this.validateJsonSchema(input.responseFormat.jsonSchema.schema, json, {
-            safe: true,
-        });
-        if (validated.success) {
-            return { ...result, json: validated.data, text: undefined };
+        if (businessToolCalls.length) {
+            yield { delta: { json: { toolCalls: businessToolCalls } } };
         }
-        logger.warn(`AnthropicChatModel: Text response does not match JSON schema, trying to use tool to extract json `, { text: result.text });
-        // Claude doesn't support json_schema response and tool calls in the same request,
-        // so we need to make a separate request for json_schema response when the tool calls is empty
-        const output = await this.requestStructuredOutput(body, input.responseFormat);
-        return {
-            ...output,
-            // merge usage from both requests
-            usage: mergeUsage(result.usage, output.usage),
-        };
-    }
-    async extractResultFromAnthropicStream(stream, streaming) {
-        const result = new ReadableStream({
-            async start(controller) {
-                try {
-                    const toolCalls = [];
-                    let usage;
-                    let model;
-                    for await (const chunk of stream) {
-                        if (chunk.type === "message_start") {
-                            if (!model) {
-                                model = chunk.message.model;
-                                controller.enqueue({ delta: { json: { model } } });
-                            }
-                            const { input_tokens, output_tokens } = chunk.message.usage;
-                            usage = {
-                                inputTokens: input_tokens,
-                                outputTokens: output_tokens,
-                            };
-                        }
-                        if (chunk.type === "message_delta" && usage) {
-                            usage.outputTokens = chunk.usage.output_tokens;
-                        }
-                        // handle streaming text
-                        if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-                            controller.enqueue({
-                                delta: { text: { text: chunk.delta.text } },
-                            });
-                        }
-                        if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
-                            toolCalls[chunk.index] = {
-                                type: "function",
-                                id: chunk.content_block.id,
-                                function: {
-                                    name: chunk.content_block.name,
-                                    arguments: {},
-                                },
-                                args: "",
-                            };
-                        }
-                        if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
-                            const call = toolCalls[chunk.index];
-                            if (!call)
-                                throw new Error("Tool call not found");
-                            call.args += chunk.delta.partial_json;
-                        }
-                    }
-                    controller.enqueue({ delta: { json: { usage } } });
-                    if (toolCalls.length) {
-                        controller.enqueue({
-                            delta: {
-                                json: {
-                                    toolCalls: toolCalls
-                                        .map(({ args, ...c }) => ({
-                                        ...c,
-                                        function: {
-                                            ...c.function,
-                                            // NOTE: claude may return a blank string for empty object (the tool's input schema is a empty object)
-                                            arguments: args.trim() ? parseJSON(args) : {},
-                                        },
-                                    }))
-                                        .filter(isNonNullable),
-                                },
-                            },
-                        });
-                    }
-                    controller.close();
-                }
-                catch (error) {
-                    controller.error(error);
-                }
-            },
-        });
-        return streaming ? result : await agentResponseStreamToObject(result);
-    }
-    async requestStructuredOutput(body, responseFormat) {
-        if (responseFormat?.type !== "json_schema") {
-            throw new Error("Expected json_schema response format");
+        if (json !== undefined) {
+            yield { delta: { json: { json: json } } };
         }
-        const result = await this.client.messages.create({
-            ...body,
-            tools: [
-                {
-                    name: "generate_json",
-                    description: "Generate a json result by given context",
-                    input_schema: responseFormat.jsonSchema.schema,
-                },
-            ],
-            tool_choice: {
-                type: "tool",
-                name: "generate_json",
-                disable_parallel_tool_use: true,
-            },
-            stream: false,
-        });
-        const jsonTool = result.content.find((i) => i.type === "tool_use" && i.name === "generate_json");
-        if (!jsonTool)
-            throw new Error("Json tool not found");
-        return {
-            json: jsonTool.input,
-            model: result.model,
-            usage: {
-                inputTokens: result.usage.input_tokens,
-                outputTokens: result.usage.output_tokens,
-            },
-        };
+        yield { delta: { json: { usage } } };
     }
 }
-async function convertMessages({ messages, responseFormat, tools }) {
-    const systemMessages = [];
+/**
+ * Parse cache configuration from model options
+ */
+function parseCacheConfig(modelOptions) {
+    const cacheConfig = modelOptions?.cacheConfig || {};
+    const shouldCache = cacheConfig.enabled !== false; // Default: enabled
+    const ttl = cacheConfig.ttl === "1h" ? "1h" : "5m"; // Default: 5m
+    const strategy = cacheConfig.strategy || "auto"; // Default: auto
+    const autoBreakpoints = {
+        tools: cacheConfig.autoBreakpoints?.tools !== false, // Default: true
+        system: cacheConfig.autoBreakpoints?.system !== false, // Default: true
+        lastMessage: cacheConfig.autoBreakpoints?.lastMessage === true, // Default: false
+    };
+    return {
+        shouldCache,
+        ttl,
+        strategy,
+        autoBreakpoints,
+    };
+}
+async function convertMessages({ messages, modelOptions }) {
+    const systemBlocks = [];
     const msgs = [];
+    // Extract cache configuration with defaults
+    const { shouldCache, strategy, autoBreakpoints, ...cacheConfig } = parseCacheConfig(modelOptions);
+    const ttl = cacheConfig.ttl === "1h" ? "1h" : undefined;
     for (const msg of messages) {
         if (msg.role === "system") {
-            if (typeof msg.content !== "string")
-                throw new Error("System message must have content");
-            systemMessages.push(msg.content);
+            if (typeof msg.content === "string") {
+                const block = {
+                    type: "text",
+                    text: msg.content,
+                };
+                systemBlocks.push(block);
+            }
+            else if (Array.isArray(msg.content)) {
+                systemBlocks.push(...msg.content.map((item) => {
+                    if (item.type !== "text")
+                        throw new Error("System message only supports text content blocks");
+                    return { type: "text", text: item.text };
+                }));
+            }
+            else {
+                throw new Error("System message must have string or array content");
+            }
         }
         else if (msg.role === "tool") {
             if (!msg.toolCallId)
                 throw new Error("Tool message must have toolCallId");
-            if (typeof msg.content !== "string")
-                throw new Error("Tool message must have string content");
+            if (!msg.content)
+                throw new Error("Tool message must have content");
             msgs.push({
                 role: "user",
                 content: [
                     {
                         type: "tool_result",
                         tool_use_id: msg.toolCallId,
-                        content: msg.content,
+                        content: await convertContent(msg.content),
                     },
                 ],
             });
@@ -304,19 +264,60 @@ async function convertMessages({ messages, responseFormat, tools }) {
             }
         }
     }
-    // If there are tools and responseFormat is json_schema, we need to add a system message
-    // to inform the model about the expected json schema, then trying to parse the response as json
-    if (tools?.length && responseFormat?.type === "json_schema") {
-        systemMessages.push(`You should provide a json response with schema: ${JSON.stringify(responseFormat.jsonSchema.schema)}`);
+    // Apply cache_control to the last system block if auto strategy is enabled
+    if (shouldCache && strategy === "auto") {
+        if (autoBreakpoints.system && systemBlocks.length > 0) {
+            const lastBlock = systemBlocks[systemBlocks.length - 1];
+            if (lastBlock) {
+                lastBlock.cache_control = { type: "ephemeral", ttl };
+            }
+        }
+        if (autoBreakpoints.lastMessage) {
+            const lastMsg = msgs[msgs.length - 1];
+            if (lastMsg) {
+                if (typeof lastMsg.content === "string") {
+                    lastMsg.content = [
+                        { type: "text", text: lastMsg.content, cache_control: { type: "ephemeral", ttl } },
+                    ];
+                }
+                else if (Array.isArray(lastMsg.content)) {
+                    const lastBlock = lastMsg.content[lastMsg.content.length - 1];
+                    if (lastBlock &&
+                        lastBlock.type !== "thinking" &&
+                        lastBlock.type !== "redacted_thinking") {
+                        lastBlock.cache_control = { type: "ephemeral", ttl };
+                    }
+                }
+            }
+        }
+    }
+    // Manual cache control: apply user-specified cacheControl from system messages
+    if (shouldCache && strategy === "manual") {
+        for (const [index, msg] of messages.entries()) {
+            const msgWithCache = msg;
+            if (msg.role === "system" && msgWithCache.cacheControl) {
+                const block = systemBlocks[index];
+                if (block) {
+                    block.cache_control = {
+                        type: msgWithCache.cacheControl.type,
+                        ...(msgWithCache.cacheControl.ttl && { ttl: msgWithCache.cacheControl.ttl }),
+                    };
+                }
+            }
+        }
     }
-    const system = systemMessages.join("\n").trim() || undefined;
     // Claude requires at least one message, so we add a system message if there are no messages
     if (msgs.length === 0) {
-        if (!system)
+        if (systemBlocks.length === 0)
             throw new Error("No messages provided");
-        return { messages: [{ role: "user", content: system }] };
+        // Convert system blocks to a single user message
+        const systemText = systemBlocks.map((b) => b.text).join("\n");
+        return { messages: [{ role: "user", content: systemText }] };
     }
-    return { messages: msgs, system };
+    return {
+        messages: msgs,
+        system: systemBlocks.length > 0 ? systemBlocks : undefined,
+    };
 }
 async function convertContent(content) {
     if (typeof content === "string")
@@ -341,38 +342,64 @@ async function convertContent(content) {
     }
     throw new Error("Invalid chat message content");
 }
-function convertTools({ tools, toolChoice, disableParallelToolUse, }) {
-    let choice;
-    if (typeof toolChoice === "object" && "type" in toolChoice && toolChoice.type === "function") {
-        choice = {
-            type: "tool",
-            name: toolChoice.function.name,
-            disable_parallel_tool_use: disableParallelToolUse,
-        };
-    }
-    else if (toolChoice === "required") {
-        choice = { type: "any", disable_parallel_tool_use: disableParallelToolUse };
-    }
-    else if (toolChoice === "auto") {
-        choice = {
-            type: "auto",
-            disable_parallel_tool_use: disableParallelToolUse,
+function convertTools({ tools, toolChoice, disableParallelToolUse, modelOptions, responseFormat, }) {
+    // Extract cache configuration with defaults
+    const { shouldCache, ttl, strategy, autoBreakpoints } = parseCacheConfig(modelOptions);
+    const shouldCacheTools = shouldCache && strategy === "auto" && autoBreakpoints.tools;
+    // Convert business tools
+    const convertedTools = (tools ?? []).map((i) => {
+        const tool = {
+            name: i.function.name,
+            description: i.function.description,
+            input_schema: isEmpty(i.function.parameters)
+                ? { type: "object" }
+                : i.function.parameters,
         };
+        // Manual cache mode: apply tool-specific cacheControl
+        if (shouldCache && strategy === "manual" && i.cacheControl) {
+            tool.cache_control = {
+                type: i.cacheControl.type,
+                ...(i.cacheControl.ttl && { ttl: i.cacheControl.ttl }),
+            };
+        }
+        return tool;
+    });
+    // Add output tool for structured output
+    if (responseFormat?.type === "json_schema") {
+        convertedTools.push({
+            name: OUTPUT_FUNCTION_NAME,
+            description: "Generate a json result by given context",
+            input_schema: responseFormat.jsonSchema.schema,
+        });
     }
-    else if (toolChoice === "none") {
-        choice = { type: "none" };
+    // Auto cache mode: add cache_control to the last tool
+    if (shouldCacheTools && convertedTools.length) {
+        const lastTool = convertedTools[convertedTools.length - 1];
+        if (lastTool) {
+            lastTool.cache_control = { type: "ephemeral", ...(ttl === "1h" && { ttl: "1h" }) };
+        }
     }
+    // Determine tool choice
+    const choice = responseFormat?.type === "json_schema"
+        ? // For structured output: force output tool if no business tools, otherwise let model choose
+            tools?.length
+                ? { type: "any", disable_parallel_tool_use: disableParallelToolUse }
+                : { type: "tool", name: OUTPUT_FUNCTION_NAME, disable_parallel_tool_use: true }
+        : typeof toolChoice === "object" && "type" in toolChoice && toolChoice.type === "function"
+            ? {
+                type: "tool",
+                name: toolChoice.function.name,
+                disable_parallel_tool_use: disableParallelToolUse,
+            }
+            : toolChoice === "required"
+                ? { type: "any", disable_parallel_tool_use: disableParallelToolUse }
+                : toolChoice === "auto"
+                    ? { type: "auto", disable_parallel_tool_use: disableParallelToolUse }
+                    : toolChoice === "none"
+                        ? { type: "none" }
+                        : undefined;
     return {
-        tools: tools?.length
-            ? tools.map((i) => ({
-                name: i.function.name,
-                description: i.function.description,
-                input_schema: isEmpty(i.function.parameters)
-                    ? { type: "object" }
-                    : i.function.parameters,
-            }))
-            : undefined,
+        tools: convertedTools.length ? convertedTools : undefined,
         tool_choice: choice,
     };
 }
-// safeParseJSON is now imported from @aigne/core

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/anthropic",
-  "version": "0.14.16-beta.2",
+  "version": "0.14.16-beta.20",
   "description": "AIGNE Anthropic SDK for integrating with Claude AI models",
   "publishConfig": {
     "access": "public"
@@ -37,8 +37,8 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.63.0",
     "zod": "^3.25.67",
-    "@aigne/core": "^1.72.0-beta.2",
-    "@aigne/platform-helpers": "^0.6.7-beta"
+    "@aigne/core": "^1.72.0-beta.18",
+    "@aigne/platform-helpers": "^0.6.7-beta.1"
   },
   "devDependencies": {
     "@types/bun": "^1.2.22",
@@ -46,7 +46,7 @@
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "typescript": "^5.9.2",
-    "@aigne/test-utils": "^0.5.69-beta.2"
+    "@aigne/test-utils": "^0.5.69-beta.18"
   },
   "scripts": {
     "lint": "tsc --noEmit",