@aigne/core 1.11.0 → 1.13.0

package/CHANGELOG.md

@@ -22,6 +22,34 @@
 * 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.13.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.12.0...core-v1.13.0) (2025-04-30)
+
+
+### Features
+
+* **core:** add BedrockChatModel support ([#101](https://github.com/AIGNE-io/aigne-framework/issues/101)) ([a0b98f0](https://github.com/AIGNE-io/aigne-framework/commit/a0b98f01bd78a135232226548848fa35a64982d1))
+
+
+### Bug Fixes
+
+* **core:** deduplicate tools for chat model ([#103](https://github.com/AIGNE-io/aigne-framework/issues/103)) ([570be6d](https://github.com/AIGNE-io/aigne-framework/commit/570be6d8620ab5b9a0149f835ecd4641009a8654))
+* export server/client api types ([93e5341](https://github.com/AIGNE-io/aigne-framework/commit/93e5341dde7a6851f08a3d4e2f6c1a1db91765e9))
+
+## [1.12.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.11.0...core-v1.12.0) (2025-04-27)
+
+
+### Features
+
+* add AIGNEServer/AIGNEClient api to serve agents via network ([#96](https://github.com/AIGNE-io/aigne-framework/issues/96)) ([1f2dfa3](https://github.com/AIGNE-io/aigne-framework/commit/1f2dfa3a6a2568373063cea3c874b573d0a248d3))
+* **core:** support streamable http transport for mcp agents ([#92](https://github.com/AIGNE-io/aigne-framework/issues/92)) ([37da490](https://github.com/AIGNE-io/aigne-framework/commit/37da490538298d882ec328e4b3304395a6cd8cf7))
+* support TeamAgent and finalize API naming ([#91](https://github.com/AIGNE-io/aigne-framework/issues/91)) ([033d1b6](https://github.com/AIGNE-io/aigne-framework/commit/033d1b6a7dc5460807476abb35a413ba89a2a664))
+
+
+### Bug Fixes
+
+* **core:** prioritize self model before falling back to context ([#97](https://github.com/AIGNE-io/aigne-framework/issues/97)) ([2a3d067](https://github.com/AIGNE-io/aigne-framework/commit/2a3d067442200657d8ef3b5314930cc14302f6bf))
+* upgrade to streamable api for serve mcp command ([#98](https://github.com/AIGNE-io/aigne-framework/issues/98)) ([ae32bda](https://github.com/AIGNE-io/aigne-framework/commit/ae32bda20e57c2a2eb8b49fad034b0b2a5ebb15e))
+
 ## [1.11.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.10.0...core-v1.11.0) (2025-04-23)
 
 

package/README.md

@@ -12,13 +12,13 @@ Core library of [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework) f
 
 ## Introduction
 
-`@aigne/core` is the foundation component of [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework), providing the essential modules and tools needed to build AI-driven applications. This package implements the core functionalities of the framework, including agent systems, execution engines, model integrations, and workflow pattern support.
+`@aigne/core` is the foundation component of [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework), providing the essential modules and tools needed to build AI-driven applications. This package implements the core functionalities of the framework, including agent systems, aigne environment, model integrations, and workflow pattern support.
 
 ## Features
 
 - **Multiple AI Model Support**: Built-in support for OpenAI, Gemini, Claude, and other mainstream AI models, easily extensible to support additional models
 - **Agent System**: Powerful agent abstractions supporting AI agents, function agents, MCP agents, and more
-- **Execution Engine**: Flexible execution engine handling communication between agents and workflow execution
+- **AIGNE Environment**: Flexible handling communication between agents and workflow execution
 - **Workflow Patterns**: Support for sequential, concurrent, routing, handoff, and other workflow patterns
 - **MCP Protocol Integration**: Seamless integration with external systems through the Model Context Protocol
 - **TypeScript Support**: Comprehensive type definitions providing an excellent development experience
@@ -39,7 +39,7 @@ pnpm add @aigne/core
 ## Basic Usage
 
 ```typescript
-import { AIAgent, ExecutionEngine } from "@aigne/core";
+import { AIAgent, AIGNE } from "@aigne/core";
 import { OpenAIChatModel } from "@aigne/core/models/openai-chat-model.js";
 
 // Create AI model instance
@@ -54,21 +54,21 @@ const agent = AIAgent.from({
   instructions: "You are a helpful assistant.",
 });
 
-// Create execution engine
-const engine = new ExecutionEngine({ model });
+// Create AIGNE
+const aigne = new AIGNE({ model });
 
-// Use the execution engine to call the agent
-const userAgent = await engine.call(agent);
+// Use the AIGNE to invoke the agent
+const userAgent = await aigne.invoke(agent);
 
 // Send a message to the agent
-const response = await userAgent.call("Hello, can you help me write a short article?");
+const response = await userAgent.invoke("Hello, can you help me write a short article?");
 console.log(response);
 ```
 
 ## Module Structure
 
 - `agents/`: Agent implementations, including AI agents, function agents, MCP agents, etc.
-- `execution-engine/`: Execution engine implementation
+- `aigne/`: AIGNE is agents execution environment
 - `loader/`: Loader-related functionality
 - `models/`: Integration with various AI models
 - `prompt/`: Prompt handling functionality
@@ -82,7 +82,8 @@ For more detailed API documentation, please refer to:
 - [AI Agent API](../../docs/apis/ai-agent-api.md)
 - [Function Agent API](../../docs/apis/function-agent-api.md)
 - [MCP Agent API](../../docs/apis/mcp-agent-api.md)
-- [Execution Engine API](../../docs/apis/execution-engine-api.md)
+- [AIGNE API](../../docs/apis/aigne-api.md)
+- [Server/Client API](../../docs/apis/server-client-api.md)
 
 ## License
 

package/README.zh.md

@@ -39,7 +39,7 @@ pnpm add @aigne/core
 ## 基本用法
 
 ```typescript
-import { AIAgent, ExecutionEngine } from "@aigne/core";
+import { AIAgent, AIGNE } from "@aigne/core";
 import { OpenAIChatModel } from "@aigne/core/models/openai-chat-model.js";
 
 // 创建 AI 模型实例
@@ -55,20 +55,20 @@ const agent = AIAgent.from({
 });
 
 // 创建执行引擎
-const engine = new ExecutionEngine({ model });
+const aigne = new AIGNE({ model });
 
 // 使用执行引擎调用代理
-const userAgent = await engine.call(agent);
+const userAgent = await aigne.invoke(agent);
 
 // 向代理发送消息
-const response = await userAgent.call("你好，能帮我写一篇短文吗？");
+const response = await userAgent.invoke("你好，能帮我写一篇短文吗？");
 console.log(response);
 ```
 
 ## 模块结构
 
 - `agents/`: 代理相关的实现，包括 AI 代理、函数代理、MCP 代理等
-- `execution-engine/`: 执行引擎的实现
+- `aigne/`: AIGNE 提供 Agents 执行环境
 - `loader/`: 加载器相关功能
 - `models/`: 各种 AI 模型的集成
 - `prompt/`: 提示词处理相关功能
@@ -82,7 +82,8 @@ console.log(response);
 - [AI Agent API](../../docs/apis/ai-agent-api.zh.md)
 - [Function Agent API](../../docs/apis/function-agent-api.zh.md)
 - [MCP Agent API](../../docs/apis/mcp-agent-api.zh.md)
-- [Execution Engine API](../../docs/apis/execution-engine-api.zh.md)
+- [AIGNE API](../../docs/apis/aigne-api.zh.md)
+- [服务器/客户端 API](../../docs/apis/server-client-api.zh.md)
 
 ## 协议
 

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

@@ -1,6 +1,6 @@
 import { inspect } from "node:util";
 import { type ZodType } from "zod";
-import type { Context } from "../execution-engine/context.js";
+import type { Context } from "../aigne/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";
@@ -15,11 +15,11 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
     inputSchema?: AgentInputOutputSchema<I>;
     outputSchema?: AgentInputOutputSchema<O>;
     includeInputInOutput?: boolean;
-    tools?: (Agent | FunctionAgentFn)[];
+    skills?: (Agent | FunctionAgentFn)[];
     disableEvents?: boolean;
     memory?: AgentMemory | AgentMemoryOptions | true;
 }
-export interface AgentCallOptions {
+export interface AgentInvokeOptions {
     streaming?: boolean;
 }
 export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
@@ -38,38 +38,38 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     readonly includeInputInOutput?: boolean;
     readonly subscribeTopic?: SubscribeTopic;
     readonly publishTopic?: PublishTopic<Message>;
-    readonly tools: Agent<Message, Message>[] & {
+    readonly skills: Agent<Message, Message>[] & {
         [key: string]: Agent<Message, Message>;
     };
     private disableEvents?;
     /**
      * Attach agent to context:
-     * - subscribe to topic and call process method when message received
+     * - subscribe to topic and invoke process method when message received
      * - subscribe to memory topic if memory is enabled
      * @param context Context to attach
      */
     attach(context: Pick<Context, "subscribe">): void;
-    addTool<I extends Message, O extends Message>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
-    get isCallable(): boolean;
+    addSkill(...skills: (Agent | FunctionAgentFn)[]): void;
+    get isInvokable(): boolean;
     private checkContextStatus;
     private newDefaultContext;
-    call(input: I | string, context: Context | undefined, options: AgentCallOptions & {
+    invoke(input: I | string, context: Context | undefined, options: AgentInvokeOptions & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
-    call(input: I | string, context?: Context, options?: AgentCallOptions & {
+    invoke(input: I | string, context?: Context, options?: AgentInvokeOptions & {
         streaming?: false;
     }): Promise<O>;
-    call(input: I | string, context?: Context, options?: AgentCallOptions): Promise<AgentResponse<O>>;
+    invoke(input: I | string, context?: Context, options?: AgentInvokeOptions): Promise<AgentResponse<O>>;
     private processAgentOutput;
     private processAgentError;
-    protected checkUsageAgentCalls(context: Context): void;
+    protected checkAgentInvokesUsage(context: Context): void;
     protected preprocess(_: I, context: Context): void;
     protected postprocess(input: I, output: O, context: Context): void;
-    abstract process(input: I, context: Context, options?: AgentCallOptions): AgentProcessResult<O | TransferAgentOutput>;
+    abstract process(input: I, context: Context, options?: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
     shutdown(): Promise<void>;
     [inspect.custom](): string;
 }
-export type AgentResponse<T> = T | AgentResponseStream<T>;
+export type AgentResponse<T> = T | TransferAgentOutput | AgentResponseStream<T>;
 export type AgentResponseStream<T> = ReadableStream<AgentResponseChunk<T>>;
 export type AgentResponseChunk<T> = AgentResponseDelta<T>;
 export declare function isEmptyChunk<T>(chunk: AgentResponseChunk<T>): boolean;
@@ -77,14 +77,14 @@ export interface AgentResponseDelta<T> {
     delta: {
         text?: Partial<{
             [key in keyof T as Extract<T[key], string> extends string ? key : never]: string;
-        }> | {
+        }> | Partial<{
             [key: string]: string;
-        };
-        json?: Partial<T>;
+        }>;
+        json?: Partial<T | TransferAgentOutput>;
     };
 }
-export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O> | undefined | void>;
-export type AgentProcessResult<O extends Message> = Promise<AgentResponse<O>> | AgentProcessAsyncGenerator<O>;
+export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O | TransferAgentOutput> | undefined | void>;
+export type AgentProcessResult<O extends Message> = AgentResponse<O> | AgentProcessAsyncGenerator<O> | Agent;
 export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
 export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     fn?: FunctionAgentFn<I, O>;
@@ -93,6 +93,6 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
     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, options?: AgentCallOptions): Promise<AgentResponse<O | TransferAgentOutput>>;
+    process(input: I, context: Context): PromiseOrValue<AgentProcessResult<O>>;
 }
-export type FunctionAgentFn<I extends Message = Message, O extends Message = Message> = (input: I, context: Context) => O | Promise<O> | Agent | Promise<Agent>;
+export type FunctionAgentFn<I extends Message = any, O extends Message = any> = (input: I, context: Context) => PromiseOrValue<AgentProcessResult<O>>;

package/lib/cjs/agents/agent.js

@@ -56,8 +56,8 @@ class Agent {
         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));
         this.disableEvents = options.disableEvents;
         if (options.memory) {
             this.memory =
@@ -94,11 +94,11 @@ class Agent {
     includeInputInOutput;
     subscribeTopic;
     publishTopic;
-    tools = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((t) => t.name === name));
+    skills = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((t) => t.name === name));
     disableEvents;
     /**
      * Attach agent to context:
-     * - subscribe to topic and call process method when message received
+     * - subscribe to topic and invoke process method when message received
      * - subscribe to memory topic if memory is enabled
      * @param context Context to attach
      */
@@ -107,7 +107,7 @@ class Agent {
         for (const topic of (0, type_utils_js_1.orArrayToArray)(this.subscribeTopic).concat(this.topic)) {
             context.subscribe(topic, async ({ message, context }) => {
                 try {
-                    await context.call(this, message);
+                    await context.invoke(this, message);
                 }
                 catch (error) {
                     context.emit("agentFailed", { agent: this, error });
@@ -115,34 +115,37 @@ class Agent {
             });
         }
     }
-    addTool(tool) {
-        this.tools.push(typeof tool === "function" ? functionToAgent(tool) : tool);
+    addSkill(...skills) {
+        this.skills.push(...skills.map((skill) => (typeof skill === "function" ? functionToAgent(skill) : skill)));
     }
-    get isCallable() {
+    get isInvokable() {
         return !!this.process;
     }
     checkContextStatus(context) {
         if (context) {
             const { status } = context;
             if (status === "timeout") {
-                throw new Error(`ExecutionEngine for agent ${this.name} has timed out`);
+                throw new Error(`AIGNE for agent ${this.name} has timed out`);
             }
         }
     }
     async newDefaultContext() {
-        return Promise.resolve().then(() => __importStar(require("../execution-engine/context.js"))).then((m) => new m.ExecutionContext());
+        return Promise.resolve().then(() => __importStar(require("../aigne/context.js"))).then((m) => new m.AIGNEContext());
     }
-    async call(input, context, options) {
+    async invoke(input, context, options) {
         const ctx = context ?? (await this.newDefaultContext());
         const message = typeof input === "string" ? (0, prompt_builder_js_1.createMessage)(input) : input;
-        logger_js_1.logger.core("Call agent %s started with input: %O", this.name, input);
+        logger_js_1.logger.core("Invoke agent %s started with input: %O", this.name, input);
         if (!this.disableEvents)
             ctx.emit("agentStarted", { agent: this, input: message });
         try {
             const parsedInput = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} input`, this.inputSchema, message);
             this.preprocess(parsedInput, ctx);
             this.checkContextStatus(ctx);
-            const response = await this.process(parsedInput, ctx, options);
+            let response = await this.process(parsedInput, ctx, options);
+            if (response instanceof Agent) {
+                response = (0, types_js_1.transferToAgentOutput)(response);
+            }
             if (options?.streaming) {
                 const stream = response instanceof ReadableStream
                     ? response
@@ -176,27 +179,27 @@ class Agent {
         const parsedOutput = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} output`, this.outputSchema, output);
         const finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
         this.postprocess(input, finalOutput, context);
-        logger_js_1.logger.core("Call agent %s succeed with output: %O", this.name, finalOutput);
+        logger_js_1.logger.core("Invoke agent %s succeed with output: %O", this.name, finalOutput);
         if (!this.disableEvents)
             context.emit("agentSucceed", { agent: this, output: finalOutput });
         return finalOutput;
     }
     processAgentError(error, context) {
-        logger_js_1.logger.core("Call agent %s failed with error: %O", this.name, error);
+        logger_js_1.logger.core("Invoke agent %s failed with error: %O", this.name, error);
         if (!this.disableEvents)
             context.emit("agentFailed", { agent: this, error });
         throw error;
     }
-    checkUsageAgentCalls(context) {
+    checkAgentInvokesUsage(context) {
         const { limits, usage } = context;
-        if (limits?.maxAgentCalls && usage.agentCalls >= limits.maxAgentCalls) {
-            throw new Error(`Exceeded max agent calls ${usage.agentCalls}/${limits.maxAgentCalls}`);
+        if (limits?.maxAgentInvokes && usage.agentCalls >= limits.maxAgentInvokes) {
+            throw new Error(`Exceeded max agent invokes ${usage.agentCalls}/${limits.maxAgentInvokes}`);
         }
         usage.agentCalls++;
     }
     preprocess(_, context) {
         this.checkContextStatus(context);
-        this.checkUsageAgentCalls(context);
+        this.checkAgentInvokesUsage(context);
     }
     postprocess(input, output, context) {
         this.checkContextStatus(context);
@@ -220,7 +223,7 @@ function isEmptyChunk(chunk) {
 }
 function checkAgentInputOutputSchema(schema) {
     if (!(schema instanceof zod_1.ZodObject) && typeof schema !== "function") {
-        throw new Error("schema must be a zod object or function return a zod object ");
+        throw new Error(`schema must be a zod object or function return a zod object, got: ${typeof schema}`);
     }
 }
 class FunctionAgent extends Agent {
@@ -232,12 +235,8 @@ class FunctionAgent extends Agent {
         this.fn = options.fn ?? (() => ({}));
     }
     fn;
-    async process(input, context, options) {
-        let result = await this.fn(input, context);
-        if (result instanceof Agent) {
-            result = (0, types_js_1.transferToAgentOutput)(result);
-        }
-        return options?.streaming ? (0, stream_utils_js_1.objectToAgentResponseStream)(result) : result;
+    process(input, context) {
+        return this.fn(input, context);
     }
 }
 exports.FunctionAgent = FunctionAgent;

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

@@ -1,10 +1,9 @@
 import { z } from "zod";
-import type { Context } from "../execution-engine/context.js";
+import type { Context } from "../aigne/context.js";
 import { ChatModel } from "../models/chat-model.js";
 import type { ChatModelInput } from "../models/chat-model.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { Agent, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
-import { type TransferAgentOutput } from "./types.js";
 export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     model?: ChatModel;
     instructions?: string | PromptBuilder;
@@ -25,39 +24,39 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     publishTopic: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>]>>;
     name: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
-    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodType<Agent<Message, Message>, z.ZodTypeDef, Agent<Message, Message>>, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>]>, "many">>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodType<Agent<Message, Message>, z.ZodTypeDef, Agent<Message, Message>>, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>]>, "many">>;
     disableLogging: z.ZodOptional<z.ZodBoolean>;
     memory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodAny, z.ZodAny]>>;
 }, "strip", z.ZodTypeAny, {
-    tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
-    toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
-    name?: string | undefined;
     description?: string | undefined;
+    memory?: any;
+    name?: string | undefined;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
+    skills?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
+    toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     model?: ChatModel | undefined;
     instructions?: string | PromptBuilder | undefined;
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
+    disableLogging?: boolean | undefined;
+}, {
+    description?: string | undefined;
+    memory?: any;
+    name?: string | undefined;
     includeInputInOutput?: boolean | undefined;
     subscribeTopic?: string | string[] | undefined;
     publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
-    disableLogging?: boolean | undefined;
-    memory?: any;
-}, {
-    tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
+    skills?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
     toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
-    name?: string | undefined;
-    description?: string | undefined;
     model?: ChatModel | undefined;
     instructions?: string | PromptBuilder | undefined;
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
-    includeInputInOutput?: boolean | undefined;
-    subscribeTopic?: string | string[] | undefined;
-    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     disableLogging?: boolean | undefined;
-    memory?: any;
 }>;
 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>;
@@ -66,6 +65,6 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
-    process(input: I, context: Context): AgentProcessAsyncGenerator<O | TransferAgentOutput>;
-    processRouter(input: I, model: ChatModel, modelInput: ChatModelInput, context: Context, toolsMap: Map<string, Agent>): AgentProcessAsyncGenerator<O | TransferAgentOutput>;
+    process(input: I, context: Context): AgentProcessAsyncGenerator<O>;
+    processRouter(input: I, model: ChatModel, modelInput: ChatModelInput, context: Context, toolsMap: Map<string, Agent>): AgentProcessAsyncGenerator<O>;
 }

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

@@ -28,7 +28,7 @@ exports.aiAgentOptionsSchema = zod_1.z.object({
     publishTopic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string()), zod_1.z.function()]).optional(),
     name: zod_1.z.string().optional(),
     description: zod_1.z.string().optional(),
-    tools: zod_1.z.array(zod_1.z.union([zod_1.z.instanceof(agent_js_1.Agent), zod_1.z.function()])).optional(),
+    skills: zod_1.z.array(zod_1.z.union([zod_1.z.instanceof(agent_js_1.Agent), zod_1.z.function()])).optional(),
     disableLogging: zod_1.z.boolean().optional(),
     memory: zod_1.z.union([zod_1.z.boolean(), zod_1.z.any(), zod_1.z.any()]).optional(),
 });
@@ -52,7 +52,7 @@ class AIAgent extends agent_js_1.Agent {
     outputKey;
     toolChoice;
     async *process(input, context) {
-        const model = context.model ?? this.model;
+        const model = this.model ?? context.model;
         if (!model)
             throw new Error("model is required to run AIAgent");
         const { toolAgents, ...modelInput } = await this.instructions.build({
@@ -70,7 +70,7 @@ class AIAgent extends agent_js_1.Agent {
         const outputKey = this.outputKey || prompt_builder_js_1.MESSAGE_KEY;
         for (;;) {
             const modelOutput = {};
-            const stream = await context.call(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
+            const stream = await context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
             for await (const value of (0, stream_utils_js_1.readableStreamToAsyncIterator)(stream)) {
                 if (value.delta.text?.text) {
                     yield { delta: { text: { [outputKey]: value.delta.text.text } } };
@@ -88,7 +88,7 @@ class AIAgent extends agent_js_1.Agent {
                     if (!tool)
                         throw new Error(`Tool not found: ${call.function.name}`);
                     // NOTE: should pass both arguments (model generated) and input (user provided) to the tool
-                    const output = await context.call(tool, { ...call.function.arguments, ...input }, { disableTransfer: true });
+                    const output = await context.invoke(tool, { ...call.function.arguments, ...input }, { disableTransfer: true });
                     // NOTE: Return transfer output immediately
                     if ((0, types_js_1.isTransferAgentOutput)(output)) {
                         return output;
@@ -115,14 +115,14 @@ class AIAgent extends agent_js_1.Agent {
         }
     }
     async *processRouter(input, model, modelInput, context, toolsMap) {
-        const { toolCalls: [call] = [], } = await context.call(model, modelInput);
+        const { toolCalls: [call] = [], } = await context.invoke(model, modelInput);
         if (!call) {
             throw new Error("Router toolChoice requires exactly one tool to be executed");
         }
         const tool = toolsMap.get(call.function.name);
         if (!tool)
             throw new Error(`Tool not found: ${call.function.name}`);
-        const stream = await context.call(tool, { ...call.function.arguments, ...input }, { streaming: true });
+        const stream = await context.invoke(tool, { ...call.function.arguments, ...input }, { streaming: true });
         yield* (0, stream_utils_js_1.readableStreamToAsyncIterator)(stream);
     }
 }

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

@@ -1,11 +1,12 @@
 import { Client, type ClientOptions } from "@modelcontextprotocol/sdk/client/index.js";
 import { type SSEClientTransportOptions } from "@modelcontextprotocol/sdk/client/sse.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { type StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.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 { Context } from "../aigne/context.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
 import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface MCPAgentOptions extends AgentOptions {
@@ -17,9 +18,14 @@ export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
     url: string;
     /**
-     * Additional options to pass to the SSEClientTransport.
+     * Whether to use the StreamableHTTPClientTransport instead of the SSEClientTransport.
+     * @default "sse"
      */
-    opts?: SSEClientTransportOptions;
+    transport?: "sse" | "streamableHttp";
+    /**
+     * Additional options to pass to the SSEClientTransport or StreamableHTTPClientTransport.
+     */
+    opts?: SSEClientTransportOptions | StreamableHTTPClientTransportOptions;
     /**
      * The timeout for requests to the server, in milliseconds.
      * @default 60000
@@ -48,7 +54,7 @@ export declare class MCPAgent extends Agent {
     readonly resources: MCPResource[] & {
         [key: string]: MCPResource;
     };
-    get isCallable(): boolean;
+    get isInvokable(): boolean;
     process(_input: Message, _context?: Context): Promise<Message>;
     shutdown(): Promise<void>;
 }

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

@@ -7,6 +7,7 @@ exports.MCPResource = exports.MCPPrompt = exports.MCPTool = exports.MCPBase = ex
 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 streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
 const uriTemplate_js_1 = require("@modelcontextprotocol/sdk/shared/uriTemplate.js");
 const p_retry_1 = __importDefault(require("p-retry"));
 const zod_1 = require("zod");
@@ -14,8 +15,8 @@ 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 MCP_AGENT_CLIENT_NAME = "AIGNE/MCPAgent";
+const MCP_AGENT_CLIENT_VERSION = "1.10.0"; // This should match the version in package.json
 const DEFAULT_MAX_RECONNECTS = 10;
 const DEFAULT_TIMEOUT = () => zod_1.z.coerce
     .number()
@@ -41,7 +42,12 @@ class MCPAgent extends agent_js_1.Agent {
     static from(options) {
         (0, type_utils_js_1.checkArguments)("MCPAgent.from", mcpAgentOptionsSchema, options);
         if (isSSEServerParameters(options)) {
-            const transport = () => new sse_js_1.SSEClientTransport(new URL(options.url), options.opts);
+            const transport = () => {
+                if (options.transport === "streamableHttp") {
+                    return new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(options.url), options.opts);
+                }
+                return new sse_js_1.SSEClientTransport(new URL(options.url), options.opts);
+            };
             return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
@@ -68,7 +74,7 @@ class MCPAgent extends agent_js_1.Agent {
         const mcpServer = getMCPServerName(client);
         const { tools: isToolsAvailable, prompts: isPromptsAvailable, resources: isResourcesAvailable, } = client.getServerCapabilities() ?? {};
         logger_js_1.logger.mcp(`Listing tools from ${mcpServer}`);
-        const tools = isToolsAvailable
+        const skills = isToolsAvailable
             ? await client.listTools().then(({ tools }) => {
                 logger_js_1.logger.mcp(`Listing tools from ${mcpServer} completed %O`, tools?.map((i) => i.name));
                 return tools.map((tool) => (0, mcp_utils_js_1.toolFromMCPTool)(tool, { client }));
@@ -97,7 +103,7 @@ class MCPAgent extends agent_js_1.Agent {
         return new MCPAgent({
             name: client.getServerVersion()?.name,
             client,
-            tools,
+            skills,
             prompts,
             resources,
         });
@@ -113,7 +119,7 @@ class MCPAgent extends agent_js_1.Agent {
     client;
     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() {
+    get isInvokable() {
         return false;
     }
     async process(_input, _context) {

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

@@ -1,4 +1,4 @@
-import type { Context } from "../execution-engine/context.js";
+import type { Context } from "../aigne/context.js";
 import type { Message } from "./agent.js";
 export interface AgentMemoryOptions {
     /**

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

@@ -0,0 +1,28 @@
+import type { Context } from "../aigne/context.js";
+import { type PromiseOrValue } from "../utils/type-utils.js";
+import { Agent, type AgentOptions, type AgentProcessResult, type Message } from "./agent.js";
+export declare enum ProcessMode {
+    /**
+     * Process the agents one by one, passing the output of each agent to the next.
+     */
+    sequential = "sequential",
+    /**
+     * Process all agents in parallel, merging the output of all agents.
+     */
+    parallel = "parallel"
+}
+export interface TeamAgentOptions<I extends Message, O extends Message> extends AgentOptions<I, O> {
+    /**
+     * The method to process the agents in the team.
+     * @default {ProcessMode.sequential}
+     */
+    mode?: ProcessMode;
+}
+export declare class TeamAgent<I extends Message, O extends Message> extends Agent<I, O> {
+    static from<I extends Message, O extends Message>(options: TeamAgentOptions<I, O>): TeamAgent<I, O>;
+    constructor(options: TeamAgentOptions<I, O>);
+    mode: ProcessMode;
+    process(input: I, context: Context): PromiseOrValue<AgentProcessResult<O>>;
+    _processSequential(input: I, context: Context): PromiseOrValue<AgentProcessResult<O>>;
+    _processParallel(input: I, context: Context): PromiseOrValue<AgentProcessResult<O>>;
+}