@aigne/core 1.5.1-1 → 1.5.1-2

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

@@ -2,6 +2,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { UriTemplate } from "@modelcontextprotocol/sdk/shared/uriTemplate.js";
+import pRetry from "p-retry";
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { promptFromMCPPrompt, resourceFromMCPResource, toolFromMCPTool, } from "../utils/mcp-utils.js";
@@ -9,6 +10,7 @@ import { checkArguments, createAccessorArray } from "../utils/type-utils.js";
 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 debug = logger.base.extend("mcp");
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
@@ -29,11 +31,11 @@ export class MCPAgent extends Agent {
     static from(options) {
         checkArguments("MCPAgent.from", mcpAgentOptionsSchema, options);
         if (isSSEServerParameters(options)) {
-            const transport = new SSEClientTransport(new URL(options.url));
+            const transport = () => new SSEClientTransport(new URL(options.url));
             return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
-            const transport = new StdioClientTransport({
+            const transport = () => new StdioClientTransport({
                 ...options,
                 env: {
                     ...getDefaultEnvironment(),
@@ -45,23 +47,24 @@ export class MCPAgent extends Agent {
         }
         return new MCPAgent(options);
     }
-    static async fromTransport(transport, options) {
-        const client = new 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) => toolFromMCPTool(client, tool)))
+                .then(({ tools }) => tools.map((tool) => 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) => promptFromMCPPrompt(client, prompt)))
+                .then(({ prompts }) => prompts.map((prompt) => promptFromMCPPrompt(prompt, { client })))
             : undefined;
         const resources = isResourcesAvailable
             ? await debug
@@ -72,7 +75,7 @@ export class MCPAgent extends 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) => resourceFromMCPResource(client, resource)))
+                .then(([{ resources }, { resourceTemplates }]) => [...resources, ...resourceTemplates].map((resource) => resourceFromMCPResource(resource, { client })))
             : undefined;
         return new MCPAgent({
             name: client.getServerVersion()?.name,
@@ -104,6 +107,47 @@ export class MCPAgent extends Agent {
         await this.client.close();
     }
 }
+class ClientWithReconnect extends 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 pRetry(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;
+        }
+    }
+}
 export class MCPBase extends Agent {
     constructor(options) {
         super(options);

package/lib/esm/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/esm/agents/user-agent.js

@@ -1,3 +1,4 @@
+import { ReadableStream } from "node:stream/web";
 import { orArrayToArray } from "../utils/type-utils.js";
 import { Agent } from "./agent.js";
 export class UserAgent extends Agent {

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

@@ -11,11 +11,18 @@ export interface ExecutionEngineOptions {
     limits?: ContextLimits;
 }
 export declare class ExecutionEngine extends EventEmitter {
+    static load({ path, ...options }: {
+        path: string;
+    } & ExecutionEngineOptions): Promise<ExecutionEngine>;
     constructor(options?: ExecutionEngineOptions);
     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/esm/execution-engine/execution-engine.js

@@ -1,26 +1,37 @@
 import EventEmitter from "node:events";
 import { z } from "zod";
 import { Agent } from "../agents/agent.js";
+import { load } from "../loader/index.js";
 import { ChatModel } from "../models/chat-model.js";
-import { checkArguments } from "../utils/type-utils.js";
+import { checkArguments, createAccessorArray } from "../utils/type-utils.js";
 import { ExecutionContext } from "./context.js";
 import { MessageQueue, } from "./message-queue.js";
 export class ExecutionEngine extends EventEmitter {
+    static async load({ path, ...options }) {
+        const { model, agents, tools } = await load({ path });
+        return new ExecutionEngine({
+            model,
+            ...options,
+            agents: agents.concat(options.agents ?? []),
+            tools: tools.concat(options.tools ?? []),
+        });
+    }
     constructor(options) {
         if (options)
             checkArguments("ExecutionEngine", executionEngineOptionsSchema, options);
         super();
         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();
     }
     messageQueue = new MessageQueue();
     model;
-    tools;
-    agents = [];
+    tools = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
+    agents = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
     limits;
     addAgent(...agents) {
         checkArguments("ExecutionEngine.addAgent", executionEngineAddAgentArgsSchema, agents);

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

@@ -0,0 +1,21 @@
+import { readFile } from "node:fs/promises";
+import { type ZodObject, type ZodType, z } from "zod";
+export declare function loadAgentFromYamlFile(path: string, { readFile: _readFile }?: {
+    readFile?: typeof readFile;
+}): Promise<{
+    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;
+}>;

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

@@ -0,0 +1,37 @@
+import { readFile } from "node:fs/promises";
+import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
+import { parse } from "yaml";
+import { z } from "zod";
+import { tryOrThrow } from "../utils/type-utils.js";
+import { inputOutputSchema } from "./schema.js";
+const agentFileSchema = z.object({
+    name: z.string(),
+    description: z
+        .string()
+        .nullish()
+        .transform((v) => v ?? undefined),
+    instructions: z
+        .string()
+        .nullish()
+        .transform((v) => v ?? undefined),
+    input_schema: inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? jsonSchemaToZod(v) : undefined)),
+    output_schema: inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? jsonSchemaToZod(v) : undefined)),
+    output_key: z
+        .string()
+        .nullish()
+        .transform((v) => v ?? undefined),
+    tools: z
+        .array(z.string())
+        .nullish()
+        .transform((v) => v ?? undefined),
+});
+export async function loadAgentFromYamlFile(path, { readFile: _readFile = readFile } = {}) {
+    const raw = await tryOrThrow(() => _readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    const json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
+    const agent = tryOrThrow(() => agentFileSchema.parse(json), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
+    return agent;
+}

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

@@ -0,0 +1,21 @@
+import { type ZodObject, type ZodType, z } from "zod";
+import type { Message } from "../agents/agent.js";
+export declare function loadAgentFromJsFile(path: string, { import: _import }?: {
+    import?: (path: string) => Promise<{
+        default: unknown;
+    }>;
+}): 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/esm/loader/function-agent.js

@@ -0,0 +1,31 @@
+import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
+import { z } from "zod";
+import { tryOrThrow } from "../utils/type-utils.js";
+import { inputOutputSchema } from "./schema.js";
+const agentJsFileSchema = z.object({
+    name: z.string(),
+    description: z
+        .string()
+        .nullish()
+        .transform((v) => v ?? undefined),
+    input_schema: inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? jsonSchemaToZod(v) : undefined)),
+    output_schema: inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? jsonSchemaToZod(v) : undefined)),
+    fn: z.function(),
+});
+export async function loadAgentFromJsFile(path, { import: _import } = {}) {
+    const { default: agent } = await tryOrThrow(() => (_import ? _import(path) : import(path)), (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 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/esm/loader/index.d.ts

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+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>[];
+}>;
+export declare function loadAgent(path: string): Promise<Agent>;
+export declare function loadAIGNEFile(path: string, { readFile: _readFile }?: {
+    readFile?: typeof readFile;
+}): Promise<{
+    tools?: string[] | null | undefined;
+    chat_model?: {
+        name?: string | null | undefined;
+        temperature?: number | 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/esm/loader/index.js

@@ -0,0 +1,88 @@
+import { readFile } from "node:fs/promises";
+import { dirname, extname, join } from "node:path";
+import { parse } from "yaml";
+import { z } from "zod";
+import { FunctionAgent } from "../agents/agent.js";
+import { AIAgent } from "../agents/ai-agent.js";
+import { OpenAIChatModel } from "../models/openai-chat-model.js";
+import { tryOrThrow } from "../utils/type-utils.js";
+import { loadAgentFromYamlFile } from "./ai-agent.js";
+import { loadAgentFromJsFile } from "./function-agent.js";
+const AIGNE_FILE_NAME = "aigne.yaml";
+export async function load(options) {
+    const { path } = options;
+    const aigneFilePath = path.endsWith(AIGNE_FILE_NAME) ? path : join(path, AIGNE_FILE_NAME);
+    const rootDir = dirname(aigneFilePath);
+    const aigne = await loadAIGNEFile(aigneFilePath);
+    const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent(join(rootDir, filename))));
+    const tools = await Promise.all((aigne.tools ?? []).map((filename) => loadAgent(join(rootDir, filename))));
+    return {
+        model: await loadModel(aigne.chat_model),
+        agents,
+        tools,
+    };
+}
+export async function loadAgent(path) {
+    if (extname(path) === ".js") {
+        const agent = await loadAgentFromJsFile(path);
+        return FunctionAgent.from({
+            name: agent.name,
+            description: agent.description,
+            inputSchema: agent.input_schema,
+            outputSchema: agent.output_schema,
+            fn: agent.fn,
+        });
+    }
+    if (extname(path) === ".yaml" || extname(path) === ".yml") {
+        const agent = await loadAgentFromYamlFile(path);
+        return 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(join(dirname(path), filename)))),
+        });
+    }
+    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,
+    };
+    // TODO: add support for other models such as AutoChatModel, ClaudeChatModel, etc.
+    if (/^o1|gpt-/.test(model.name)) {
+        return new OpenAIChatModel(params);
+    }
+    throw new Error(`Unsupported model: ${model.name}`);
+}
+const aigneFileSchema = z.object({
+    chat_model: z
+        .union([
+        z.string(),
+        z.object({
+            name: z.string().nullish(),
+            temperature: z.number().min(0).max(2).nullish(),
+            top_p: z.number().min(0).nullish(),
+            frequent_penalty: z.number().min(-2).max(2).nullish(),
+            presence_penalty: z.number().min(-2).max(2).nullish(),
+        }),
+    ])
+        .nullish()
+        .transform((v) => (typeof v === "string" ? { name: v } : v)),
+    agents: z.array(z.string()).nullish(),
+    tools: z.array(z.string()).nullish(),
+});
+export async function loadAIGNEFile(path, { readFile: _readFile = readFile } = {}) {
+    const raw = await tryOrThrow(() => _readFile(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
+    const json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse aigne.yaml from ${path}: ${error.message}`));
+    const agent = tryOrThrow(() => aigneFileSchema.parse(json), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
+    return agent;
+}

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

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const inputOutputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodAny>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    additionalProperties: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "object";
+    properties: Record<string, any>;
+    required?: string[] | undefined;
+    additionalProperties?: boolean | undefined;
+}, {
+    type: "object";
+    properties: Record<string, any>;
+    required?: string[] | undefined;
+    additionalProperties?: boolean | undefined;
+}>;

package/lib/esm/loader/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const inputOutputSchema = z.object({
+    type: z.literal("object"),
+    properties: z.record(z.any()),
+    required: z.array(z.string()).optional(),
+    additionalProperties: z.boolean().optional(),
+});

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

@@ -57,7 +57,7 @@ export declare const claudeChatModelOptionsSchema: z.ZodObject<{
 export declare class ClaudeChatModel extends ChatModel {
     options?: ClaudeChatModelOptions | undefined;
     constructor(options?: ClaudeChatModelOptions | undefined);
-    private _client?;
+    protected _client?: Anthropic;
     get client(): Anthropic;
     get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;

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

@@ -30,9 +30,10 @@ export class ClaudeChatModel extends ChatModel {
     }
     _client;
     get client() {
-        if (!this.options?.apiKey)
+        const apiKey = this.options?.apiKey || process.env.CLAUDE_API_KEY;
+        if (!apiKey)
             throw new Error("Api Key is required for ClaudeChatModel");
-        this._client ??= new Anthropic({ apiKey: this.options.apiKey });
+        this._client ??= new Anthropic({ apiKey });
         return this._client;
     }
     get modelOptions() {

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

@@ -61,7 +61,7 @@ export declare const openAIChatModelOptionsSchema: z.ZodObject<{
 export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);
-    private _client?;
+    protected _client?: OpenAI;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;

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

@@ -30,11 +30,12 @@ export class OpenAIChatModel extends ChatModel {
     }
     _client;
     get client() {
-        if (!this.options?.apiKey)
+        const apiKey = this.options?.apiKey || process.env.OPENAI_API_KEY;
+        if (!apiKey)
             throw new Error("Api Key is required for OpenAIChatModel");
         this._client ??= new OpenAI({
-            baseURL: this.options.baseURL,
-            apiKey: this.options.apiKey,
+            baseURL: this.options?.baseURL,
+            apiKey,
         });
         return this._client;
     }

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

@@ -1,3 +1,4 @@
+import OpenAI from "openai";
 import type { ChatModelOptions } from "./chat-model.js";
 import { OpenAIChatModel } from "./openai-chat-model.js";
 export interface XAIChatModelOptions {
@@ -8,4 +9,5 @@ export interface XAIChatModelOptions {
 }
 export declare class XAIChatModel extends OpenAIChatModel {
     constructor(options?: XAIChatModelOptions);
+    get client(): OpenAI;
 }

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

@@ -1,3 +1,4 @@
+import OpenAI from "openai";
 import { OpenAIChatModel } from "./openai-chat-model.js";
 const XAI_DEFAULT_CHAT_MODEL = "grok-2-latest";
 const XAI_BASE_URL = "https://api.x.ai/v1";
@@ -9,4 +10,14 @@ export class XAIChatModel extends OpenAIChatModel {
             baseURL: options?.baseURL || XAI_BASE_URL,
         });
     }
+    get client() {
+        const apiKey = this.options?.apiKey || process.env.XAI_API_KEY;
+        if (!apiKey)
+            throw new Error("Api Key is required for XAIChatModel");
+        this._client ??= new OpenAI({
+            baseURL: this.options?.baseURL,
+            apiKey,
+        });
+        return this._client;
+    }
 }

package/lib/esm/utils/json-schema.js

@@ -7,7 +7,7 @@ function setAdditionPropertiesDeep(schema, additionalProperties) {
     if (Array.isArray(schema)) {
         return schema.map((s) => setAdditionPropertiesDeep(s, additionalProperties));
     }
-    if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+    if (schema !== null && typeof schema === "object" && !Array.isArray(schema)) {
         return Object.entries(schema).reduce((acc, [key, value]) => {
             acc[key] = setAdditionPropertiesDeep(value, additionalProperties);
             if (acc.type === "object") {

package/lib/esm/utils/logger.d.ts

@@ -1,4 +1,5 @@
 import debug, { type Debugger } from "debug";
+import type { Ora } from "ora";
 interface DebugWithSpinner extends Debugger {
     spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void, options?: {
         disabled?: boolean;
@@ -10,9 +11,10 @@ export declare const logger: debug.Debug & {
     debug: debug.Debug;
     default: debug.Debug;
 } & {
-    globalSpinner: import("@aigne/ora").Ora;
+    globalSpinner: Ora | undefined;
     base: DebugWithSpinner;
     debug: DebugWithSpinner;
     spinner: typeof spinner;
+    setSpinner: (spinner: Ora) => void;
 };
 export {};

package/lib/esm/utils/logger.js

@@ -1,12 +1,11 @@
-import ora from "@aigne/ora";
 import debug from "debug";
 debug.log = (...args) => {
-    const { isSpinning } = globalSpinner;
+    const { isSpinning } = globalSpinner ?? {};
     if (isSpinning)
-        globalSpinner.stop();
+        globalSpinner?.stop();
     console.log(...args);
     if (isSpinning)
-        globalSpinner.start();
+        globalSpinner?.start();
 };
 function createDebugger(namespace) {
     const i = debug(namespace);
@@ -26,12 +25,12 @@ function createDebugger(namespace) {
     overrideExtend(i);
     return i;
 }
-const globalSpinner = ora();
+let globalSpinner;
 const globalSpinnerTasks = [];
 async function spinner(promise, message, callback) {
     const task = { promise, message, callback };
     globalSpinnerTasks.push(task);
-    globalSpinner.start(message || " ");
+    globalSpinner?.start(message || " ");
     await promise
         .then((result) => {
         task.result = result;
@@ -48,18 +47,18 @@ async function spinner(promise, message, callback) {
             break;
         // Recover spinner state for last running task
         if (!task.status) {
-            globalSpinner.start(task.message || " ");
+            globalSpinner?.start(task.message || " ");
             break;
         }
         globalSpinnerTasks.pop();
         if (task.message) {
             if (task.status === "fail")
-                globalSpinner.fail(task.message);
+                globalSpinner?.fail(task.message);
             else
-                globalSpinner.succeed(task.message);
+                globalSpinner?.succeed(task.message);
         }
         else {
-            globalSpinner.stop();
+            globalSpinner?.stop();
         }
         // NOTE: This is a workaround to make sure the spinner stops spinning before the next tick
         await new Promise((resolve) => setTimeout(resolve, 10));
@@ -74,4 +73,8 @@ export const logger = Object.assign(debug, {
     base,
     debug: base.extend("core"),
     spinner,
+    setSpinner: (spinner) => {
+        globalSpinner = spinner;
+        logger.globalSpinner = spinner;
+    },
 });

package/lib/esm/utils/mcp-utils.d.ts

@@ -1,6 +1,5 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { type ListPromptsResult, type ListResourceTemplatesResult, type ListResourcesResult, type ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
-import { MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.js";
-export declare function toolFromMCPTool(client: Client, tool: ListToolsResult["tools"][number]): MCPTool;
-export declare function promptFromMCPPrompt(client: Client, prompt: ListPromptsResult["prompts"][number]): MCPPrompt;
-export declare function resourceFromMCPResource(client: Client, resource: ListResourcesResult["resources"][number] | ListResourceTemplatesResult["resourceTemplates"][number]): MCPResource;
+import { type MCPBaseOptions, MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.js";
+export declare function toolFromMCPTool(tool: ListToolsResult["tools"][number], options: MCPBaseOptions): MCPTool;
+export declare function promptFromMCPPrompt(prompt: ListPromptsResult["prompts"][number], options: MCPBaseOptions): MCPPrompt;
+export declare function resourceFromMCPResource(resource: ListResourcesResult["resources"][number] | ListResourceTemplatesResult["resourceTemplates"][number], options: MCPBaseOptions): MCPResource;