@aigne/core 1.5.1-1 → 1.6.0

package/lib/cjs/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/cjs/loader/schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputOutputSchema = void 0;
+const zod_1 = require("zod");
+exports.inputOutputSchema = zod_1.z.object({
+    type: zod_1.z.literal("object"),
+    properties: zod_1.z.record(zod_1.z.any()),
+    required: zod_1.z.array(zod_1.z.string()).optional(),
+    additionalProperties: zod_1.z.boolean().optional(),
+});

package/lib/cjs/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/cjs/models/claude-chat-model.js

@@ -36,9 +36,10 @@ class ClaudeChatModel extends chat_model_js_1.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 sdk_1.default({ apiKey: this.options.apiKey });
+        this._client ??= new sdk_1.default({ apiKey });
         return this._client;
     }
     get modelOptions() {

package/lib/cjs/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/cjs/models/openai-chat-model.js

@@ -36,11 +36,12 @@ class OpenAIChatModel extends chat_model_js_1.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_1.default({
-            baseURL: this.options.baseURL,
-            apiKey: this.options.apiKey,
+            baseURL: this.options?.baseURL,
+            apiKey,
         });
         return this._client;
     }

package/lib/cjs/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/cjs/models/xai-chat-model.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XAIChatModel = void 0;
+const openai_1 = __importDefault(require("openai"));
 const openai_chat_model_js_1 = require("./openai-chat-model.js");
 const XAI_DEFAULT_CHAT_MODEL = "grok-2-latest";
 const XAI_BASE_URL = "https://api.x.ai/v1";
@@ -12,5 +16,15 @@ class XAIChatModel extends openai_chat_model_js_1.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_1.default({
+            baseURL: this.options?.baseURL,
+            apiKey,
+        });
+        return this._client;
+    }
 }
 exports.XAIChatModel = XAIChatModel;

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

@@ -12,7 +12,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/cjs/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/cjs/utils/logger.js

@@ -4,15 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
-const ora_1 = __importDefault(require("@aigne/ora"));
 const debug_1 = __importDefault(require("debug"));
 debug_1.default.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 = (0, debug_1.default)(namespace);
@@ -32,12 +31,12 @@ function createDebugger(namespace) {
     overrideExtend(i);
     return i;
 }
-const globalSpinner = (0, ora_1.default)();
+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;
@@ -54,18 +53,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));
@@ -80,4 +79,8 @@ exports.logger = Object.assign(debug_1.default, {
     base,
     debug: base.extend("core"),
     spinner,
+    setSpinner: (spinner) => {
+        globalSpinner = spinner;
+        exports.logger.globalSpinner = spinner;
+    },
 });

package/lib/cjs/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;

package/lib/cjs/utils/mcp-utils.js

@@ -8,18 +8,18 @@ const uriTemplate_js_1 = require("@modelcontextprotocol/sdk/shared/uriTemplate.j
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const zod_1 = require("zod");
 const mcp_agent_js_1 = require("../agents/mcp-agent.js");
-function toolFromMCPTool(client, tool) {
+function toolFromMCPTool(tool, options) {
     return new mcp_agent_js_1.MCPTool({
-        client,
+        ...options,
         name: tool.name,
         description: tool.description,
         inputSchema: (0, json_schema_to_zod_1.jsonSchemaToZod)(tool.inputSchema),
         outputSchema: types_js_1.CallToolResultSchema,
     });
 }
-function promptFromMCPPrompt(client, prompt) {
+function promptFromMCPPrompt(prompt, options) {
     return new mcp_agent_js_1.MCPPrompt({
-        client,
+        ...options,
         name: prompt.name,
         description: prompt.description,
         inputSchema: (0, json_schema_to_zod_1.jsonSchemaToZod)({
@@ -31,7 +31,7 @@ function promptFromMCPPrompt(client, prompt) {
         outputSchema: types_js_1.GetPromptResultSchema,
     });
 }
-function resourceFromMCPResource(client, resource) {
+function resourceFromMCPResource(resource, options) {
     const [uri, variables] = isResourceTemplate(resource)
         ? [
             resource.uriTemplate,
@@ -40,7 +40,7 @@ function resourceFromMCPResource(client, resource) {
         ]
         : [resource.uri, []];
     return new mcp_agent_js_1.MCPResource({
-        client,
+        ...options,
         name: resource.name,
         uri,
         description: resource.description,

package/lib/cjs/utils/run-chat-loop.js

@@ -5,8 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runChatLoopInTerminal = runChatLoopInTerminal;
 const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
 const logger_js_1 = require("./logger.js");
 async function runChatLoopInTerminal(userAgent, { log = console.log.bind(console), ...options } = {}) {
+    logger_js_1.logger.setSpinner((0, ora_1.default)());
     let isLoopExited = false;
     let prompt;
     if (options?.welcome)
@@ -19,7 +21,7 @@ async function runChatLoopInTerminal(userAgent, { log = console.log.bind(console
             if (isLoopExited)
                 return;
             if (options?.onResponse)
-                options.onResponse(output);
+                options.onResponse(output.message);
             else
                 log(output);
             prompt?.ui.close();

package/lib/cjs/utils/type-utils.d.ts

@@ -5,8 +5,10 @@ export declare function isNil(value: unknown): value is null | undefined;
 export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
 export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
+export declare function duplicates<T>(arr: T[], key?: (item: T) => unknown): T[];
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };
 export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): void;
+export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;

package/lib/cjs/utils/type-utils.js

@@ -4,9 +4,11 @@ exports.isNil = isNil;
 exports.isEmpty = isEmpty;
 exports.isNonNullable = isNonNullable;
 exports.isNotEmpty = isNotEmpty;
+exports.duplicates = duplicates;
 exports.orArrayToArray = orArrayToArray;
 exports.createAccessorArray = createAccessorArray;
 exports.checkArguments = checkArguments;
+exports.tryOrThrow = tryOrThrow;
 const zod_1 = require("zod");
 function isNil(value) {
     return value === null || value === undefined;
@@ -17,7 +19,7 @@ function isEmpty(obj) {
     if (typeof obj === "string" || Array.isArray(obj))
         return obj.length === 0;
     if (typeof obj === "object")
-        Object.keys(obj).length === 0;
+        return Object.keys(obj).length === 0;
     return false;
 }
 function isNonNullable(value) {
@@ -26,6 +28,20 @@ function isNonNullable(value) {
 function isNotEmpty(arr) {
     return arr.length > 0;
 }
+function duplicates(arr, key = (item) => item) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const item of arr) {
+        const k = key(item);
+        if (seen.has(k)) {
+            duplicates.add(item);
+        }
+        else {
+            seen.add(k);
+        }
+    }
+    return Array.from(duplicates);
+}
 function orArrayToArray(value) {
     if (isNil(value))
         return [];
@@ -78,3 +94,24 @@ function checkArguments(prefix, schema, args) {
         throw error;
     }
 }
+function tryOrThrow(fn, error) {
+    const createError = (e) => {
+        return typeof error === "function"
+            ? error(e)
+            : typeof error === "string"
+                ? new Error(error)
+                : error;
+    };
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            return result.catch((e) => {
+                throw createError(e);
+            });
+        }
+        return result;
+    }
+    catch (e) {
+        throw createError(e);
+    }
+}

package/lib/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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;

package/lib/dts/utils/type-utils.d.ts

@@ -5,8 +5,10 @@ export declare function isNil(value: unknown): value is null | undefined;
 export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
 export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
+export declare function duplicates<T>(arr: T[], key?: (item: T) => unknown): T[];
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };
 export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): void;
+export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;