@aigne/anthropic 0.1.0

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

@@ -0,0 +1,317 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 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";
+/**
+ * @hidden
+ */
+exports.claudeChatModelOptionsSchema = zod_1.z.object({
+    apiKey: zod_1.z.string().optional(),
+    model: zod_1.z.string().optional(),
+    modelOptions: zod_1.z
+        .object({
+        model: zod_1.z.string().optional(),
+        temperature: zod_1.z.number().optional(),
+        topP: zod_1.z.number().optional(),
+        frequencyPenalty: zod_1.z.number().optional(),
+        presencePenalty: zod_1.z.number().optional(),
+        parallelToolCalls: zod_1.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}
+ */
+class AnthropicChatModel extends core_1.ChatModel {
+    options;
+    constructor(options) {
+        if (options)
+            (0, type_utils_js_1.checkArguments)("AnthropicChatModel", exports.claudeChatModelOptionsSchema, options);
+        super();
+        this.options = options;
+    }
+    /**
+     * @hidden
+     */
+    _client;
+    get client() {
+        const apiKey = this.options?.apiKey || process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_API_KEY;
+        if (!apiKey)
+            throw new Error("Api Key is required for AnthropicChatModel");
+        this._client ??= new sdk_1.default({ apiKey });
+        return this._client;
+    }
+    get modelOptions() {
+        return this.options?.modelOptions;
+    }
+    /**
+     * Process the input using Claude's chat model
+     * @param input - The input to process
+     * @returns The processed output from the model
+     */
+    process(input) {
+        return this._process(input);
+    }
+    async _process(input) {
+        const model = this.options?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL;
+        const disableParallelToolUse = input.modelOptions?.parallelToolCalls === false ||
+            this.modelOptions?.parallelToolCalls === false;
+        const body = {
+            model,
+            temperature: input.modelOptions?.temperature ?? this.modelOptions?.temperature,
+            top_p: input.modelOptions?.topP ?? this.modelOptions?.topP,
+            // TODO: make dynamic based on model https://docs.anthropic.com/en/docs/about-claude/models/all-models
+            max_tokens: /claude-3-[5|7]/.test(model) ? 8192 : 4096,
+            ...convertMessages(input),
+            ...convertTools({ ...input, disableParallelToolUse }),
+        };
+        const stream = this.client.messages.stream({
+            ...body,
+            stream: true,
+        });
+        if (input.responseFormat?.type !== "json_schema") {
+            return this.extractResultFromAnthropicStream(stream, true);
+        }
+        const result = await this.extractResultFromAnthropicStream(stream);
+        // 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
+        if (!result.toolCalls?.length && input.responseFormat?.type === "json_schema") {
+            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),
+            };
+        }
+        return result;
+    }
+    async extractResultFromAnthropicStream(stream, streaming) {
+        const logs = [];
+        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;
+                        }
+                        logs.push(JSON.stringify(chunk));
+                        // 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");
+        }
+        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,
+            },
+        };
+    }
+}
+exports.AnthropicChatModel = AnthropicChatModel;
+function convertMessages({ messages, responseFormat }) {
+    const systemMessages = [];
+    const msgs = [];
+    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);
+        }
+        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");
+            msgs.push({
+                role: "user",
+                content: [{ type: "tool_result", tool_use_id: msg.toolCallId, content: msg.content }],
+            });
+        }
+        else if (msg.role === "user") {
+            if (!msg.content)
+                throw new Error("User message must have content");
+            msgs.push({ role: "user", content: 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: convertContent(msg.content) });
+            }
+            else {
+                throw new Error("Agent message must have content or toolCalls");
+            }
+        }
+    }
+    if (responseFormat?.type === "json_schema") {
+        systemMessages.push(`You should provide a json response with schema: ${JSON.stringify(responseFormat.jsonSchema.schema)}`);
+    }
+    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)
+            throw new Error("No messages provided");
+        return { messages: [{ role: "user", content: system }] };
+    }
+    return { messages: msgs, system };
+}
+function convertContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((item) => item.type === "image_url"
+            ? { type: "image", source: { type: "url", url: item.url } }
+            : { type: "text", text: item.text });
+    }
+    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 };
+    }
+    else if (toolChoice === "none") {
+        choice = { type: "none" };
+    }
+    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,
+        tool_choice: choice,
+    };
+}

package/lib/cjs/index.d.ts

@@ -0,0 +1 @@
+export * from "./anthropic-chat-model.js";

package/lib/cjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./anthropic-chat-model.js"), exports);

package/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

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

@@ -0,0 +1,113 @@
+import { type AgentProcessResult, ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "@aigne/core";
+import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import Anthropic from "@anthropic-ai/sdk";
+import { z } from "zod";
+/**
+ * Configuration options for Claude Chat Model
+ */
+export interface AnthropicChatModelOptions {
+    /**
+     * 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;
+    /**
+     * Claude model to use
+     *
+     * Defaults to 'claude-3-7-sonnet-latest'
+     */
+    model?: string;
+    /**
+     * Additional model options to control behavior
+     */
+    modelOptions?: ChatModelOptions;
+}
+/**
+ * @hidden
+ */
+export 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}
+ */
+export declare class AnthropicChatModel extends ChatModel {
+    options?: AnthropicChatModelOptions | undefined;
+    constructor(options?: AnthropicChatModelOptions | undefined);
+    /**
+     * @hidden
+     */
+    protected _client?: Anthropic;
+    get client(): Anthropic;
+    get modelOptions(): ChatModelOptions | undefined;
+    /**
+     * Process the input using Claude's chat model
+     * @param input - The input to process
+     * @returns The processed output from the model
+     */
+    process(input: ChatModelInput): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    private _process;
+    private extractResultFromAnthropicStream;
+    private requestStructuredOutput;
+}

package/lib/dts/index.d.ts

@@ -0,0 +1 @@
+export * from "./anthropic-chat-model.js";

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

@@ -0,0 +1,113 @@
+import { type AgentProcessResult, ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "@aigne/core";
+import { type PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import Anthropic from "@anthropic-ai/sdk";
+import { z } from "zod";
+/**
+ * Configuration options for Claude Chat Model
+ */
+export interface AnthropicChatModelOptions {
+    /**
+     * 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;
+    /**
+     * Claude model to use
+     *
+     * Defaults to 'claude-3-7-sonnet-latest'
+     */
+    model?: string;
+    /**
+     * Additional model options to control behavior
+     */
+    modelOptions?: ChatModelOptions;
+}
+/**
+ * @hidden
+ */
+export 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}
+ */
+export declare class AnthropicChatModel extends ChatModel {
+    options?: AnthropicChatModelOptions | undefined;
+    constructor(options?: AnthropicChatModelOptions | undefined);
+    /**
+     * @hidden
+     */
+    protected _client?: Anthropic;
+    get client(): Anthropic;
+    get modelOptions(): ChatModelOptions | undefined;
+    /**
+     * Process the input using Claude's chat model
+     * @param input - The input to process
+     * @returns The processed output from the model
+     */
+    process(input: ChatModelInput): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    private _process;
+    private extractResultFromAnthropicStream;
+    private requestStructuredOutput;
+}