@aigne/core 1.5.1-1 → 1.6.0

package/CHANGELOG.md

@@ -22,6 +22,20 @@
 * rename @aigne/core-next to @aigne/core ([3a81009](https://github.com/AIGNE-io/aigne-framework/commit/3a8100962c81813217b687ae28e8de604419c622))
 * use text resource from MCP correctly ([8b9eba8](https://github.com/AIGNE-io/aigne-framework/commit/8b9eba83352ec096a2a5d4f410d4c4bde7420bce))
 
+## [1.6.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.5.0...core-v1.6.0) (2025-04-08)
+
+
+### Features
+
+* add `serve` command for @aigne/cli ([#54](https://github.com/AIGNE-io/aigne-framework/issues/54)) ([1cca843](https://github.com/AIGNE-io/aigne-framework/commit/1cca843f1760abe832b6651108fa858130f47355))
+* add agent library support ([#51](https://github.com/AIGNE-io/aigne-framework/issues/51)) ([1f0d34d](https://github.com/AIGNE-io/aigne-framework/commit/1f0d34ddda3154283a4bc958ddb9b68b4ac106b0))
+* support token/call/time limits for ExecutionEngine ([#44](https://github.com/AIGNE-io/aigne-framework/issues/44)) ([5a2ca0a](https://github.com/AIGNE-io/aigne-framework/commit/5a2ca0a033267dd4765f574b53dca71e932e53d4))
+
+
+### Bug Fixes
+
+* support reconnect to the MCP server automatically ([#50](https://github.com/AIGNE-io/aigne-framework/issues/50)) ([898d83f](https://github.com/AIGNE-io/aigne-framework/commit/898d83f75fc655142b93c70a1afeda376a2e92b4))
+
 ## [1.5.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.4.0...core-v1.5.0) (2025-03-27)
 
 

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

@@ -1,7 +1,11 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Client, type ClientOptions } from "@modelcontextprotocol/sdk/client/index.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { CallToolResult, GetPromptResult, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { CallToolResult, GetPromptResult, Implementation, ReadResourceResult, Request } from "@modelcontextprotocol/sdk/types.js";
+import { type ZodType, z } from "zod";
 import type { Context } from "../execution-engine/context.js";
+import { type PromiseOrValue } from "../utils/type-utils.js";
 import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface MCPAgentOptions extends AgentOptions {
     client: Client;
@@ -11,6 +15,16 @@ export interface MCPAgentOptions extends AgentOptions {
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
     url: string;
+    /**
+     * Whether to automatically reconnect to the server if the connection is lost.
+     * @default 10 set to 0 to disable automatic reconnection
+     */
+    maxReconnects?: number;
+    /**
+     * A function that determines whether to reconnect to the server based on the error.
+     * default to reconnect on all errors.
+     */
+    shouldReconnect?: (error: Error) => boolean;
 };
 export declare class MCPAgent extends Agent {
     static from(options: MCPServerOptions): Promise<MCPAgent>;
@@ -28,12 +42,24 @@ export declare class MCPAgent extends Agent {
     process(_input: Message, _context?: Context): Promise<Message>;
     shutdown(): Promise<void>;
 }
-export interface MCPToolBaseOptions<I extends Message, O extends Message> extends AgentOptions<I, O> {
-    client: Client;
+export interface ClientWithReconnectOptions {
+    transportCreator?: () => PromiseOrValue<Transport>;
+    maxReconnects?: number;
+    shouldReconnect?: (error: Error) => boolean;
+}
+declare class ClientWithReconnect extends Client {
+    private reconnectOptions?;
+    constructor(info: Implementation, options?: ClientOptions, reconnectOptions?: ClientWithReconnectOptions | undefined);
+    private shouldReconnect;
+    private reconnect;
+    request<T extends ZodType<object>>(request: Request, resultSchema: T, options?: RequestOptions): Promise<z.infer<T>>;
+}
+export interface MCPBaseOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
+    client: ClientWithReconnect;
 }
 export declare abstract class MCPBase<I extends Message, O extends Message> extends Agent<I, O> {
-    constructor(options: MCPToolBaseOptions<I, O>);
-    protected client: Client;
+    constructor(options: MCPBaseOptions<I, O>);
+    protected client: ClientWithReconnect;
     protected get mcpServer(): string | undefined;
 }
 export declare class MCPTool extends MCPBase<Message, CallToolResult> {
@@ -45,7 +71,7 @@ export interface MCPPromptInput extends Message {
 export declare class MCPPrompt extends MCPBase<MCPPromptInput, GetPromptResult> {
     process(input: MCPPromptInput): Promise<GetPromptResult>;
 }
-export interface MCPResourceOptions extends MCPToolBaseOptions<MCPPromptInput, ReadResourceResult> {
+export interface MCPResourceOptions extends MCPBaseOptions<MCPPromptInput, ReadResourceResult> {
     uri: string;
 }
 export declare class MCPResource extends MCPBase<MCPPromptInput, ReadResourceResult> {
@@ -53,3 +79,4 @@ export declare class MCPResource extends MCPBase<MCPPromptInput, ReadResourceRes
     uri: string;
     process(input: MCPPromptInput): Promise<ReadResourceResult>;
 }
+export {};

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

@@ -1,10 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCPResource = exports.MCPPrompt = exports.MCPTool = exports.MCPBase = exports.MCPAgent = void 0;
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
 const uriTemplate_js_1 = require("@modelcontextprotocol/sdk/shared/uriTemplate.js");
+const p_retry_1 = __importDefault(require("p-retry"));
 const zod_1 = require("zod");
 const logger_js_1 = require("../utils/logger.js");
 const mcp_utils_js_1 = require("../utils/mcp-utils.js");
@@ -12,6 +16,7 @@ const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
 const MCP_AGENT_CLIENT_NAME = "MCPAgent";
 const MCP_AGENT_CLIENT_VERSION = "0.0.1";
+const DEFAULT_MAX_RECONNECTS = 10;
 const debug = logger_js_1.logger.base.extend("mcp");
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
@@ -32,11 +37,11 @@ class MCPAgent extends agent_js_1.Agent {
     static from(options) {
         (0, type_utils_js_1.checkArguments)("MCPAgent.from", mcpAgentOptionsSchema, options);
         if (isSSEServerParameters(options)) {
-            const transport = new sse_js_1.SSEClientTransport(new URL(options.url));
+            const transport = () => new sse_js_1.SSEClientTransport(new URL(options.url));
             return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
-            const transport = new stdio_js_1.StdioClientTransport({
+            const transport = () => new stdio_js_1.StdioClientTransport({
                 ...options,
                 env: {
                     ...(0, stdio_js_1.getDefaultEnvironment)(),
@@ -48,23 +53,24 @@ class MCPAgent extends agent_js_1.Agent {
         }
         return new MCPAgent(options);
     }
-    static async fromTransport(transport, options) {
-        const client = new index_js_1.Client({
+    static async fromTransport(transportCreator, options) {
+        const client = new ClientWithReconnect({
             name: MCP_AGENT_CLIENT_NAME,
             version: MCP_AGENT_CLIENT_VERSION,
-        });
+        }, undefined, isSSEServerParameters(options) ? { transportCreator, ...options } : undefined);
+        const transport = transportCreator();
         await debug.spinner(client.connect(transport), `Connecting to MCP server: ${getMCPServerString(options)}`);
         const mcpServer = getMCPServerName(client);
         const { tools: isToolsAvailable, prompts: isPromptsAvailable, resources: isResourcesAvailable, } = client.getServerCapabilities() ?? {};
         const tools = isToolsAvailable
             ? await debug
                 .spinner(client.listTools(), `Listing tools from ${mcpServer}`, ({ tools }) => debug("%O", tools))
-                .then(({ tools }) => tools.map((tool) => (0, mcp_utils_js_1.toolFromMCPTool)(client, tool)))
+                .then(({ tools }) => tools.map((tool) => (0, mcp_utils_js_1.toolFromMCPTool)(tool, { client })))
             : undefined;
         const prompts = isPromptsAvailable
             ? await debug
                 .spinner(client.listPrompts(), `Listing prompts from ${mcpServer}`, ({ prompts }) => debug("%O", prompts))
-                .then(({ prompts }) => prompts.map((prompt) => (0, mcp_utils_js_1.promptFromMCPPrompt)(client, prompt)))
+                .then(({ prompts }) => prompts.map((prompt) => (0, mcp_utils_js_1.promptFromMCPPrompt)(prompt, { client })))
             : undefined;
         const resources = isResourcesAvailable
             ? await debug
@@ -75,7 +81,7 @@ class MCPAgent extends agent_js_1.Agent {
                 client.listResources().catch(() => ({ resources: [] })),
                 client.listResourceTemplates().catch(() => ({ resourceTemplates: [] })),
             ]), `Listing resources from ${mcpServer}`, ([{ resources }, { resourceTemplates }]) => debug("%O\n%O", resources, resourceTemplates))
-                .then(([{ resources }, { resourceTemplates }]) => [...resources, ...resourceTemplates].map((resource) => (0, mcp_utils_js_1.resourceFromMCPResource)(client, resource)))
+                .then(([{ resources }, { resourceTemplates }]) => [...resources, ...resourceTemplates].map((resource) => (0, mcp_utils_js_1.resourceFromMCPResource)(resource, { client })))
             : undefined;
         return new MCPAgent({
             name: client.getServerVersion()?.name,
@@ -108,6 +114,47 @@ class MCPAgent extends agent_js_1.Agent {
     }
 }
 exports.MCPAgent = MCPAgent;
+class ClientWithReconnect extends index_js_1.Client {
+    reconnectOptions;
+    constructor(info, options, reconnectOptions) {
+        super(info, options);
+        this.reconnectOptions = reconnectOptions;
+    }
+    shouldReconnect(error) {
+        const { transportCreator, shouldReconnect, maxReconnects } = this.reconnectOptions || {};
+        if (!transportCreator || maxReconnects === 0)
+            return false;
+        if (!shouldReconnect)
+            return true; // default to reconnect on all errors
+        return shouldReconnect(error);
+    }
+    async reconnect() {
+        const transportCreator = this.reconnectOptions?.transportCreator;
+        if (!transportCreator)
+            throw new Error("reconnect requires a transportCreator");
+        await (0, p_retry_1.default)(async () => {
+            await this.close();
+            await this.connect(await transportCreator());
+        }, {
+            retries: this.reconnectOptions?.maxReconnects ?? DEFAULT_MAX_RECONNECTS,
+            shouldRetry: this.shouldReconnect,
+            onFailedAttempt: (error) => debug("Reconnect attempt failed: %O", error),
+        });
+    }
+    async request(request, resultSchema, options) {
+        try {
+            return await super.request(request, resultSchema, options);
+        }
+        catch (error) {
+            if (this.shouldReconnect(error)) {
+                debug("Error occurred, reconnecting to MCP server: %O", error);
+                await this.reconnect();
+                return await super.request(request, resultSchema, options);
+            }
+            throw error;
+        }
+    }
+}
 class MCPBase extends agent_js_1.Agent {
     constructor(options) {
         super(options);

package/lib/cjs/agents/user-agent.d.ts

@@ -1,3 +1,4 @@
+import { ReadableStream } from "node:stream/web";
 import type { Context } from "../execution-engine/context.js";
 import type { MessagePayload, MessageQueueListener, Unsubscribe } from "../execution-engine/message-queue.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";

package/lib/cjs/agents/user-agent.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserAgent = void 0;
+const web_1 = require("node:stream/web");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
 class UserAgent extends agent_js_1.Agent {
@@ -44,7 +45,7 @@ class UserAgent extends agent_js_1.Agent {
     }
     get stream() {
         let subscriptions = [];
-        return new ReadableStream({
+        return new web_1.ReadableStream({
             start: (controller) => {
                 const subscribeTopic = (0, type_utils_js_1.orArrayToArray)(this.subscribeTopic);
                 subscriptions = subscribeTopic.map((topic) => this.subscribe(topic, (message) => {

package/lib/cjs/execution-engine/execution-engine.d.ts

@@ -5,17 +5,28 @@ import { ChatModel } from "../models/chat-model.js";
 import { type ContextLimits, ExecutionContext, type Runnable } from "./context.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 export interface ExecutionEngineOptions {
+    name?: string;
+    description?: string;
     model?: ChatModel;
     tools?: Agent[];
     agents?: Agent[];
     limits?: ContextLimits;
 }
 export declare class ExecutionEngine extends EventEmitter {
+    static load({ path, ...options }: {
+        path: string;
+    } & ExecutionEngineOptions): Promise<ExecutionEngine>;
     constructor(options?: ExecutionEngineOptions);
+    name?: string;
+    description?: string;
     readonly messageQueue: MessageQueue;
     model?: ChatModel;
-    tools: Agent[];
-    private agents;
+    readonly tools: Agent<Message, Message>[] & {
+        [key: string]: Agent<Message, Message>;
+    };
+    readonly agents: Agent<Message, Message>[] & {
+        [key: string]: Agent<Message, Message>;
+    };
     limits?: ContextLimits;
     addAgent(...agents: Agent[]): void;
     newContext(): ExecutionContext;

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

@@ -7,26 +7,43 @@ exports.ExecutionEngine = void 0;
 const node_events_1 = __importDefault(require("node:events"));
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
+const index_js_1 = require("../loader/index.js");
 const chat_model_js_1 = require("../models/chat-model.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const context_js_1 = require("./context.js");
 const message_queue_js_1 = require("./message-queue.js");
 class ExecutionEngine extends node_events_1.default {
+    static async load({ path, ...options }) {
+        const { model, agents, tools, ...aigne } = await (0, index_js_1.load)({ path });
+        return new ExecutionEngine({
+            model,
+            ...options,
+            name: options.name || aigne.name || undefined,
+            description: options.description || aigne.description || undefined,
+            agents: agents.concat(options.agents ?? []),
+            tools: tools.concat(options.tools ?? []),
+        });
+    }
     constructor(options) {
         if (options)
             (0, type_utils_js_1.checkArguments)("ExecutionEngine", executionEngineOptionsSchema, options);
         super();
+        this.name = options?.name;
+        this.description = options?.description;
         this.model = options?.model;
-        this.tools = options?.tools ?? [];
         this.limits = options?.limits;
+        if (options?.tools?.length)
+            this.tools.push(...options.tools);
         if (options?.agents?.length)
             this.addAgent(...options.agents);
         this.initProcessExitHandler();
     }
+    name;
+    description;
     messageQueue = new message_queue_js_1.MessageQueue();
     model;
-    tools;
-    agents = [];
+    tools = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
+    agents = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
     limits;
     addAgent(...agents) {
         (0, type_utils_js_1.checkArguments)("ExecutionEngine.addAgent", executionEngineAddAgentArgsSchema, agents);

package/lib/cjs/loader/agent-js.d.ts

@@ -0,0 +1,17 @@
+import { type ZodObject, type ZodType, z } from "zod";
+import type { Message } from "../agents/agent.js";
+export declare function loadAgentFromJsFile(path: string): Promise<{
+    name: string;
+    fn: (args_0: Message) => Message;
+    description?: string | undefined;
+    input_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> | undefined;
+    output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> | undefined;
+}>;

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

@@ -0,0 +1,67 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAgentFromJsFile = loadAgentFromJsFile;
+const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
+const zod_1 = require("zod");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const schema_js_1 = require("./schema.js");
+const agentJsFileSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    description: zod_1.z
+        .string()
+        .nullish()
+        .transform((v) => v ?? undefined),
+    input_schema: schema_js_1.inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
+    output_schema: schema_js_1.inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
+    fn: zod_1.z.function(),
+});
+async function loadAgentFromJsFile(path) {
+    const { default: agent } = await (0, type_utils_js_1.tryOrThrow)(() => Promise.resolve(`${path}`).then(s => __importStar(require(s))), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    if (typeof agent !== "function") {
+        throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
+    }
+    return (0, type_utils_js_1.tryOrThrow)(() => agentJsFileSchema.parse({
+        name: agent.name,
+        description: agent.description,
+        input_schema: agent.input_schema,
+        output_schema: agent.output_schema,
+        fn: agent,
+    }), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
+}

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

@@ -0,0 +1,24 @@
+import { type ZodObject, type ZodType, z } from "zod";
+export declare function loadAgentFromYamlFile(path: string): Promise<{
+    type: "ai";
+    name: string;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    instructions?: string | undefined;
+    input_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> | undefined;
+    output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> | undefined;
+    output_key?: string | undefined;
+} | {
+    type: "mcp";
+    url?: string | undefined;
+    command?: string | undefined;
+    args?: string[] | undefined;
+}>;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAgentFromYamlFile = loadAgentFromYamlFile;
+const promises_1 = require("node:fs/promises");
+const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
+const yaml_1 = require("yaml");
+const zod_1 = require("zod");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const schema_js_1 = require("./schema.js");
+const agentFileSchema = zod_1.z.discriminatedUnion("type", [
+    zod_1.z.object({
+        type: zod_1.z.literal("ai"),
+        name: zod_1.z.string(),
+        description: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        instructions: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        input_schema: schema_js_1.inputOutputSchema
+            .nullish()
+            .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
+        output_schema: schema_js_1.inputOutputSchema
+            .nullish()
+            .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
+        output_key: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        tools: zod_1.z
+            .array(zod_1.z.string())
+            .nullish()
+            .transform((v) => v ?? undefined),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("mcp"),
+        url: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        command: zod_1.z
+            .string()
+            .nullish()
+            .transform((v) => v ?? undefined),
+        args: zod_1.z
+            .array(zod_1.z.string())
+            .nullish()
+            .transform((v) => v ?? undefined),
+    }),
+]);
+async function loadAgentFromYamlFile(path) {
+    const raw = await (0, type_utils_js_1.tryOrThrow)(() => (0, promises_1.readFile)(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
+    const agent = (0, type_utils_js_1.tryOrThrow)(() => agentFileSchema.parse({ ...json, type: json.type ?? "ai" }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
+    return agent;
+}

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

@@ -0,0 +1,35 @@
+import { type Agent } from "../agents/agent.js";
+import type { ChatModel } from "../models/chat-model.js";
+export interface LoadOptions {
+    path: string;
+}
+export declare function load(options: LoadOptions): Promise<{
+    model: ChatModel | undefined;
+    agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
+    tools: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
+    description?: 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;
+}>;
+export declare function loadAgent(path: string): Promise<Agent>;
+export declare function loadAIGNEFile(path: string): Promise<{
+    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;
+}>;

package/lib/cjs/loader/index.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = load;
+exports.loadAgent = loadAgent;
+exports.loadAIGNEFile = loadAIGNEFile;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const yaml_1 = require("yaml");
+const zod_1 = require("zod");
+const agent_js_1 = require("../agents/agent.js");
+const ai_agent_js_1 = require("../agents/ai-agent.js");
+const mcp_agent_js_1 = require("../agents/mcp-agent.js");
+const claude_chat_model_js_1 = require("../models/claude-chat-model.js");
+const openai_chat_model_js_1 = require("../models/openai-chat-model.js");
+const xai_chat_model_js_1 = require("../models/xai-chat-model.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const agent_js_js_1 = require("./agent-js.js");
+const agent_yaml_js_1 = require("./agent-yaml.js");
+const DEFAULT_MODEL_PROVIDER = "openai";
+const AIGNE_FILE_NAME = ["aigne.yaml", "aigne.yml"];
+async function load(options) {
+    const { path } = options;
+    const aigneFilePath = await getAIGNEFilePath(path);
+    const rootDir = (0, node_path_1.dirname)(aigneFilePath);
+    const aigne = await loadAIGNEFile(aigneFilePath);
+    const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
+    const tools = await Promise.all((aigne.tools ?? []).map((filename) => loadAgent((0, node_path_1.join)(rootDir, filename))));
+    return {
+        ...aigne,
+        model: await loadModel(aigne.chat_model),
+        agents,
+        tools,
+    };
+}
+async function loadAgent(path) {
+    if ((0, node_path_1.extname)(path) === ".js") {
+        const agent = await (0, agent_js_js_1.loadAgentFromJsFile)(path);
+        return agent_js_1.FunctionAgent.from({
+            name: agent.name,
+            description: agent.description,
+            inputSchema: agent.input_schema,
+            outputSchema: agent.output_schema,
+            fn: agent.fn,
+        });
+    }
+    if ((0, node_path_1.extname)(path) === ".yaml" || (0, node_path_1.extname)(path) === ".yml") {
+        const agent = await (0, agent_yaml_js_1.loadAgentFromYamlFile)(path);
+        if (agent.type === "ai") {
+            return ai_agent_js_1.AIAgent.from({
+                name: agent.name,
+                description: agent.description,
+                instructions: agent.instructions,
+                inputSchema: agent.input_schema,
+                outputSchema: agent.output_schema,
+                outputKey: agent.output_key,
+                tools: await Promise.all((agent.tools ?? []).map((filename) => loadAgent((0, node_path_1.join)((0, node_path_1.dirname)(path), filename)))),
+            });
+        }
+        if (agent.type === "mcp") {
+            if (agent.url) {
+                return mcp_agent_js_1.MCPAgent.from({
+                    url: agent.url,
+                });
+            }
+            if (agent.command) {
+                return mcp_agent_js_1.MCPAgent.from({
+                    command: agent.command,
+                    args: agent.args,
+                });
+            }
+            throw new Error(`Missing url or command in mcp agent: ${path}`);
+        }
+    }
+    throw new Error(`Unsupported agent file type: ${path}`);
+}
+async function loadModel(model) {
+    if (!model?.name)
+        return undefined;
+    const params = {
+        model: model.name,
+        temperature: model.temperature ?? undefined,
+        topP: model.top_p ?? undefined,
+        frequencyPenalty: model.frequent_penalty ?? undefined,
+        presencePenalty: model.presence_penalty ?? undefined,
+    };
+    const availableModels = [openai_chat_model_js_1.OpenAIChatModel, claude_chat_model_js_1.ClaudeChatModel, xai_chat_model_js_1.XAIChatModel];
+    const M = availableModels.find((m) => m.name.toLowerCase().includes(model.provider || DEFAULT_MODEL_PROVIDER));
+    if (!M)
+        throw new Error(`Unsupported model: ${model.provider} ${model.name}`);
+    return new M(params);
+}
+const aigneFileSchema = zod_1.z.object({
+    name: zod_1.z.string().nullish(),
+    description: zod_1.z.string().nullish(),
+    chat_model: zod_1.z
+        .union([
+        zod_1.z.string(),
+        zod_1.z.object({
+            provider: zod_1.z.string().nullish(),
+            name: zod_1.z.string().nullish(),
+            temperature: zod_1.z.number().min(0).max(2).nullish(),
+            top_p: zod_1.z.number().min(0).nullish(),
+            frequent_penalty: zod_1.z.number().min(-2).max(2).nullish(),
+            presence_penalty: zod_1.z.number().min(-2).max(2).nullish(),
+        }),
+    ])
+        .nullish()
+        .transform((v) => (typeof v === "string" ? { name: v } : v)),
+    agents: zod_1.z.array(zod_1.z.string()).nullish(),
+    tools: zod_1.z.array(zod_1.z.string()).nullish(),
+});
+async function loadAIGNEFile(path) {
+    const raw = await (0, type_utils_js_1.tryOrThrow)(() => (0, promises_1.readFile)(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
+    const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse aigne.yaml from ${path}: ${error.message}`));
+    const agent = (0, type_utils_js_1.tryOrThrow)(() => aigneFileSchema.parse(json), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
+    return agent;
+}
+async function getAIGNEFilePath(path) {
+    const s = await (0, promises_1.stat)(path);
+    if (s.isDirectory()) {
+        for (const file of AIGNE_FILE_NAME) {
+            const filePath = (0, node_path_1.join)(path, file);
+            if (await (0, promises_1.exists)(filePath))
+                return filePath;
+        }
+    }
+    return path;
+}