@aigne/anthropic 0.1.0

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

@@ -0,0 +1,310 @@
+import { ChatModel, } from "@aigne/core";
+import { parseJSON } from "@aigne/core/utils/json-schema.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 Anthropic from "@anthropic-ai/sdk";
+import { z } from "zod";
+const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
+/**
+ * @hidden
+ */
+export const claudeChatModelOptionsSchema = z.object({
+    apiKey: z.string().optional(),
+    model: z.string().optional(),
+    modelOptions: z
+        .object({
+        model: z.string().optional(),
+        temperature: z.number().optional(),
+        topP: z.number().optional(),
+        frequencyPenalty: z.number().optional(),
+        presencePenalty: z.number().optional(),
+        parallelToolCalls: 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}
+ */
+export class AnthropicChatModel extends ChatModel {
+    options;
+    constructor(options) {
+        if (options)
+            checkArguments("AnthropicChatModel", 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 Anthropic({ 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: 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() ? 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");
+        }
+        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,
+            },
+        };
+    }
+}
+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: isEmpty(i.function.parameters)
+                    ? { type: "object" }
+                    : i.function.parameters,
+            }))
+            : undefined,
+        tool_choice: choice,
+    };
+}

package/lib/esm/index.d.ts

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

package/lib/esm/index.js

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

package/lib/esm/package.json

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

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@aigne/anthropic",
+  "version": "0.1.0",
+  "description": "AIGNE Anthropic SDK for integrating with Claude AI models",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Arcblock <blocklet@arcblock.io> https://github.com/blocklet",
+  "homepage": "https://github.com/AIGNE-io/aigne-framework",
+  "license": "Elastic-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AIGNE-io/aigne-framework"
+  },
+  "files": [
+    "lib/cjs",
+    "lib/dts",
+    "lib/esm",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "main": "./lib/cjs/index.js",
+  "module": "./lib/esm/index.js",
+  "types": "./lib/dts/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js",
+      "types": "./lib/dts/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.41.0",
+    "zod": "^3.24.4",
+    "@aigne/core": "^1.16.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.12",
+    "@types/node": "^22.15.15",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3",
+    "@aigne/test-utils": "^0.3.0"
+  },
+  "scripts": {
+    "lint": "tsc --noEmit",
+    "build": "tsc --build scripts/tsconfig.build.json",
+    "clean": "rimraf lib test/coverage",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter=lcov --coverage-reporter=text",
+    "postbuild": "echo '{\"type\": \"module\"}' > lib/esm/package.json && echo '{\"type\": \"commonjs\"}' > lib/cjs/package.json"
+  }
+}