@aigne/core 1.1.0-beta.6 → 1.3.0

package/CHANGELOG.md

@@ -1,3 +1,80 @@
+## [1.3.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.2.0...core-v1.3.0) (2025-03-24)
+
+
+### Features
+
+* add Agent FunctionAgent AIAgent MCPAgent and ExecutionEngine ([4d2a5a1](https://github.com/AIGNE-io/aigne-framework/commit/4d2a5a1b3366b8f935f50a0937c2da6e49073348))
+* add OrchestratorAgent in agent library ([25a5e9e](https://github.com/AIGNE-io/aigne-framework/commit/25a5e9e6c60d747c8bf484ac884b31dc02c14757))
+* add sequential and parallel helper function ([a295697](https://github.com/AIGNE-io/aigne-framework/commit/a295697b5694754e02954fc5c7f382a3b219a3ab))
+* add support for MCP resources ([1ded2fb](https://github.com/AIGNE-io/aigne-framework/commit/1ded2fbf222fa8984e75df0852ff384524f73b04))
+* **core:** add ChatModelClaude to use models of anthropic ([#30](https://github.com/AIGNE-io/aigne-framework/issues/30)) ([0a62a64](https://github.com/AIGNE-io/aigne-framework/commit/0a62a6499e3da723a4646e67952051708ce7de6a))
+* **core:** add support for subscribing topics for agent memory ([#28](https://github.com/AIGNE-io/aigne-framework/issues/28)) ([eeecc67](https://github.com/AIGNE-io/aigne-framework/commit/eeecc67049a60ebcc4cdba0fbcd987b3d81f4af6))
+* **prompt-builder:** support chat history in PromptBuilder ([6ca05f2](https://github.com/AIGNE-io/aigne-framework/commit/6ca05f28eddb683a4f1e228865f8bbf8a8e190f1))
+* support run puppeteer example chat loop in terminal ([85ce7f8](https://github.com/AIGNE-io/aigne-framework/commit/85ce7f8de8b443c86e50815dd7bcab99f869c4ce))
+* use PromptBuilder instead of string instructions ([e4cb2cb](https://github.com/AIGNE-io/aigne-framework/commit/e4cb2cb6baf4f9bcef390567a4a174e9246c29a3))
+
+
+### Bug Fixes
+
+* **AIAgent:** should pass both arguments (model generated) and input (user input) to tool ([c49d64e](https://github.com/AIGNE-io/aigne-framework/commit/c49d64ee35f7efd83b0f82f43205bb1c40f999e8))
+* **core:** enforce stricter input/output type checks ([#26](https://github.com/AIGNE-io/aigne-framework/issues/26)) ([ef8cf53](https://github.com/AIGNE-io/aigne-framework/commit/ef8cf53586aff08a809909c56ab2a20f215fa129))
+* **MCP:** catch list resource error treat as empty list ([1885fab](https://github.com/AIGNE-io/aigne-framework/commit/1885fab3585e0dd1467b127e5b47cd0b98282bab))
+* 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.2.0](https://github.com/AIGNE-io/aigne-framework/compare/core-next-v1.1.0...core-next-v1.2.0) (2025-03-18)
+
+- chore: release v1.2.0
+
+## 1.1.0-beta.17 (2025-3-18)
+
+- chore: add support for esm module
+
+
+## 1.1.0-beta.16 (2025-3-18)
+
+- chore: add puppeteer in linux need docker_container
+
+## 1.1.0-beta.15 (2025-3-18)
+
+- chore: make coverage report as text to terminal
+- chore: update contributing docs
+
+## 1.1.0-beta.14 (2025-3-18)
+
+- chore(example): add code-execution example
+
+## 1.1.0-beta.13 (2025-3-18)
+
+- feat: add OrchestratorAgent in agent library
+
+## 1.1.0-beta.12 (2025-3-14)
+
+- chore(example): add concurrency reflection handoff workflow examples
+
+## 1.1.0-beta.11 (2025-3-14)
+
+- feat(core): add sequential and parallel helper function
+- chore(examples): add workflow-sequential example
+
+## 1.1.0-beta.10 (2025-3-13)
+
+- chore: ensure required environment variables have values
+
+## 1.1.0-beta.9 (2025-3-13)
+
+- fix(MCP): catch list resource error treat as empty list
+
+## 1.1.0-beta.8 (2025-3-13)
+
+- fix(AIAgent): should pass both arguments (model generated) and input (user input) to tool
+- chore(examples): add workflow-router example
+- chore(examples): rename examples puppeteer-mcp-server and sqlite-mcp-server to mcp-server-puppeteer and mcp-server-sqlite
+
+## 1.1.0-beta.7 (2025-3-13)
+
+- chore: rename @aigne/core to @aigne/core
+
 ## 1.1.0-beta.6 (2025-3-13)
 
 - chore(examples): default enable mcp debug message for examples

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

@@ -1,57 +1,61 @@
-import EventEmitter from "node:events";
-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>;
+import { type ZodType } from "zod";
+import type { Context } from "../execution-engine/context.js";
+import { type Nullish, type PromiseOrValue } from "../utils/type-utils.js";
+import { AgentMemory, type AgentMemoryOptions } from "./memory.js";
+import { type TransferAgentOutput } from "./types.js";
+export type Message = Record<string, unknown>;
 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 type PublishTopic<O extends Message> = string | string[] | ((output: O) => PromiseOrValue<Nullish<string | string[]>>);
+export interface AgentOptions<I extends Message = Message, O extends Message = Message> {
     subscribeTopic?: SubscribeTopic;
     publishTopic?: PublishTopic<O>;
     name?: string;
     description?: string;
-    inputSchema?: ZodObject<{
-        [key in keyof I]: ZodType;
-    }>;
-    outputSchema?: ZodObject<{
-        [key in keyof O]: ZodType;
-    }>;
+    inputSchema?: ZodType<I>;
+    outputSchema?: ZodType<O>;
     includeInputInOutput?: boolean;
     tools?: (Agent | FunctionAgentFn)[];
     disableLogging?: boolean;
+    memory?: AgentMemory | AgentMemoryOptions | true;
 }
-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>);
+export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
+    constructor({ inputSchema, outputSchema, ...options }: AgentOptions<I, O>);
+    readonly memory?: AgentMemory;
     readonly name: string;
+    /**
+     * Default topic this agent will subscribe to
+     */
+    get topic(): string;
     readonly description?: string;
-    readonly inputSchema: ZodObject<{
-        [key in keyof I]: ZodType;
-    }>;
-    readonly outputSchema: ZodObject<{
-        [key in keyof O]: ZodType;
-    }>;
+    readonly inputSchema: ZodType<I>;
+    readonly outputSchema: ZodType<O>;
     readonly includeInputInOutput?: boolean;
     readonly subscribeTopic?: SubscribeTopic;
-    readonly publishTopic?: PublishTopic<AgentOutput>;
-    readonly tools: Agent<AgentInput, AgentOutput>[] & {
-        [key: string]: Agent<AgentInput, AgentOutput>;
+    readonly publishTopic?: PublishTopic<Message>;
+    readonly tools: Agent<Message, Message>[] & {
+        [key: string]: Agent<Message, Message>;
     };
     private disableLogging?;
-    addTool<I extends AgentInput, O extends AgentOutput>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
+    /**
+     * Attach agent to context:
+     * - subscribe to topic and call process method when message received
+     * - subscribe to memory topic if memory is enabled
+     * @param context Context to attach
+     */
+    attach(context: Context): void;
+    addTool<I extends Message, O extends Message>(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>;
+    abstract process(input: I, context?: Context): Promise<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
 }
-export interface FunctionAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     fn?: FunctionAgentFn<I, O>;
 }
-export declare class FunctionAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    static from<I extends AgentInput, O extends AgentOutput>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
+export declare class FunctionAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    static from<I extends Message, O extends Message>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
     constructor(options: FunctionAgentOptions<I, O>);
     fn: FunctionAgentFn<I, O>;
-    process(input: I, context?: Context): Promise<O>;
+    process(input: I, context?: Context): Promise<TransferAgentOutput | O>;
 }
-export type FunctionAgentFn<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> = (input: I, context?: Context) => O | Promise<O> | Agent | Promise<Agent>;
+export type FunctionAgentFn<I extends Message = Message, O extends Message = Message> = (input: I, context?: Context) => O | Promise<O> | Agent | Promise<Agent>;

package/lib/cjs/agents/agent.js

@@ -1,43 +1,72 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionAgent = exports.Agent = void 0;
-const node_events_1 = __importDefault(require("node:events"));
 const zod_1 = require("zod");
-const prompt_builder_1 = require("../prompt/prompt-builder");
-const logger_1 = require("../utils/logger");
-const type_utils_1 = require("../utils/type-utils");
-const types_1 = require("./types");
-class Agent extends node_events_1.default {
-    static from(options) {
-        return new Agent(options);
-    }
-    constructor(options) {
-        super();
+const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
+const logger_js_1 = require("../utils/logger.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const memory_js_1 = require("./memory.js");
+const types_js_1 = require("./types.js");
+class Agent {
+    constructor({ inputSchema, outputSchema, ...options }) {
         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({});
+        if ((inputSchema && !(inputSchema instanceof zod_1.ZodObject)) ||
+            (outputSchema && !(outputSchema instanceof zod_1.ZodObject))) {
+            throw new Error("inputSchema must be a Zod object");
+        }
+        this.inputSchema = (inputSchema || zod_1.z.object({})).passthrough();
+        this.outputSchema = (outputSchema || zod_1.z.object({})).passthrough();
         this.includeInputInOutput = options.includeInputInOutput;
         this.subscribeTopic = options.subscribeTopic;
         this.publishTopic = options.publishTopic;
         if (options.tools?.length)
             this.tools.push(...options.tools.map(functionToAgent));
         this.disableLogging = options.disableLogging;
+        if (options.memory) {
+            this.memory =
+                options.memory instanceof memory_js_1.AgentMemory
+                    ? options.memory
+                    : typeof options.memory === "boolean"
+                        ? new memory_js_1.AgentMemory({ enabled: options.memory })
+                        : new memory_js_1.AgentMemory(options.memory);
+        }
     }
+    memory;
     name;
+    /**
+     * Default topic this agent will subscribe to
+     */
+    get topic() {
+        return `$agent_${this.name}`;
+    }
     description;
     inputSchema;
     outputSchema;
     includeInputInOutput;
     subscribeTopic;
     publishTopic;
-    tools = (0, type_utils_1.createAccessorArray)([], (arr, name) => arr.find((t) => t.name === name));
+    tools = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((t) => t.name === name));
     disableLogging;
+    /**
+     * Attach agent to context:
+     * - subscribe to topic and call process method when message received
+     * - subscribe to memory topic if memory is enabled
+     * @param context Context to attach
+     */
+    attach(context) {
+        this.memory?.attach(context);
+        for (const topic of (0, type_utils_js_1.orArrayToArray)(this.subscribeTopic).concat(this.topic)) {
+            context.subscribe(topic, async ({ message }) => {
+                try {
+                    await context.call(this, message);
+                }
+                catch (error) {
+                    context.emit("error", error);
+                }
+            });
+        }
+    }
     addTool(tool) {
         this.tools.push(typeof tool === "function" ? functionToAgent(tool) : tool);
     }
@@ -45,17 +74,28 @@ class Agent extends node_events_1.default {
         return !!this.process;
     }
     async call(input, context) {
-        if (!this.process)
-            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);
-        const result = this.process(parsedInput, context).then((output) => {
-            const parsedOutput = this.outputSchema.passthrough().parse(output);
+        const _input = typeof input === "string" ? (0, prompt_builder_js_1.createMessage)(input) : input;
+        const parsedInput = this.inputSchema.parse(_input);
+        logger_js_1.logger.debug("Call agent %s start with input: %O", this.name, input);
+        const result = this.process(parsedInput, context)
+            .then((output) => {
+            const parsedOutput = this.outputSchema.parse(output);
             return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
+        })
+            .then((output) => {
+            this.memory?.addMemory({ role: "user", content: _input });
+            this.memory?.addMemory({
+                role: "agent",
+                content: (0, types_js_1.replaceTransferAgentToName)(output),
+                source: this.name,
+            });
+            return output;
         });
-        return logger_1.logger.debug.spinner(result, `Call agent ${this.name}`, (output) => logger_1.logger.debug("input: %O\noutput: %O", input, output), { disabled: this.disableLogging });
+        return logger_js_1.logger.debug.spinner(result, `Call agent ${this.name}`, (output) => logger_js_1.logger.debug("Call agent %s succeed with output: %O", this.name, (0, types_js_1.replaceTransferAgentToName)(output)), { disabled: this.disableLogging });
+    }
+    async shutdown() {
+        this.memory?.detach();
     }
-    async shutdown() { }
 }
 exports.Agent = Agent;
 class FunctionAgent extends Agent {
@@ -70,7 +110,7 @@ class FunctionAgent extends Agent {
     async process(input, context) {
         const result = await this.fn(input, context);
         if (result instanceof Agent) {
-            return (0, types_1.transferToAgentOutput)(result);
+            return (0, types_js_1.transferToAgentOutput)(result);
         }
         return result;
     }

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

@@ -1,24 +1,20 @@
-import type { Context } from "../execution-engine/context";
-import type { ChatModel } from "../models/chat";
-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> {
+import type { Context } from "../execution-engine/context.js";
+import type { ChatModel } from "../models/chat-model.js";
+import { PromptBuilder } from "../prompt/prompt-builder.js";
+import { Agent, type AgentOptions, type Message } from "./agent.js";
+export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     model?: ChatModel;
     instructions?: string | PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
-    enableHistory?: boolean;
-    maxHistoryMessages?: number;
 }
 export type AIAgentToolChoice = "auto" | "none" | "required" | "router" | Agent;
-export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    static from<I extends AgentInput, O extends AgentOutput>(options: AIAgentOptions<I, O>): AIAgent<I, O>;
+export declare class AIAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    static from<I extends Message, O extends Message>(options: AIAgentOptions<I, O>): AIAgent<I, O>;
     constructor(options: AIAgentOptions<I, O>);
     model?: ChatModel;
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
-    enableHistory?: boolean;
-    maxHistoryMessages: number;
-    process(input: I, context?: Context): Promise<O>;
+    process(input: I, context?: Context): Promise<import("./types.js").TransferAgentOutput | O>;
 }

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

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIAgent = void 0;
-const prompt_builder_1 = require("../prompt/prompt-builder");
-const template_1 = require("../prompt/template");
-const agent_1 = require("./agent");
-const types_1 = require("./types");
-const DEFAULT_OUTPUT_KEY = "text";
-const DEFAULT_MAX_HISTORY_MESSAGES = 10;
-class AIAgent extends agent_1.Agent {
+const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
+const template_js_1 = require("../prompt/template.js");
+const agent_js_1 = require("./agent.js");
+const types_js_1 = require("./types.js");
+class AIAgent extends agent_js_1.Agent {
     static from(options) {
         return new AIAgent(options);
     }
@@ -16,27 +14,22 @@ class AIAgent extends agent_1.Agent {
         this.model = options.model;
         this.instructions =
             typeof options.instructions === "string"
-                ? prompt_builder_1.PromptBuilder.from(options.instructions)
-                : (options.instructions ?? new prompt_builder_1.PromptBuilder());
+                ? prompt_builder_js_1.PromptBuilder.from(options.instructions)
+                : (options.instructions ?? new prompt_builder_js_1.PromptBuilder());
         this.outputKey = options.outputKey;
         this.toolChoice = options.toolChoice;
-        this.enableHistory = options.enableHistory;
-        this.maxHistoryMessages = options.maxHistoryMessages ?? DEFAULT_MAX_HISTORY_MESSAGES;
     }
     model;
     instructions;
     outputKey;
     toolChoice;
-    enableHistory;
-    maxHistoryMessages;
     async process(input, context) {
+        if (!context)
+            throw new Error("Context is required to run AIAgent");
         const model = context?.model ?? this.model;
         if (!model)
             throw new Error("model is required to run AIAgent");
-        let transferOutput;
         const { toolAgents, messages, ...modelInput } = await this.instructions.build({
-            enableHistory: this.enableHistory,
-            maxHistoryMessages: this.maxHistoryMessages,
             agent: this,
             input,
             model,
@@ -53,18 +46,17 @@ class AIAgent extends agent_1.Agent {
                     const tool = toolsMap.get(call.function.name);
                     if (!tool)
                         throw new Error(`Tool not found: ${call.function.name}`);
-                    const output = await tool.call(call.function.arguments, context);
-                    // Save the TransferAgentOutput for later
-                    if ((0, types_1.isTransferAgentOutput)(output)) {
-                        transferOutput = output;
-                    }
-                    else {
-                        executedToolCalls.push({ call, output });
+                    // NOTE: should pass both arguments (model generated) and input (user provided) to the tool
+                    const output = await tool.call({ ...call.function.arguments, ...input }, context);
+                    // NOTE: Return transfer output immediately
+                    if ((0, types_js_1.isTransferAgentOutput)(output)) {
+                        return output;
                     }
+                    executedToolCalls.push({ call, output });
                 }
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
-                    toolCallMessages.push(template_1.AgentMessageTemplate.from(executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => template_1.ToolMessageTemplate.from(output, call.id).format()));
+                    toolCallMessages.push(template_js_1.AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => template_js_1.ToolMessageTemplate.from(output, call.id).format()));
                     // Return the output of the first tool if the toolChoice is "router"
                     if (this.toolChoice === "router") {
                         const output = executedToolCalls[0]?.output;
@@ -77,23 +69,13 @@ class AIAgent extends agent_1.Agent {
                 }
             }
             const result = {};
-            if (json) {
-                this.instructions.addHistory(template_1.AgentMessageTemplate.from(JSON.stringify(json)).format());
-            }
-            else if (text) {
-                this.instructions.addHistory(template_1.AgentMessageTemplate.from(text).format());
-            }
             if (modelInput.responseFormat?.type === "json_schema") {
                 Object.assign(result, json);
             }
             else {
-                const outputKey = this.outputKey || DEFAULT_OUTPUT_KEY;
+                const outputKey = this.outputKey || prompt_builder_js_1.MESSAGE_KEY;
                 Object.assign(result, { [outputKey]: text });
             }
-            // Return the TransferAgentOutput if it exists
-            if (transferOutput) {
-                result[types_1.transferAgentOutputKey] = transferOutput[types_1.transferAgentOutputKey];
-            }
             return result;
         }
     }

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

@@ -1,10 +1,12 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { CallToolResult, GetPromptResult } from "@modelcontextprotocol/sdk/types";
-import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
+import type { CallToolResult, GetPromptResult, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import type { Context } from "../execution-engine/context.js";
+import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface MCPAgentOptions extends AgentOptions {
     client: Client;
     prompts?: MCPPrompt[];
+    resources?: MCPResource[];
 }
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
@@ -19,21 +21,35 @@ export declare class MCPAgent extends Agent {
     readonly prompts: MCPPrompt[] & {
         [key: string]: MCPPrompt;
     };
+    readonly resources: MCPResource[] & {
+        [key: string]: MCPResource;
+    };
+    get isCallable(): boolean;
+    process(_input: Message, _context?: Context): Promise<Message>;
     shutdown(): Promise<void>;
 }
-export interface MCPToolBaseOptions<I extends AgentInput, O extends AgentOutput> extends AgentOptions<I, O> {
+export interface MCPToolBaseOptions<I extends Message, O extends Message> extends AgentOptions<I, O> {
     client: Client;
 }
-export declare abstract class MCPBase<I extends AgentInput, O extends AgentOutput> extends Agent<I, O> {
+export declare abstract class MCPBase<I extends Message, O extends Message> extends Agent<I, O> {
     constructor(options: MCPToolBaseOptions<I, O>);
     protected client: Client;
     protected get mcpServer(): string | undefined;
 }
-export declare class MCPTool extends MCPBase<AgentInput, CallToolResult> {
-    process(input: AgentInput): Promise<CallToolResult>;
+export declare class MCPTool extends MCPBase<Message, CallToolResult> {
+    process(input: Message): Promise<CallToolResult>;
 }
-export declare class MCPPrompt extends MCPBase<{
+export interface MCPPromptInput extends Message {
     [key: string]: string;
-}, GetPromptResult> {
-    process(input: AgentInput): Promise<GetPromptResult>;
+}
+export declare class MCPPrompt extends MCPBase<MCPPromptInput, GetPromptResult> {
+    process(input: MCPPromptInput): Promise<GetPromptResult>;
+}
+export interface MCPResourceOptions extends MCPToolBaseOptions<MCPPromptInput, ReadResourceResult> {
+    uri: string;
+}
+export declare class MCPResource extends MCPBase<MCPPromptInput, ReadResourceResult> {
+    constructor(options: MCPResourceOptions);
+    uri: string;
+    process(input: MCPPromptInput): Promise<ReadResourceResult>;
 }

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

@@ -1,30 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPPrompt = exports.MCPTool = exports.MCPBase = exports.MCPAgent = void 0;
+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 logger_1 = require("../utils/logger");
-const mcp_utils_1 = require("../utils/mcp-utils");
-const type_utils_1 = require("../utils/type-utils");
-const agent_1 = require("./agent");
+const uriTemplate_js_1 = require("@modelcontextprotocol/sdk/shared/uriTemplate.js");
+const logger_js_1 = require("../utils/logger.js");
+const mcp_utils_js_1 = require("../utils/mcp-utils.js");
+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 debug = logger_1.logger.base.extend("mcp");
+const debug = logger_js_1.logger.base.extend("mcp");
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
 }
 function isStdioServerParameters(options) {
     return "command" in options && typeof options.command === "string";
 }
-class MCPAgent extends agent_1.Agent {
+class MCPAgent extends agent_js_1.Agent {
     static from(options) {
         if (isSSEServerParameters(options)) {
             const transport = new sse_js_1.SSEClientTransport(new URL(options.url));
             return MCPAgent.fromTransport(transport);
         }
         if (isStdioServerParameters(options)) {
-            const transport = new stdio_js_1.StdioClientTransport({ ...options, stderr: "pipe" });
+            const transport = new stdio_js_1.StdioClientTransport({
+                ...options,
+                env: {
+                    ...(0, stdio_js_1.getDefaultEnvironment)(),
+                    ...options.env,
+                },
+                stderr: "pipe",
+            });
             return MCPAgent.fromTransport(transport);
         }
         return new MCPAgent(options);
@@ -36,34 +44,60 @@ class MCPAgent extends agent_1.Agent {
         });
         await debug.spinner(client.connect(transport), "Connecting to MCP server");
         const mcpServer = getMCPServerName(client);
-        const { tools: isToolsAvailable, prompts: isPromptsAvailable } = client.getServerCapabilities() ?? {};
+        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_1.toolFromMCPTool)(client, tool)))
+                .then(({ tools }) => tools.map((tool) => (0, mcp_utils_js_1.toolFromMCPTool)(client, tool)))
             : 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_1.promptFromMCPPrompt)(client, prompt)))
+                .then(({ prompts }) => prompts.map((prompt) => (0, mcp_utils_js_1.promptFromMCPPrompt)(client, prompt)))
             : undefined;
-        return new MCPAgent({ client, tools, prompts });
+        const resources = isResourcesAvailable
+            ? await debug
+                .spinner(
+            // TODO: should conditionally call listResourceTemplates based on the server capabilities
+            // but the capability is not correct in the current SDK version
+            Promise.all([
+                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)))
+            : undefined;
+        return new MCPAgent({
+            name: client.getServerVersion()?.name,
+            client,
+            tools,
+            prompts,
+            resources,
+        });
     }
     constructor(options) {
         super(options);
         this.client = options.client;
         if (options.prompts?.length)
             this.prompts.push(...options.prompts);
+        if (options.resources?.length)
+            this.resources.push(...options.resources);
     }
     client;
-    prompts = (0, type_utils_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
+    prompts = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
+    resources = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
+    get isCallable() {
+        return false;
+    }
+    async process(_input, _context) {
+        throw new Error("Method not implemented.");
+    }
     async shutdown() {
         super.shutdown();
         await this.client.close();
     }
 }
 exports.MCPAgent = MCPAgent;
-class MCPBase extends agent_1.Agent {
+class MCPBase extends agent_js_1.Agent {
     constructor(options) {
         super(options);
         this.client = options.client;
@@ -88,6 +122,19 @@ class MCPPrompt extends MCPBase {
     }
 }
 exports.MCPPrompt = MCPPrompt;
+class MCPResource extends MCPBase {
+    constructor(options) {
+        super(options);
+        this.uri = options.uri;
+    }
+    uri;
+    async process(input) {
+        const uri = new uriTemplate_js_1.UriTemplate(this.uri).expand(input);
+        const result = await debug.spinner(this.client.readResource({ uri }), `Read resource ${this.name} from ${this.mcpServer}`, (output) => debug("input: %O\noutput: %O", input, output));
+        return result;
+    }
+}
+exports.MCPResource = MCPResource;
 function getMCPServerName(client) {
     const info = client.getServerVersion();
     if (!info)