@aigne/core 1.7.0 → 1.9.0

package/lib/esm/agents/agent.js

@@ -2,7 +2,7 @@ import { inspect } from "node:util";
 import { ZodObject, z } from "zod";
 import { createMessage } from "../prompt/prompt-builder.js";
 import { logger } from "../utils/logger.js";
-import { createAccessorArray, orArrayToArray, } from "../utils/type-utils.js";
+import { checkArguments, createAccessorArray, orArrayToArray, } from "../utils/type-utils.js";
 import { AgentMemory } from "./memory.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
 export class Agent {
@@ -101,12 +101,12 @@ export class Agent {
         if (!this.disableEvents)
             ctx.emit("agentStarted", { agent: this, input: message });
         try {
-            const parsedInput = this.inputSchema.parse(message);
+            const parsedInput = checkArguments(`Agent ${this.name} input`, this.inputSchema, message);
             this.preprocess(parsedInput, ctx);
             this.checkContextStatus(ctx);
             const output = await this.process(parsedInput, ctx)
                 .then((output) => {
-                const parsedOutput = this.outputSchema.parse(output);
+                const parsedOutput = checkArguments(`Agent ${this.name} output`, this.outputSchema, output);
                 return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
             })
                 .then((output) => {

package/lib/esm/agents/mcp-agent.d.ts

@@ -22,7 +22,7 @@ export type SSEServerParameters = {
     opts?: SSEClientTransportOptions;
     /**
      * The timeout for requests to the server, in milliseconds.
-     * @default 10000
+     * @default 60000
      */
     timeout?: number;
     /**
@@ -41,7 +41,7 @@ export declare class MCPAgent extends Agent {
     static from(options: MCPAgentOptions): MCPAgent;
     private static fromTransport;
     constructor(options: MCPAgentOptions);
-    private client;
+    client: Client;
     readonly prompts: MCPPrompt[] & {
         [key: string]: MCPPrompt;
     };
@@ -71,7 +71,6 @@ export interface MCPBaseOptions<I extends Message = Message, O extends Message =
 export declare abstract class MCPBase<I extends Message, O extends Message> extends Agent<I, O> {
     constructor(options: MCPBaseOptions<I, O>);
     protected client: ClientWithReconnect;
-    protected get mcpServer(): string | undefined;
 }
 export declare class MCPTool extends MCPBase<Message, CallToolResult> {
     process(input: Message): Promise<CallToolResult>;

package/lib/esm/agents/mcp-agent.js

@@ -11,6 +11,11 @@ import { Agent } from "./agent.js";
 const MCP_AGENT_CLIENT_NAME = "MCPAgent";
 const MCP_AGENT_CLIENT_VERSION = "0.0.1";
 const DEFAULT_MAX_RECONNECTS = 10;
+const DEFAULT_TIMEOUT = () => z.coerce
+    .number()
+    .int()
+    .min(0)
+    .safeParse(process.env.MCP_TIMEOUT || process.env.TIMEOUT).data || 60e3;
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
 }
@@ -133,7 +138,9 @@ class ClientWithReconnect extends Client {
             throw new Error("reconnect requires a transportCreator");
         await pRetry(async () => {
             await this.close();
-            await this.connect(await transportCreator());
+            await this.connect(await transportCreator(), {
+                timeout: this.reconnectOptions?.timeout ?? DEFAULT_TIMEOUT(),
+            });
         }, {
             retries: this.reconnectOptions?.maxReconnects ?? DEFAULT_MAX_RECONNECTS,
             shouldRetry: this.shouldReconnect,
@@ -142,8 +149,8 @@ class ClientWithReconnect extends Client {
     }
     async request(request, resultSchema, options) {
         const mergedOptions = {
-            ...(options ?? {}),
-            timeout: options?.timeout ?? this.reconnectOptions?.timeout ?? 10000,
+            ...options,
+            timeout: options?.timeout ?? DEFAULT_TIMEOUT(),
         };
         try {
             return await super.request(request, resultSchema, mergedOptions);
@@ -164,9 +171,6 @@ export class MCPBase extends Agent {
         this.client = options.client;
     }
     client;
-    get mcpServer() {
-        return getMCPServerName(this.client);
-    }
 }
 export class MCPTool extends MCPBase {
     async process(input) {

package/lib/esm/execution-engine/execution-engine.js

@@ -9,8 +9,8 @@ export class ExecutionEngine {
     static async load({ path, ...options }) {
         const { model, agents, tools, ...aigne } = await load({ path });
         return new ExecutionEngine({
-            model,
             ...options,
+            model: options.model || model,
             name: options.name || aigne.name || undefined,
             description: options.description || aigne.description || undefined,
             agents: agents.concat(options.agents ?? []),

package/lib/esm/loader/agent-js.js

@@ -22,7 +22,7 @@ export async function loadAgentFromJsFile(path) {
         throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
     }
     return tryOrThrow(() => agentJsFileSchema.parse({
-        name: agent.name,
+        name: agent.agent_name || agent.name,
         description: agent.description,
         input_schema: agent.input_schema,
         output_schema: agent.output_schema,

package/lib/esm/loader/agent-yaml.d.ts

@@ -10,6 +10,7 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     }, {
         [x: string]: any;
     }> | undefined;
+    tool_choice?: "auto" | "none" | "required" | "router" | undefined;
     output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {

package/lib/esm/loader/agent-yaml.js

@@ -30,6 +30,10 @@ const agentFileSchema = z.discriminatedUnion("type", [
             .array(z.string())
             .nullish()
             .transform((v) => v ?? undefined),
+        tool_choice: z
+            .union([z.literal("auto"), z.literal("none"), z.literal("required"), z.literal("router")])
+            .nullish()
+            .transform((v) => v ?? undefined),
     }),
     z.object({
         type: z.literal("mcp"),

package/lib/esm/loader/index.d.ts

@@ -1,5 +1,6 @@
+import { z } from "zod";
 import { type Agent } from "../agents/agent.js";
-import type { ChatModel } from "../models/chat-model.js";
+import type { ChatModel, ChatModelOptions } from "../models/chat-model.js";
 export interface LoadOptions {
     path: string;
 }
@@ -19,6 +20,75 @@ export declare function load(options: LoadOptions): Promise<{
     } | null | undefined;
 }>;
 export declare function loadAgent(path: string): Promise<Agent>;
+export declare function loadModel(model?: z.infer<typeof aigneFileSchema>["chat_model"], modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
+declare const aigneFileSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    chat_model: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        top_p: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        frequent_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        presence_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    }, {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    }>]>>>, {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined, string | {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined>;
+    agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    description?: string | null | undefined;
+    tools?: string[] | null | undefined;
+    name?: string | null | undefined;
+    chat_model?: {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined;
+    agents?: string[] | null | undefined;
+}, {
+    description?: string | null | undefined;
+    tools?: string[] | null | undefined;
+    name?: string | null | undefined;
+    chat_model?: string | {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined;
+    agents?: string[] | null | undefined;
+}>;
 export declare function loadAIGNEFile(path: string): Promise<{
     description?: string | null | undefined;
     tools?: string[] | null | undefined;
@@ -33,3 +103,4 @@ export declare function loadAIGNEFile(path: string): Promise<{
     } | null | undefined;
     agents?: string[] | null | undefined;
 }>;
+export {};

package/lib/esm/loader/index.js

@@ -6,12 +6,15 @@ import { FunctionAgent } from "../agents/agent.js";
 import { AIAgent } from "../agents/ai-agent.js";
 import { MCPAgent } from "../agents/mcp-agent.js";
 import { ClaudeChatModel } from "../models/claude-chat-model.js";
+import { DeepSeekChatModel } from "../models/deepseek-chat-model.js";
+import { GeminiChatModel } from "../models/gemini-chat-model.js";
+import { OllamaChatModel } from "../models/ollama-chat-model.js";
+import { OpenRouterChatModel } from "../models/open-router-chat-model.js";
 import { OpenAIChatModel } from "../models/openai-chat-model.js";
 import { XAIChatModel } from "../models/xai-chat-model.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { loadAgentFromJsFile } from "./agent-js.js";
 import { loadAgentFromYamlFile } from "./agent-yaml.js";
-const DEFAULT_MODEL_PROVIDER = "openai";
 const AIGNE_FILE_NAME = ["aigne.yaml", "aigne.yml"];
 export async function load(options) {
     const { path } = options;
@@ -49,6 +52,7 @@ export async function loadAgent(path) {
                 outputSchema: agent.output_schema,
                 outputKey: agent.output_key,
                 tools: await Promise.all((agent.tools ?? []).map((filename) => loadAgent(join(dirname(path), filename)))),
+                toolChoice: agent.tool_choice,
             });
         }
         if (agent.type === "mcp") {
@@ -68,21 +72,32 @@ export async function loadAgent(path) {
     }
     throw new Error(`Unsupported agent file type: ${path}`);
 }
-async function loadModel(model) {
-    if (!model?.name)
-        return undefined;
+const { MODEL_PROVIDER, MODEL_NAME } = process.env;
+const DEFAULT_MODEL_PROVIDER = "openai";
+const DEFAULT_MODEL_NAME = "gpt-4o-mini";
+export async function loadModel(model, modelOptions) {
     const params = {
-        model: model.name,
-        temperature: model.temperature ?? undefined,
-        topP: model.top_p ?? undefined,
-        frequencyPenalty: model.frequent_penalty ?? undefined,
-        presencePenalty: model.presence_penalty ?? undefined,
+        model: MODEL_NAME ?? model?.name ?? DEFAULT_MODEL_NAME,
+        temperature: model?.temperature ?? undefined,
+        topP: model?.top_p ?? undefined,
+        frequencyPenalty: model?.frequent_penalty ?? undefined,
+        presencePenalty: model?.presence_penalty ?? undefined,
     };
-    const availableModels = [OpenAIChatModel, ClaudeChatModel, XAIChatModel];
-    const M = availableModels.find((m) => m.name.toLowerCase().includes(model.provider || DEFAULT_MODEL_PROVIDER));
+    const availableModels = [
+        OpenAIChatModel,
+        ClaudeChatModel,
+        XAIChatModel,
+        GeminiChatModel,
+        DeepSeekChatModel,
+        OpenRouterChatModel,
+        OllamaChatModel,
+    ];
+    const M = availableModels.find((m) => m.name
+        .toLowerCase()
+        .includes((MODEL_PROVIDER ?? model?.provider ?? DEFAULT_MODEL_PROVIDER).toLowerCase()));
     if (!M)
-        throw new Error(`Unsupported model: ${model.provider} ${model.name}`);
-    return new M(params);
+        throw new Error(`Unsupported model: ${model?.provider} ${model?.name}`);
+    return new M({ model: params.model, modelOptions: { ...params, ...modelOptions } });
 }
 const aigneFileSchema = z.object({
     name: z.string().nullish(),

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

@@ -30,7 +30,7 @@ export class ClaudeChatModel extends ChatModel {
     }
     _client;
     get client() {
-        const apiKey = this.options?.apiKey || process.env.CLAUDE_API_KEY;
+        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 });

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

@@ -0,0 +1,7 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+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

@@ -0,0 +1,15 @@
+import { OpenAIChatModel } from "./openai-chat-model.js";
+const DEEPSEEK_DEFAULT_CHAT_MODEL = "deepseek-chat";
+const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+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

@@ -0,0 +1,8 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class GeminiChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected supportsEndWithSystemMessage: boolean;
+    protected supportsToolsUseWithJsonSchema: boolean;
+    protected supportsParallelToolCalls: boolean;
+}

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

@@ -0,0 +1,16 @@
+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";
+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;
+}

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

@@ -0,0 +1,6 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class OllamaChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected apiKeyDefault: string;
+}

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

@@ -0,0 +1,14 @@
+import { OpenAIChatModel } from "./openai-chat-model.js";
+const OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434/v1";
+const OLLAMA_DEFAULT_CHAT_MODEL = "llama3.2";
+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

@@ -0,0 +1,5 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class OpenRouterChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+}

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

@@ -0,0 +1,13 @@
+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";
+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";
+}

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

@@ -1,6 +1,8 @@
 import OpenAI from "openai";
+import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
+import type { Stream } from "openai/streaming.js";
 import { z } from "zod";
-import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
+import { ChatModel, type ChatModelInput, type ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput, type Role } from "./chat-model.js";
 export interface OpenAIChatModelOptions {
     apiKey?: string;
     baseURL?: string;
@@ -62,7 +64,27 @@ export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);
     protected _client?: OpenAI;
+    protected apiKeyEnvName: string;
+    protected apiKeyDefault: string | undefined;
+    protected supportsNativeStructuredOutputs: boolean;
+    protected supportsEndWithSystemMessage: boolean;
+    protected supportsToolsUseWithJsonSchema: boolean;
+    protected supportsParallelToolCalls: boolean;
+    protected supportsToolsEmptyParameters: boolean;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;
+    private getParallelToolCalls;
+    private getRunMessages;
+    private getRunResponseFormat;
+    private requestStructuredOutput;
 }
+export declare const ROLE_MAP: {
+    [key in Role]: ChatCompletionMessageParam["role"];
+};
+export declare function contentsFromInputMessages(messages: ChatModelInputMessage[]): Promise<ChatCompletionMessageParam[]>;
+export declare function toolsFromInputTools(tools?: ChatModelInputTool[], options?: {
+    addTypeToEmptyParameters?: boolean;
+}): ChatCompletionTool[] | undefined;
+export declare function jsonSchemaToOpenAIJsonSchema(schema: Record<string, unknown>): Record<string, unknown>;
+export declare function extractResultFromStream(stream: Stream<OpenAI.Chat.Completions.ChatCompletionChunk>, jsonMode?: boolean): Promise<ChatModelOutput>;