@aigne/core 1.1.0-beta.1 → 1.1.0-beta.2

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

@@ -1,41 +1,47 @@
 import EventEmitter from "node:events";
-import { type ZodObject } from "zod";
+import { type ZodObject, type ZodType } from "zod";
 import type { Context } from "../execution-engine/context";
 import { type TransferAgentOutput } from "./types";
 export type AgentInput = Record<string, unknown>;
 export type AgentOutput = Record<string, unknown> & Partial<TransferAgentOutput>;
 export type SubscribeTopic = string | string[];
 export type PublishTopic<O extends AgentOutput = AgentOutput> = string | string[] | ((output: O) => string | string[] | Promise<string | string[]>);
-export interface AgentOptions<_I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> {
+export interface AgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> {
     subscribeTopic?: SubscribeTopic;
     publishTopic?: PublishTopic<O>;
     name?: string;
     description?: string;
-    inputSchema?: ZodObject<any>;
-    outputSchema?: ZodObject<any>;
+    inputSchema?: ZodObject<{
+        [key in keyof I]: ZodType;
+    }>;
+    outputSchema?: ZodObject<{
+        [key in keyof O]: ZodType;
+    }>;
     includeInputInOutput?: boolean;
     tools?: (Agent | FunctionAgentFn)[];
-    skills?: (Agent | FunctionAgentFn)[];
 }
 export declare class Agent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends EventEmitter {
     static from<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput>(options: AgentOptions<I, O>): Agent<I, O>;
     constructor(options: AgentOptions<I, O>);
-    name: string;
-    description?: string;
-    inputSchema: ZodObject<any>;
-    outputSchema: ZodObject<any>;
-    includeInputInOutput?: boolean;
-    subscribeTopic?: SubscribeTopic;
-    publishTopic?: PublishTopic<any>;
-    readonly tools: Agent[];
-    readonly skills: {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: ZodObject<{
+        [key in keyof I]: ZodType;
+    }>;
+    readonly outputSchema: ZodObject<{
+        [key in keyof O]: ZodType;
+    }>;
+    readonly includeInputInOutput?: boolean;
+    readonly subscribeTopic?: SubscribeTopic;
+    readonly publishTopic?: PublishTopic<AgentOutput>;
+    readonly tools: Agent<AgentInput, AgentOutput>[] & {
         [key: string]: Agent<AgentInput, AgentOutput>;
-    } & Agent<AgentInput, AgentOutput>[];
-    addSkill<I extends AgentInput, O extends AgentOutput>(skill: Agent<I, O> | FunctionAgentFn<I, O>): void;
+    };
+    addTool<I extends AgentInput, O extends AgentOutput>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
     get isCallable(): boolean;
     call(input: I | string, context?: Context): Promise<O>;
     process?(input: I, context?: Context): Promise<O>;
-    destroy(): Promise<void>;
+    shutdown(): Promise<void>;
 }
 export interface FunctionAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
     fn?: FunctionAgentFn<I, O>;

package/lib/cjs/agents/agent.js

@@ -17,15 +17,15 @@ class Agent extends node_events_1.default {
         super();
         this.name = options.name || this.constructor.name;
         this.description = options.description;
-        this.inputSchema = options.inputSchema || zod_1.z.object({});
-        this.outputSchema = options.outputSchema || zod_1.z.object({});
+        this.inputSchema =
+            options.inputSchema || zod_1.z.object({});
+        this.outputSchema =
+            options.outputSchema || zod_1.z.object({});
         this.includeInputInOutput = options.includeInputInOutput;
         this.subscribeTopic = options.subscribeTopic;
         this.publishTopic = options.publishTopic;
         if (options.tools?.length)
             this.tools.push(...options.tools.map(functionToAgent));
-        if (options.skills?.length)
-            this.skills.push(...options.skills.map(functionToAgent));
     }
     name;
     description;
@@ -34,14 +34,11 @@ class Agent extends node_events_1.default {
     includeInputInOutput;
     subscribeTopic;
     publishTopic;
-    tools = [];
-    skills = new Proxy([], {
-        get: (target, p, receiver) => {
-            return Reflect.get(target, p, receiver) ?? target.find((i) => i.name === p);
-        },
+    tools = new Proxy([], {
+        get: (t, p, r) => Reflect.get(t, p, r) ?? t.find((t) => t.name === p),
     });
-    addSkill(skill) {
-        this.skills.push(typeof skill === "function" ? functionToAgent(skill) : skill);
+    addTool(tool) {
+        this.tools.push(typeof tool === "function" ? functionToAgent(tool) : tool);
     }
     get isCallable() {
         return !!this.process;
@@ -51,19 +48,21 @@ class Agent extends node_events_1.default {
             throw new Error("Agent must implement process method");
         const _input = typeof input === "string" ? (0, prompt_builder_1.userInput)(input) : input;
         const parsedInput = this.inputSchema.passthrough().parse(_input);
-        logger_1.logger.debug(`Agent ${this.name} (${this.constructor.name}) start`, parsedInput);
+        logger_1.logger.debug(`Call agent ${this.name} start`, parsedInput);
         const output = await this.process(parsedInput, context);
         const parsedOutput = this.outputSchema.passthrough().parse(output);
         const finalOutput = this.includeInputInOutput
             ? { ...parsedInput, ...parsedOutput }
             : parsedOutput;
-        logger_1.logger.debug(`Agent ${this.name} (${this.constructor.name}) end`, {
+        logger_1.logger.debug(`Call agent ${this.name} successfully`, {
             ...finalOutput,
-            [types_1.transferAgentOutputKey]: finalOutput[types_1.transferAgentOutputKey]?.agent?.name,
+            ...(finalOutput[types_1.transferAgentOutputKey]
+                ? { [types_1.transferAgentOutputKey]: finalOutput[types_1.transferAgentOutputKey].agent.name }
+                : {}),
         });
         return finalOutput;
     }
-    async destroy() { }
+    async shutdown() { }
 }
 exports.Agent = Agent;
 class FunctionAgent extends Agent {

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

@@ -4,7 +4,7 @@ import { PromptBuilder } from "../prompt/prompt-builder";
 import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
 export interface AIAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
     model?: ChatModel;
-    instructions?: string;
+    instructions?: string | PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
 }
@@ -13,8 +13,7 @@ export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentO
     static from<I extends AgentInput, O extends AgentOutput>(options: AIAgentOptions<I, O>): AIAgent<I, O>;
     constructor(options: AIAgentOptions<I, O>);
     model?: ChatModel;
-    promptBuilder: PromptBuilder;
-    instructions?: string;
+    instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
     process(input: I, context?: Context): Promise<O>;

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

@@ -13,12 +13,14 @@ class AIAgent extends agent_1.Agent {
     constructor(options) {
         super(options);
         this.model = options.model;
-        this.instructions = options.instructions;
+        this.instructions =
+            typeof options.instructions === "string"
+                ? prompt_builder_1.PromptBuilder.from(options.instructions)
+                : (options.instructions ?? new prompt_builder_1.PromptBuilder());
         this.outputKey = options.outputKey;
         this.toolChoice = options.toolChoice;
     }
     model;
-    promptBuilder = new prompt_builder_1.PromptBuilder();
     instructions;
     outputKey;
     toolChoice;
@@ -27,13 +29,13 @@ class AIAgent extends agent_1.Agent {
         if (!model)
             throw new Error("model is required to run AIAgent");
         let transferOutput;
-        const { toolAgents, ...modelInput } = await this.promptBuilder.build({
+        const { toolAgents, ...modelInput } = await this.instructions.build({
             agent: this,
             input,
             model,
             context,
         });
-        const toolsMap = new Map(toolAgents.map((i) => [i.name, i]));
+        const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
         for (;;) {
             const { text, json, toolCalls } = await model.call(modelInput, context);
             if (toolCalls?.length) {

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

@@ -14,7 +14,7 @@ export declare class MCPAgent extends Agent {
     private static fromTransport;
     constructor(options: MCPAgentOptions);
     private client;
-    destroy(): Promise<void>;
+    shutdown(): Promise<void>;
 }
 export interface MCPToolOptions extends AgentOptions {
     client: Client;
@@ -22,5 +22,6 @@ export interface MCPToolOptions extends AgentOptions {
 export declare class MCPTool extends Agent {
     constructor(options: MCPToolOptions);
     private client;
+    private get mcpServer();
     process(input: AgentInput): Promise<AgentOutput>;
 }

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

@@ -6,9 +6,11 @@ const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
 const json_schema_to_zod_1 = require("@n8n/json-schema-to-zod");
 const zod_1 = require("zod");
+const logger_1 = require("../utils/logger");
 const agent_1 = require("./agent");
 const MCP_AGENT_CLIENT_NAME = "MCPAgent";
 const MCP_AGENT_CLIENT_VERSION = "0.0.1";
+const debug = logger_1.logger.base.extend("mcp-agent:debug", "/");
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
 }
@@ -32,9 +34,14 @@ class MCPAgent extends agent_1.Agent {
             name: MCP_AGENT_CLIENT_NAME,
             version: MCP_AGENT_CLIENT_VERSION,
         });
+        debug(`Connecting to MCP server with transport ${transport.constructor.name}`);
         await client.connect(transport);
+        debug(`Connected to MCP server with transport ${transport.constructor.name}`);
+        const mcpServer = getMCPServerName(client);
+        debug(`Listing tools from ${mcpServer}`);
         const { tools: mcpTools } = await client.listTools();
-        const skills = mcpTools.map((tool) => {
+        debug(`Listed tools from ${mcpServer}`, mcpTools.map((i) => i.name));
+        const tools = mcpTools.map((tool) => {
             return new MCPTool({
                 client,
                 name: tool.name,
@@ -49,15 +56,15 @@ class MCPAgent extends agent_1.Agent {
                     .passthrough(),
             });
         });
-        return new MCPAgent({ client, skills });
+        return new MCPAgent({ client, tools });
     }
     constructor(options) {
         super(options);
         this.client = options.client;
     }
     client;
-    async destroy() {
-        super.destroy();
+    async shutdown() {
+        super.shutdown();
         await this.client.close();
     }
 }
@@ -68,8 +75,21 @@ class MCPTool extends agent_1.Agent {
         this.client = options.client;
     }
     client;
+    get mcpServer() {
+        return getMCPServerName(this.client);
+    }
     async process(input) {
-        return await this.client.callTool({ name: this.name, arguments: input });
+        debug(`Start call tool ${this.name} from ${this.mcpServer} with input`, input);
+        const result = await this.client.callTool({ name: this.name, arguments: input });
+        debug(`End call tool ${this.name} from ${this.mcpServer} with result`, result);
+        return result;
     }
 }
 exports.MCPTool = MCPTool;
+function getMCPServerName(client) {
+    const info = client.getServerVersion();
+    if (!info)
+        return undefined;
+    const { name, version } = info;
+    return `${name}@${version}`;
+}

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

@@ -32,13 +32,13 @@ export declare class ExecutionEngine extends EventEmitter implements Context {
     private publishUserInputTopic;
     private runChatLoop;
     private callAgent;
-    destroy(): Promise<void>;
+    shutdown(): Promise<void>;
 }
 export declare class UserAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    options: AgentOptions & {
+    options: AgentOptions<I, O> & {
         run: (input: I) => Promise<O>;
     };
-    constructor(options: AgentOptions & {
+    constructor(options: AgentOptions<I, O> & {
         run: (input: I) => Promise<O>;
     });
     process(input: I): Promise<O>;

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

@@ -167,12 +167,12 @@ class ExecutionEngine extends node_events_1.default {
             output,
         };
     }
-    async destroy() {
+    async shutdown() {
         for (const tool of this.tools) {
-            await tool.destroy();
+            await tool.shutdown();
         }
         for (const agent of this.agents) {
-            await agent.destroy();
+            await agent.shutdown();
         }
     }
 }

package/lib/cjs/models/chat-openai.d.ts

@@ -1,12 +1,12 @@
 import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat";
 export declare class ChatModelOpenAI extends ChatModel {
     config?: {
-        apiKey: string;
-        model: string;
+        apiKey?: string;
+        model?: string;
     } | undefined;
     constructor(config?: {
-        apiKey: string;
-        model: string;
+        apiKey?: string;
+        model?: string;
     } | undefined);
     private _client?;
     private get client();

package/lib/cjs/models/chat-openai.js

@@ -56,6 +56,8 @@ class ChatModelOpenAI extends chat_1.ChatModel {
                         args: "",
                     };
                     const c = toolCalls[call.index];
+                    if (!c)
+                        throw new Error("Tool call not found");
                     if (call.type)
                         c.type = call.type;
                     c.function.name = c.function.name + (call.function?.name || "");
@@ -146,9 +148,10 @@ function jsonSchemaToOpenAIJsonSchema(schema) {
         };
     }
     if (schema?.type === "array") {
+        const { items } = schema;
         return {
             ...schema,
-            items: jsonSchemaToOpenAIJsonSchema(schema.items),
+            items: jsonSchemaToOpenAIJsonSchema(items),
         };
     }
     return schema;

package/lib/cjs/models/chat.d.ts

@@ -37,7 +37,7 @@ export type ChatModelInputResponseFormat = {
     jsonSchema: {
         name: string;
         description?: string;
-        schema: object;
+        schema: Record<string, unknown>;
         strict?: boolean;
     };
 };

package/lib/cjs/prompt/prompt-builder.d.ts

@@ -3,21 +3,30 @@ import type { AIAgent } from "../agents/ai-agent";
 import type { Context } from "../execution-engine/context";
 import type { ChatModel, ChatModelInput, ChatModelInputMessage } from "../models/chat";
 export declare const USER_INPUT_MESSAGE_KEY = "$user_input_message";
-export declare function userInput(message: string | object): {
-    $user_input_message: string | object;
-};
-export declare function addMessagesToInput(input: AgentInput, messages: ChatModelInputMessage[]): {
-    $user_input_message: ChatModelInputMessage[];
-};
+export declare function userInput(message: string | object): AgentInput;
+export declare function addMessagesToInput(input: AgentInput, messages: ChatModelInputMessage[]): AgentInput;
+export interface PromptBuilderOptions {
+    instructions?: string;
+}
 export interface PromptBuilderBuildOptions {
     context?: Context;
-    agent: AIAgent;
-    input: AgentInput;
+    agent?: AIAgent;
+    input?: AgentInput;
     model?: ChatModel;
 }
 export declare class PromptBuilder {
+    static from(instructions: string): PromptBuilder;
+    static from(instructions: {
+        path: string;
+    }): Promise<PromptBuilder>;
+    static from(instructions: string | {
+        path: string;
+    }): PromptBuilder | Promise<PromptBuilder>;
+    private static fromFile;
+    constructor(options?: PromptBuilderOptions);
+    instructions?: string;
     build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
-        toolAgents: Agent[];
+        toolAgents?: Agent[];
     }>;
     private buildMessages;
     private buildResponseFormat;

package/lib/cjs/prompt/prompt-builder.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptBuilder = exports.USER_INPUT_MESSAGE_KEY = void 0;
 exports.userInput = userInput;
 exports.addMessagesToInput = addMessagesToInput;
+const promises_1 = require("node:fs/promises");
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 const agent_1 = require("../agents/agent");
 const template_1 = require("./template");
-const instructions_1 = require("./templates/instructions");
 exports.USER_INPUT_MESSAGE_KEY = "$user_input_message";
 function userInput(message) {
     return { [exports.USER_INPUT_MESSAGE_KEY]: message };
@@ -35,6 +35,20 @@ function addMessagesToInput(input, messages) {
     return { ...input, [exports.USER_INPUT_MESSAGE_KEY]: newMessages };
 }
 class PromptBuilder {
+    static from(instructions) {
+        if (typeof instructions === "string") {
+            return new PromptBuilder({ instructions });
+        }
+        return PromptBuilder.fromFile(instructions.path);
+    }
+    static async fromFile(path) {
+        const text = await (0, promises_1.readFile)(path, "utf-8");
+        return PromptBuilder.from(text);
+    }
+    constructor(options) {
+        this.instructions = options?.instructions;
+    }
+    instructions;
     async build(options) {
         return {
             messages: this.buildMessages(options),
@@ -43,13 +57,11 @@ class PromptBuilder {
         };
     }
     buildMessages(options) {
-        const { agent, input } = options;
+        const { input } = options;
         const template = template_1.ChatMessagesTemplate.from([]);
-        template.messages.push(template_1.SystemMessageTemplate.from(template_1.PromptTemplate.from(instructions_1.DEFAULT_INSTRUCTIONS_TEMPLATE).format({
-            name: agent.name,
-            instructions: agent.instructions,
-        })));
-        const userInputMessage = input[exports.USER_INPUT_MESSAGE_KEY];
+        if (this.instructions)
+            template.messages.push(template_1.SystemMessageTemplate.from(this.instructions));
+        const userInputMessage = input?.[exports.USER_INPUT_MESSAGE_KEY];
         if (typeof userInputMessage === "string") {
             template.messages.push(template_1.UserMessageTemplate.from(userInputMessage));
         }
@@ -63,7 +75,9 @@ class PromptBuilder {
         return template.format(input);
     }
     buildResponseFormat(options) {
-        const { outputSchema } = options.agent;
+        const outputSchema = options.agent?.outputSchema;
+        if (!outputSchema)
+            return undefined;
         const isJsonOutput = !isEmptyObjectType(outputSchema);
         return isJsonOutput
             ? {
@@ -77,10 +91,10 @@ class PromptBuilder {
             : undefined;
     }
     buildTools(options) {
-        const toolAgents = options.agent.tools
-            .concat(options.context?.tools ?? [])
-            // TODO: support nested tools in the agent skills?
-            .flatMap((i) => (i.isCallable ? i.skills.concat(i) : i.skills));
+        const toolAgents = (options.context?.tools ?? [])
+            .concat(options.agent?.tools ?? [])
+            // TODO: support nested tools?
+            .flatMap((i) => (i.isCallable ? i.tools.concat(i) : i.tools));
         const tools = toolAgents.map((i) => ({
             type: "function",
             function: {
@@ -91,7 +105,7 @@ class PromptBuilder {
         }));
         let toolChoice;
         // use manual choice if configured in the agent
-        const { toolChoice: manualChoice } = options.agent;
+        const manualChoice = options.agent?.toolChoice;
         if (manualChoice) {
             if (manualChoice instanceof agent_1.Agent) {
                 toolChoice = {
@@ -114,8 +128,8 @@ class PromptBuilder {
             toolChoice = tools.length ? "auto" : undefined;
         }
         return {
-            toolAgents,
-            tools,
+            toolAgents: toolAgents.length ? toolAgents : undefined,
+            tools: tools.length ? tools : undefined,
             toolChoice,
         };
     }

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

@@ -1,3 +1,6 @@
-type Logger = Pick<typeof console, "debug" | "info" | "warn" | "error">;
-export declare const logger: Logger;
-export {};
+import debug from "debug";
+export declare const logger: {
+    base: debug.Debugger;
+    debug: debug.Debugger;
+    error: debug.Debugger;
+};

package/lib/cjs/utils/logger.js

@@ -1,15 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
-function logLevel() {
-    return process.env.LOG_LEVEL || "info";
-}
-function createLogger(logger, level = logLevel()) {
-    return {
-        debug: level === "debug" ? logger.debug : () => { },
-        info: level === "debug" || level === "info" ? logger.info : () => { },
-        warn: level === "debug" || level === "info" || level === "warn" ? logger.warn : () => { },
-        error: logger.error,
-    };
-}
-exports.logger = createLogger(console);
+const debug_1 = __importDefault(require("debug"));
+exports.logger = {
+    base: (0, debug_1.default)("@aigne/core"),
+    debug: (0, debug_1.default)("@aigne/core:debug"),
+    error: (0, debug_1.default)("@aigne/core:error"),
+};

package/lib/dts/agents/agent.d.ts

@@ -1,41 +1,47 @@
 import EventEmitter from "node:events";
-import { type ZodObject } from "zod";
+import { type ZodObject, type ZodType } from "zod";
 import type { Context } from "../execution-engine/context";
 import { type TransferAgentOutput } from "./types";
 export type AgentInput = Record<string, unknown>;
 export type AgentOutput = Record<string, unknown> & Partial<TransferAgentOutput>;
 export type SubscribeTopic = string | string[];
 export type PublishTopic<O extends AgentOutput = AgentOutput> = string | string[] | ((output: O) => string | string[] | Promise<string | string[]>);
-export interface AgentOptions<_I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> {
+export interface AgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> {
     subscribeTopic?: SubscribeTopic;
     publishTopic?: PublishTopic<O>;
     name?: string;
     description?: string;
-    inputSchema?: ZodObject<any>;
-    outputSchema?: ZodObject<any>;
+    inputSchema?: ZodObject<{
+        [key in keyof I]: ZodType;
+    }>;
+    outputSchema?: ZodObject<{
+        [key in keyof O]: ZodType;
+    }>;
     includeInputInOutput?: boolean;
     tools?: (Agent | FunctionAgentFn)[];
-    skills?: (Agent | FunctionAgentFn)[];
 }
 export declare class Agent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends EventEmitter {
     static from<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput>(options: AgentOptions<I, O>): Agent<I, O>;
     constructor(options: AgentOptions<I, O>);
-    name: string;
-    description?: string;
-    inputSchema: ZodObject<any>;
-    outputSchema: ZodObject<any>;
-    includeInputInOutput?: boolean;
-    subscribeTopic?: SubscribeTopic;
-    publishTopic?: PublishTopic<any>;
-    readonly tools: Agent[];
-    readonly skills: {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: ZodObject<{
+        [key in keyof I]: ZodType;
+    }>;
+    readonly outputSchema: ZodObject<{
+        [key in keyof O]: ZodType;
+    }>;
+    readonly includeInputInOutput?: boolean;
+    readonly subscribeTopic?: SubscribeTopic;
+    readonly publishTopic?: PublishTopic<AgentOutput>;
+    readonly tools: Agent<AgentInput, AgentOutput>[] & {
         [key: string]: Agent<AgentInput, AgentOutput>;
-    } & Agent<AgentInput, AgentOutput>[];
-    addSkill<I extends AgentInput, O extends AgentOutput>(skill: Agent<I, O> | FunctionAgentFn<I, O>): void;
+    };
+    addTool<I extends AgentInput, O extends AgentOutput>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
     get isCallable(): boolean;
     call(input: I | string, context?: Context): Promise<O>;
     process?(input: I, context?: Context): Promise<O>;
-    destroy(): Promise<void>;
+    shutdown(): Promise<void>;
 }
 export interface FunctionAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
     fn?: FunctionAgentFn<I, O>;

package/lib/dts/agents/ai-agent.d.ts

@@ -4,7 +4,7 @@ import { PromptBuilder } from "../prompt/prompt-builder";
 import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
 export interface AIAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
     model?: ChatModel;
-    instructions?: string;
+    instructions?: string | PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
 }
@@ -13,8 +13,7 @@ export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentO
     static from<I extends AgentInput, O extends AgentOutput>(options: AIAgentOptions<I, O>): AIAgent<I, O>;
     constructor(options: AIAgentOptions<I, O>);
     model?: ChatModel;
-    promptBuilder: PromptBuilder;
-    instructions?: string;
+    instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
     process(input: I, context?: Context): Promise<O>;

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

@@ -14,7 +14,7 @@ export declare class MCPAgent extends Agent {
     private static fromTransport;
     constructor(options: MCPAgentOptions);
     private client;
-    destroy(): Promise<void>;
+    shutdown(): Promise<void>;
 }
 export interface MCPToolOptions extends AgentOptions {
     client: Client;
@@ -22,5 +22,6 @@ export interface MCPToolOptions extends AgentOptions {
 export declare class MCPTool extends Agent {
     constructor(options: MCPToolOptions);
     private client;
+    private get mcpServer();
     process(input: AgentInput): Promise<AgentOutput>;
 }

package/lib/dts/execution-engine/index.d.ts

@@ -32,13 +32,13 @@ export declare class ExecutionEngine extends EventEmitter implements Context {
     private publishUserInputTopic;
     private runChatLoop;
     private callAgent;
-    destroy(): Promise<void>;
+    shutdown(): Promise<void>;
 }
 export declare class UserAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    options: AgentOptions & {
+    options: AgentOptions<I, O> & {
         run: (input: I) => Promise<O>;
     };
-    constructor(options: AgentOptions & {
+    constructor(options: AgentOptions<I, O> & {
         run: (input: I) => Promise<O>;
     });
     process(input: I): Promise<O>;