@aigne/anthropic 0.14.17-beta → 1.74.0-beta

package/README.md

@@ -2,28 +2,28 @@
 
 <p align="center">
   <picture>
-    <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/logo-dark.svg" media="(prefers-color-scheme: dark)">
-    <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/logo.svg" media="(prefers-color-scheme: light)">
-    <img src="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/logo.svg" alt="AIGNE Logo" width="400" />
+    <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/logo-dark.svg" media="(prefers-color-scheme: dark)">
+    <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/logo.svg" media="(prefers-color-scheme: light)">
+    <img src="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/logo.svg" alt="AIGNE Logo" width="400" />
   </picture>
 </p>
 
-[![GitHub star chart](https://img.shields.io/github/stars/AIGNE-io/aigne-framework?style=flat-square)](https://star-history.com/#AIGNE-io/aigne-framework)
-[![Open Issues](https://img.shields.io/github/issues-raw/AIGNE-io/aigne-framework?style=flat-square)](https://github.com/AIGNE-io/aigne-framework/issues)
-[![codecov](https://codecov.io/gh/AIGNE-io/aigne-framework/graph/badge.svg?token=DO07834RQL)](https://codecov.io/gh/AIGNE-io/aigne-framework)
+[![GitHub star chart](https://img.shields.io/github/stars/ArcBlock/aigne-framework?style=flat-square)](https://star-history.com/#ArcBlock/aigne-framework)
+[![Open Issues](https://img.shields.io/github/issues-raw/ArcBlock/aigne-framework?style=flat-square)](https://github.com/ArcBlock/aigne-framework/issues)
+[![codecov](https://codecov.io/gh/ArcBlock/aigne-framework/graph/badge.svg?token=DO07834RQL)](https://codecov.io/gh/ArcBlock/aigne-framework)
 [![NPM Version](https://img.shields.io/npm/v/@aigne/anthropic)](https://www.npmjs.com/package/@aigne/anthropic)
-[![Elastic-2.0 licensed](https://img.shields.io/npm/l/@aigne/anthropic)](https://github.com/AIGNE-io/aigne-framework/blob/main/LICENSE.md)
+[![Elastic-2.0 licensed](https://img.shields.io/npm/l/@aigne/anthropic)](https://github.com/ArcBlock/aigne-framework/blob/main/LICENSE.md)
 
-AIGNE Anthropic SDK for integrating with Claude AI models within the [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework).
+AIGNE Anthropic SDK for integrating with Claude AI models within the [AIGNE Framework](https://github.com/ArcBlock/aigne-framework).
 
 ## Introduction
 
 `@aigne/anthropic` provides a seamless integration between the AIGNE Framework and Anthropic's Claude language models and API. This package enables developers to easily leverage Anthropic's Claude models in their AIGNE applications, providing a consistent interface across the framework while taking advantage of Claude's advanced AI capabilities.
 
 <picture>
-  <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/assets/aigne-anthropic-dark.png" media="(prefers-color-scheme: dark)">
-  <source srcset="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/assets/aigne-anthropic.png" media="(prefers-color-scheme: light)">
-  <img src="https://raw.githubusercontent.com/AIGNE-io/aigne-framework/main/aigne-anthropic.png" alt="AIGNE Arch" />
+  <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/assets/aigne-anthropic-dark.png" media="(prefers-color-scheme: dark)">
+  <source srcset="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/assets/aigne-anthropic.png" media="(prefers-color-scheme: light)">
+  <img src="https://raw.githubusercontent.com/ArcBlock/aigne-framework/main/aigne-anthropic.png" alt="AIGNE Arch" />
 </picture>
 
 ## Features

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/anthropic-chat-model.cjs

@@ -0,0 +1,364 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _aigne_core = require("@aigne/core");
+let _aigne_core_utils_json_schema = require("@aigne/core/utils/json-schema");
+let _aigne_core_utils_type_utils = require("@aigne/core/utils/type-utils");
+let _anthropic_ai_sdk = require("@anthropic-ai/sdk");
+_anthropic_ai_sdk = require_rolldown_runtime.__toESM(_anthropic_ai_sdk);
+let zod = require("zod");
+
+//#region src/anthropic-chat-model.ts
+const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
+const OUTPUT_FUNCTION_NAME = "generate_json";
+/**
+* @hidden
+*/
+const claudeChatModelOptionsSchema = zod.z.object({
+	apiKey: zod.z.string().optional(),
+	model: zod.z.string().optional(),
+	modelOptions: zod.z.object({
+		model: zod.z.string().optional(),
+		temperature: zod.z.number().optional(),
+		topP: zod.z.number().optional(),
+		frequencyPenalty: zod.z.number().optional(),
+		presencePenalty: zod.z.number().optional(),
+		parallelToolCalls: zod.z.boolean().optional().default(true)
+	}).optional()
+});
+/**
+* Implementation of the ChatModel interface for Anthropic's Claude API
+*
+* This model provides access to Claude's capabilities including:
+* - Text generation
+* - Tool use
+* - JSON structured output
+*
+* Default model: 'claude-3-7-sonnet-latest'
+*
+* @example
+* Here's how to create and use a Claude chat model:
+* {@includeCode ../test/anthropic-chat-model.test.ts#example-anthropic-chat-model}
+*
+* @example
+* Here's an example with streaming response:
+* {@includeCode ../test/anthropic-chat-model.test.ts#example-anthropic-chat-model-streaming-async-generator}
+*/
+var AnthropicChatModel = class extends _aigne_core.ChatModel {
+	constructor(options) {
+		if (options) (0, _aigne_core_utils_type_utils.checkArguments)("AnthropicChatModel", claudeChatModelOptionsSchema, options);
+		super();
+		this.options = options;
+	}
+	apiKeyEnvName = "ANTHROPIC_API_KEY";
+	/**
+	* @hidden
+	*/
+	_client;
+	get client() {
+		const { apiKey } = this.credential;
+		if (!apiKey) throw new Error("AnthropicChatModel requires an API key. Please provide it via `options.apiKey`, or set the `ANTHROPIC_API_KEY` or `CLAUDE_API_KEY` environment variable");
+		this._client ??= new _anthropic_ai_sdk.default({
+			apiKey,
+			...this.options?.clientOptions,
+			timeout: this.options?.clientOptions?.timeout ?? 6e5
+		});
+		return this._client;
+	}
+	get modelOptions() {
+		return this.options?.modelOptions;
+	}
+	get credential() {
+		return {
+			apiKey: this.options?.apiKey || process.env[this.apiKeyEnvName] || process.env.CLAUDE_API_KEY,
+			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, _aigne_core_utils_type_utils.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) {
+		for (const [regex, maxTokens] of [
+			[/claude-opus-4-/, 32e3],
+			[/claude-sonnet-4-/, 64e3],
+			[/claude-3-7-sonnet-/, 64e3],
+			[/claude-3-5-sonnet-/, 8192],
+			[/claude-3-5-haiku-/, 8192]
+		]) if (regex.test(model)) return maxTokens;
+		return 4096;
+	}
+	/**
+	* Process the input using Claude's chat model
+	* @param input - The input to process
+	* @returns The processed output from the model
+	*/
+	process(input, _options) {
+		return this.processInput(input);
+	}
+	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 ?? void 0,
+					cacheReadInputTokens: cache_read_input_tokens ?? void 0
+				};
+			}
+			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 toolCalls = blocks.filter(_aigne_core_utils_type_utils.isNonNullable);
+		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, _aigne_core_utils_json_schema.parseJSON)(args) : {}
+			}
+		})).filter(_aigne_core_utils_type_utils.isNonNullable);
+		if (outputToolCall) json = outputToolCall.args.trim() ? (0, _aigne_core_utils_json_schema.parseJSON)(outputToolCall.args) : {};
+		if (businessToolCalls.length) yield { delta: { json: { toolCalls: businessToolCalls } } };
+		if (json !== void 0) yield { delta: { json: { json } } };
+		yield { delta: { json: { usage } } };
+	}
+};
+/**
+* Parse cache configuration from model options
+*/
+function parseCacheConfig(modelOptions) {
+	const cacheConfig = modelOptions?.cacheConfig || {};
+	return {
+		shouldCache: cacheConfig.enabled !== false,
+		ttl: cacheConfig.ttl === "1h" ? "1h" : "5m",
+		strategy: cacheConfig.strategy || "auto",
+		autoBreakpoints: {
+			tools: cacheConfig.autoBreakpoints?.tools !== false,
+			system: cacheConfig.autoBreakpoints?.system !== false,
+			lastMessage: cacheConfig.autoBreakpoints?.lastMessage === true
+		}
+	};
+}
+async function convertMessages({ messages, modelOptions }) {
+	const systemBlocks = [];
+	const msgs = [];
+	const { shouldCache, strategy, autoBreakpoints, ...cacheConfig } = parseCacheConfig(modelOptions);
+	const ttl = cacheConfig.ttl === "1h" ? "1h" : void 0;
+	for (const msg of messages) if (msg.role === "system") 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 (!msg.content) throw new Error("Tool message must have content");
+		msgs.push({
+			role: "user",
+			content: [{
+				type: "tool_result",
+				tool_use_id: msg.toolCallId,
+				content: await convertContent(msg.content)
+			}]
+		});
+	} else if (msg.role === "user") {
+		if (!msg.content) throw new Error("User message must have content");
+		msgs.push({
+			role: "user",
+			content: await convertContent(msg.content)
+		});
+	} else if (msg.role === "agent") if (msg.toolCalls?.length) msgs.push({
+		role: "assistant",
+		content: msg.toolCalls.map((i) => ({
+			type: "tool_use",
+			id: i.id,
+			name: i.function.name,
+			input: i.function.arguments
+		}))
+	});
+	else if (msg.content) msgs.push({
+		role: "assistant",
+		content: await convertContent(msg.content)
+	});
+	else throw new Error("Agent message must have content or toolCalls");
+	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
+					};
+				}
+			}
+		}
+	}
+	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 }
+			};
+		}
+	}
+	if (msgs.length === 0) {
+		if (systemBlocks.length === 0) throw new Error("No messages provided");
+		return { messages: [{
+			role: "user",
+			content: systemBlocks.map((b) => b.text).join("\n")
+		}] };
+	}
+	return {
+		messages: msgs,
+		system: systemBlocks.length > 0 ? systemBlocks : void 0
+	};
+}
+async function convertContent(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return Promise.all(content.map(async (item) => {
+		if (item.type === "text") return {
+			type: "text",
+			text: item.text
+		};
+		const media_type = await _aigne_core.ChatModel.getMimeType(item.mimeType || item.filename || "");
+		switch (item.type) {
+			case "url": return {
+				type: "image",
+				source: {
+					type: "url",
+					url: item.url
+				}
+			};
+			case "file": return {
+				type: "image",
+				source: {
+					type: "base64",
+					data: item.data,
+					media_type
+				}
+			};
+			case "local": throw new Error(`Unsupported local file: ${item.path}, it should be converted to base64 at ChatModel`);
+		}
+	}));
+	throw new Error("Invalid chat message content");
+}
+function convertTools({ tools, toolChoice, disableParallelToolUse, modelOptions, responseFormat }) {
+	const { shouldCache, ttl, strategy, autoBreakpoints } = parseCacheConfig(modelOptions);
+	const shouldCacheTools = shouldCache && strategy === "auto" && autoBreakpoints.tools;
+	const convertedTools = (tools ?? []).map((i) => {
+		const tool = {
+			name: i.function.name,
+			description: i.function.description,
+			input_schema: (0, _aigne_core_utils_type_utils.isEmpty)(i.function.parameters) ? { type: "object" } : i.function.parameters
+		};
+		if (shouldCache && strategy === "manual" && i.cacheControl) tool.cache_control = {
+			type: i.cacheControl.type,
+			...i.cacheControl.ttl && { ttl: i.cacheControl.ttl }
+		};
+		return tool;
+	});
+	if (responseFormat?.type === "json_schema") convertedTools.push({
+		name: OUTPUT_FUNCTION_NAME,
+		description: "Generate a json result by given context",
+		input_schema: responseFormat.jsonSchema.schema
+	});
+	if (shouldCacheTools && convertedTools.length) {
+		const lastTool = convertedTools[convertedTools.length - 1];
+		if (lastTool) lastTool.cache_control = {
+			type: "ephemeral",
+			...ttl === "1h" && { ttl: "1h" }
+		};
+	}
+	const choice = responseFormat?.type === "json_schema" ? 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" } : void 0;
+	return {
+		tools: convertedTools.length ? convertedTools : void 0,
+		tool_choice: choice
+	};
+}
+
+//#endregion
+exports.AnthropicChatModel = AnthropicChatModel;
+exports.claudeChatModelOptionsSchema = claudeChatModelOptionsSchema;

package/dist/anthropic-chat-model.d.cts

@@ -0,0 +1,151 @@
+import * as _aigne_core0 from "@aigne/core";
+import { AgentInvokeOptions, AgentProcessResult, ChatModel, ChatModelInput, ChatModelOptions, ChatModelOutput } from "@aigne/core";
+import { PromiseOrValue } from "@aigne/core/utils/type-utils";
+import Anthropic, { ClientOptions } from "@anthropic-ai/sdk";
+import { z } from "zod";
+
+//#region src/anthropic-chat-model.d.ts
+/**
+ * Configuration options for Claude Chat Model
+ */
+interface AnthropicChatModelOptions extends ChatModelOptions {
+  /**
+       * API key for Anthropic's Claude API
+       *
+       * If not provided, will look for ANTHROPIC_API_KEY or CLAUDE_API_KEY in environment variables
+       */
+  apiKey?: string;
+  /**
+       * Optional client options for the Anthropic SDK
+       */
+  clientOptions?: Partial<ClientOptions>;
+}
+/**
+ * @hidden
+ */
+declare const claudeChatModelOptionsSchema: z.ZodObject<{
+  apiKey: z.ZodOptional<z.ZodString>;
+  model: z.ZodOptional<z.ZodString>;
+  modelOptions: z.ZodOptional<z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+    presencePenalty: z.ZodOptional<z.ZodNumber>;
+    parallelToolCalls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  }, "strip", z.ZodTypeAny, {
+    parallelToolCalls: boolean;
+    model?: string | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+  }, {
+    model?: string | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+    parallelToolCalls?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  apiKey?: string | undefined;
+  model?: string | undefined;
+  modelOptions?: {
+    parallelToolCalls: boolean;
+    model?: string | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+  } | undefined;
+}, {
+  apiKey?: string | undefined;
+  model?: string | undefined;
+  modelOptions?: {
+    model?: string | undefined;
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+    parallelToolCalls?: boolean | undefined;
+  } | undefined;
+}>;
+/**
+ * Implementation of the ChatModel interface for Anthropic's Claude API
+ *
+ * This model provides access to Claude's capabilities including:
+ * - Text generation
+ * - Tool use
+ * - JSON structured output
+ *
+ * Default model: 'claude-3-7-sonnet-latest'
+ *
+ * @example
+ * Here's how to create and use a Claude chat model:
+ * {@includeCode ../test/anthropic-chat-model.test.ts#example-anthropic-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../test/anthropic-chat-model.test.ts#example-anthropic-chat-model-streaming-async-generator}
+ */
+declare class AnthropicChatModel extends ChatModel {
+  options?: AnthropicChatModelOptions | undefined;
+  constructor(options?: AnthropicChatModelOptions | undefined);
+  protected apiKeyEnvName: string;
+  /**
+       * @hidden
+       */
+  protected _client?: Anthropic;
+  get client(): Anthropic;
+  get modelOptions(): Partial<{
+    [x: string]: unknown;
+    model?: string | {
+      $get: string;
+    } | undefined;
+    temperature?: number | {
+      $get: string;
+    } | undefined;
+    topP?: number | {
+      $get: string;
+    } | undefined;
+    frequencyPenalty?: number | {
+      $get: string;
+    } | undefined;
+    presencePenalty?: number | {
+      $get: string;
+    } | undefined;
+    parallelToolCalls?: boolean | {
+      $get: string;
+    } | undefined;
+    modalities?: {
+      $get: string;
+    } | _aigne_core0.Modality[] | undefined;
+    preferInputFileType?: {
+      $get: string;
+    } | "file" | "url" | undefined;
+    reasoningEffort?: number | {
+      $get: string;
+    } | "minimal" | "low" | "medium" | "high" | undefined;
+    cacheConfig?: {
+      $get: string;
+    } | _aigne_core0.CacheConfig | 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 processInput;
+}
+//#endregion
+export { AnthropicChatModel, AnthropicChatModelOptions, claudeChatModelOptionsSchema };
+//# sourceMappingURL=anthropic-chat-model.d.cts.map

package/dist/anthropic-chat-model.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-chat-model.d.cts","names":[],"sources":["../src/anthropic-chat-model.ts"],"mappings":";;;;;;;;AAwCA;;UAAiB,yBAAA,SAAkC,gBAAA;EAAA;;AAiBnD;;;EAjBmD,MAAA;EAAA;;AAiBnD;EAjBmD,aAAA,GAWjC,OAAA,CAAQ,aAAA;AAAA;AAAA;;;AAAA,cAMb,4BAAA,EAA4B,CAAA,CAAA,SAAA;EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCzC;;;;;;;;;;;;;;;cAAa,kBAAA,SAA2B,SAAA;EAAA,OAAA,GACA,yBAAA;EAAA,YAAA,OAAA,GAAA,yBAAA;EAAA,UAAA,aAAA;EAAA;;;EAAA,UAAA,OAAA,GAUlB,SAAA;EAAA,IAAA,OAAA,GAEV,SAAA;EAAA,IAAA,aAAA,GAeM,OAAA;IAAA,CAAA,CAAA;IAAA,KAAA;MAAA,IAAA;IAAA;IAAA,WAAA;MAAA,IAAA;IAAA;IAAA,IAAA;MAAA,IAAA;IAAA;IAAA,gBAAA;MAAA,IAAA;IAAA;IAAA,eAAA;MAAA,IAAA;IAAA;IAAA,iBAAA;MAAA,IAAA;IAAA;IAAA,UAAA;MAAA,IAAA;IAAA,IAfN,YAAA,CAAA,QAAA;IAAA,mBAAA;MAAA,IAAA;IAAA;IAAA,eAAA;MAAA,IAAA;IAAA;IAAA,WAAA;MAAA,IAAA;IAAA;;;;;;qBA6BwB,cAAA,GAAiB,OAAA;EAAA,QAAA,sBAAA;EAAA,QAAA,YAAA;EAAA;;;;;EAAA,QAAA,KAAA,EA8C1C,cAAA,EAAA,QAAA,EACG,kBAAA,GACT,cAAA,CAAe,kBAAA,CAAmB,eAAA;EAAA,QAAA,YAAA;AAAA"}