@aigne/core 1.14.0 → 1.16.0

package/lib/esm/models/claude-chat-model.js

@@ -1,310 +0,0 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { z } from "zod";
-import { parseJSON } from "../utils/json-schema.js";
-import { mergeUsage } from "../utils/model-utils.js";
-import { agentResponseStreamToObject } from "../utils/stream-utils.js";
-import { checkArguments, isEmpty, isNonNullable, } from "../utils/type-utils.js";
-import { ChatModel, } from "./chat-model.js";
-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/models/claude-chat-model.test.ts#example-claude-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/claude-chat-model.test.ts#example-claude-chat-model-streaming-async-generator}
- */
-export class ClaudeChatModel extends ChatModel {
-    options;
-    constructor(options) {
-        if (options)
-            checkArguments("ClaudeChatModel", 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 ClaudeChatModel");
-        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.extractResultFromClaudeStream(stream, true);
-        }
-        const result = await this.extractResultFromClaudeStream(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 extractResultFromClaudeStream(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/models/deepseek-chat-model.d.ts

@@ -1,23 +0,0 @@
-import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
-/**
- * Implementation of the ChatModel interface for DeepSeek's API
- *
- * This model uses OpenAI-compatible API format to interact with DeepSeek's models,
- * but with specific configuration and capabilities for DeepSeek.
- *
- * Default model: 'deepseek-chat'
- *
- * @example
- * Here's how to create and use a DeepSeek chat model:
- * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model-streaming}
- */
-export declare class DeepSeekChatModel extends OpenAIChatModel {
-    constructor(options?: OpenAIChatModelOptions);
-    protected apiKeyEnvName: string;
-    protected supportsNativeStructuredOutputs: boolean;
-    protected supportsToolsEmptyParameters: boolean;
-}

package/lib/esm/models/deepseek-chat-model.js

@@ -1,31 +0,0 @@
-import { OpenAIChatModel } from "./openai-chat-model.js";
-const DEEPSEEK_DEFAULT_CHAT_MODEL = "deepseek-chat";
-const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
-/**
- * Implementation of the ChatModel interface for DeepSeek's API
- *
- * This model uses OpenAI-compatible API format to interact with DeepSeek's models,
- * but with specific configuration and capabilities for DeepSeek.
- *
- * Default model: 'deepseek-chat'
- *
- * @example
- * Here's how to create and use a DeepSeek chat model:
- * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model-streaming}
- */
-export class DeepSeekChatModel extends OpenAIChatModel {
-    constructor(options) {
-        super({
-            ...options,
-            model: options?.model || DEEPSEEK_DEFAULT_CHAT_MODEL,
-            baseURL: options?.baseURL || DEEPSEEK_BASE_URL,
-        });
-    }
-    apiKeyEnvName = "DEEPSEEK_API_KEY";
-    supportsNativeStructuredOutputs = false;
-    supportsToolsEmptyParameters = false;
-}

package/lib/esm/models/gemini-chat-model.d.ts

@@ -1,23 +0,0 @@
-import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
-/**
- * Implementation of the ChatModel interface for Google's Gemini API
- *
- * This model uses OpenAI-compatible API format to interact with Google's Gemini models,
- * providing access to models like Gemini 1.5 and Gemini 2.0.
- *
- * @example
- * Here's how to create and use a Gemini chat model:
- * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model-streaming}
- */
-export declare class GeminiChatModel extends OpenAIChatModel {
-    constructor(options?: OpenAIChatModelOptions);
-    protected apiKeyEnvName: string;
-    protected supportsEndWithSystemMessage: boolean;
-    protected supportsToolsUseWithJsonSchema: boolean;
-    protected supportsParallelToolCalls: boolean;
-    protected supportsToolStreaming: boolean;
-}

package/lib/esm/models/gemini-chat-model.js

@@ -1,31 +0,0 @@
-import { OpenAIChatModel } from "./openai-chat-model.js";
-const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai";
-const GEMINI_DEFAULT_CHAT_MODEL = "gemini-2.0-flash";
-/**
- * Implementation of the ChatModel interface for Google's Gemini API
- *
- * This model uses OpenAI-compatible API format to interact with Google's Gemini models,
- * providing access to models like Gemini 1.5 and Gemini 2.0.
- *
- * @example
- * Here's how to create and use a Gemini chat model:
- * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model-streaming}
- */
-export class GeminiChatModel extends OpenAIChatModel {
-    constructor(options) {
-        super({
-            ...options,
-            model: options?.model || GEMINI_DEFAULT_CHAT_MODEL,
-            baseURL: options?.baseURL || GEMINI_BASE_URL,
-        });
-    }
-    apiKeyEnvName = "GEMINI_API_KEY";
-    supportsEndWithSystemMessage = false;
-    supportsToolsUseWithJsonSchema = false;
-    supportsParallelToolCalls = false;
-    supportsToolStreaming = false;
-}

package/lib/esm/models/ollama-chat-model.d.ts

@@ -1,22 +0,0 @@
-import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
-/**
- * Implementation of the ChatModel interface for Ollama
- *
- * This model allows you to run open-source LLMs locally using Ollama,
- * with an OpenAI-compatible API interface.
- *
- * Default model: 'llama3.2'
- *
- * @example
- * Here's how to create and use an Ollama chat model:
- * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model-streaming}
- */
-export declare class OllamaChatModel extends OpenAIChatModel {
-    constructor(options?: OpenAIChatModelOptions);
-    protected apiKeyEnvName: string;
-    protected apiKeyDefault: string;
-}

package/lib/esm/models/ollama-chat-model.js

@@ -1,30 +0,0 @@
-import { OpenAIChatModel } from "./openai-chat-model.js";
-const OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434/v1";
-const OLLAMA_DEFAULT_CHAT_MODEL = "llama3.2";
-/**
- * Implementation of the ChatModel interface for Ollama
- *
- * This model allows you to run open-source LLMs locally using Ollama,
- * with an OpenAI-compatible API interface.
- *
- * Default model: 'llama3.2'
- *
- * @example
- * Here's how to create and use an Ollama chat model:
- * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model-streaming}
- */
-export class OllamaChatModel extends OpenAIChatModel {
-    constructor(options) {
-        super({
-            ...options,
-            model: options?.model || OLLAMA_DEFAULT_CHAT_MODEL,
-            baseURL: options?.baseURL || process.env.OLLAMA_BASE_URL || OLLAMA_DEFAULT_BASE_URL,
-        });
-    }
-    apiKeyEnvName = "OLLAMA_API_KEY";
-    apiKeyDefault = "ollama";
-}

package/lib/esm/models/open-router-chat-model.d.ts

@@ -1,22 +0,0 @@
-import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
-/**
- * Implementation of the ChatModel interface for OpenRouter service
- *
- * OpenRouter provides access to a variety of large language models through a unified API.
- * This implementation uses the OpenAI-compatible interface to connect to OpenRouter's service.
- *
- * Default model: 'openai/gpt-4o'
- *
- * @example
- * Here's how to create and use an OpenRouter chat model:
- * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model-streaming}
- */
-export declare class OpenRouterChatModel extends OpenAIChatModel {
-    constructor(options?: OpenAIChatModelOptions);
-    protected apiKeyEnvName: string;
-    protected supportsParallelToolCalls: boolean;
-}

package/lib/esm/models/open-router-chat-model.js

@@ -1,30 +0,0 @@
-import { OpenAIChatModel } from "./openai-chat-model.js";
-const OPEN_ROUTER_DEFAULT_CHAT_MODEL = "openai/gpt-4o";
-const OPEN_ROUTER_BASE_URL = "https://openrouter.ai/api/v1";
-/**
- * Implementation of the ChatModel interface for OpenRouter service
- *
- * OpenRouter provides access to a variety of large language models through a unified API.
- * This implementation uses the OpenAI-compatible interface to connect to OpenRouter's service.
- *
- * Default model: 'openai/gpt-4o'
- *
- * @example
- * Here's how to create and use an OpenRouter chat model:
- * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model}
- *
- * @example
- * Here's an example with streaming response:
- * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model-streaming}
- */
-export class OpenRouterChatModel extends OpenAIChatModel {
-    constructor(options) {
-        super({
-            ...options,
-            model: options?.model || OPEN_ROUTER_DEFAULT_CHAT_MODEL,
-            baseURL: options?.baseURL || OPEN_ROUTER_BASE_URL,
-        });
-    }
-    apiKeyEnvName = "OPEN_ROUTER_API_KEY";
-    supportsParallelToolCalls = false;
-}