@aigne/core 1.10.0 → 1.12.0

package/lib/esm/agents/agent.js

@@ -3,7 +3,7 @@ import { ZodObject, z } from "zod";
 import { createMessage } from "../prompt/prompt-builder.js";
 import { logger } from "../utils/logger.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, isAsyncGenerator, objectToAgentResponseStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
-import { checkArguments, createAccessorArray, orArrayToArray, } from "../utils/type-utils.js";
+import { checkArguments, createAccessorArray, isEmpty, orArrayToArray, } from "../utils/type-utils.js";
 import { AgentMemory } from "./memory.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
 export class Agent {
@@ -19,8 +19,8 @@ export 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 =
@@ -57,11 +57,11 @@ export class Agent {
     includeInputInOutput;
     subscribeTopic;
     publishTopic;
-    tools = createAccessorArray([], (arr, name) => arr.find((t) => t.name === name));
+    skills = 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
      */
@@ -70,7 +70,7 @@ export class Agent {
         for (const topic of 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 });
@@ -78,34 +78,37 @@ export 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 import("../execution-engine/context.js").then((m) => new m.ExecutionContext());
+        return import("../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" ? createMessage(input) : input;
-        logger.core("Call agent %s started with input: %O", this.name, input);
+        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 = 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 = transferToAgentOutput(response);
+            }
             if (options?.streaming) {
                 const stream = response instanceof ReadableStream
                     ? response
@@ -139,27 +142,27 @@ export class Agent {
         const parsedOutput = checkArguments(`Agent ${this.name} output`, this.outputSchema, output);
         const finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
         this.postprocess(input, finalOutput, context);
-        logger.core("Call agent %s succeed with output: %O", this.name, finalOutput);
+        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.core("Call agent %s failed with error: %O", this.name, error);
+        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);
@@ -177,9 +180,12 @@ export class Agent {
         return this.name;
     }
 }
+export function isEmptyChunk(chunk) {
+    return isEmpty(chunk.delta.json) && isEmpty(chunk.delta.text);
+}
 function checkAgentInputOutputSchema(schema) {
     if (!(schema instanceof 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}`);
     }
 }
 export class FunctionAgent extends Agent {
@@ -191,12 +197,8 @@ export 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 = transferToAgentOutput(result);
-        }
-        return options?.streaming ? objectToAgentResponseStream(result) : result;
+    process(input, context) {
+        return this.fn(input, context);
     }
 }
 function functionToAgent(agent) {

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

@@ -1,9 +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;
@@ -24,18 +24,18 @@ 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, {
     description?: string | undefined;
     memory?: any;
+    name?: string | undefined;
     includeInputInOutput?: boolean | undefined;
     subscribeTopic?: string | string[] | undefined;
     publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
-    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;
     model?: ChatModel | undefined;
     instructions?: string | PromptBuilder | undefined;
     outputKey?: string | undefined;
@@ -45,12 +45,12 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
 }, {
     description?: string | undefined;
     memory?: any;
+    name?: string | undefined;
     includeInputInOutput?: boolean | undefined;
     subscribeTopic?: string | string[] | undefined;
     publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
-    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;
     model?: ChatModel | undefined;
     instructions?: string | PromptBuilder | undefined;
     outputKey?: string | undefined;
@@ -65,5 +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>;
+    process(input: I, context: Context): AgentProcessAsyncGenerator<O>;
+    processRouter(input: I, model: ChatModel, modelInput: ChatModelInput, context: Context, toolsMap: Map<string, Agent>): AgentProcessAsyncGenerator<O>;
 }

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

@@ -25,7 +25,7 @@ export const aiAgentOptionsSchema = z.object({
     publishTopic: z.union([z.string(), z.array(z.string()), z.function()]).optional(),
     name: z.string().optional(),
     description: z.string().optional(),
-    tools: z.array(z.union([z.instanceof(Agent), z.function()])).optional(),
+    skills: z.array(z.union([z.instanceof(Agent), z.function()])).optional(),
     disableLogging: z.boolean().optional(),
     memory: z.union([z.boolean(), z.any(), z.any()]).optional(),
 });
@@ -49,21 +49,25 @@ export class AIAgent extends 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, messages, ...modelInput } = await this.instructions.build({
+        const { toolAgents, ...modelInput } = await this.instructions.build({
             agent: this,
             input,
             model,
             context,
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
+        if (this.toolChoice === "router") {
+            yield* this.processRouter(input, model, modelInput, context, toolsMap);
+            return;
+        }
         const toolCallMessages = [];
         const outputKey = this.outputKey || MESSAGE_KEY;
         for (;;) {
             const modelOutput = {};
-            const stream = await context.call(model, { ...modelInput, messages: messages.concat(toolCallMessages) }, { streaming: true });
+            const stream = await context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
             for await (const value of readableStreamToAsyncIterator(stream)) {
                 if (value.delta.text?.text) {
                     yield { delta: { text: { [outputKey]: value.delta.text.text } } };
@@ -81,7 +85,7 @@ export class AIAgent extends 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 (isTransferAgentOutput(output)) {
                         return output;
@@ -91,15 +95,6 @@ export class AIAgent extends Agent {
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
                     toolCallMessages.push(AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => 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;
-                        const { supportsParallelToolCalls } = model.getModelCapabilities();
-                        if (!output || (supportsParallelToolCalls && executedToolCalls.length !== 1)) {
-                            throw new Error("Router toolChoice requires exactly one tool to be executed");
-                        }
-                        return output;
-                    }
                     continue;
                 }
             }
@@ -116,4 +111,15 @@ export class AIAgent extends Agent {
             return;
         }
     }
+    async *processRouter(input, model, modelInput, context, toolsMap) {
+        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.invoke(tool, { ...call.function.arguments, ...input }, { streaming: true });
+        yield* readableStreamToAsyncIterator(stream);
+    }
 }

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

@@ -1,6 +1,7 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport, } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport, } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { UriTemplate } from "@modelcontextprotocol/sdk/shared/uriTemplate.js";
 import pRetry from "p-retry";
 import { z } from "zod";
@@ -8,8 +9,8 @@ import { logger } from "../utils/logger.js";
 import { promptFromMCPPrompt, resourceFromMCPResource, toolFromMCPTool, } from "../utils/mcp-utils.js";
 import { checkArguments, createAccessorArray } from "../utils/type-utils.js";
 import { Agent } from "./agent.js";
-const MCP_AGENT_CLIENT_NAME = "MCPAgent";
-const MCP_AGENT_CLIENT_VERSION = "0.0.1";
+const 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 = () => z.coerce
     .number()
@@ -35,7 +36,12 @@ export class MCPAgent extends Agent {
     static from(options) {
         checkArguments("MCPAgent.from", mcpAgentOptionsSchema, options);
         if (isSSEServerParameters(options)) {
-            const transport = () => new SSEClientTransport(new URL(options.url), options.opts);
+            const transport = () => {
+                if (options.transport === "streamableHttp") {
+                    return new StreamableHTTPClientTransport(new URL(options.url), options.opts);
+                }
+                return new SSEClientTransport(new URL(options.url), options.opts);
+            };
             return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
@@ -62,7 +68,7 @@ export class MCPAgent extends Agent {
         const mcpServer = getMCPServerName(client);
         const { tools: isToolsAvailable, prompts: isPromptsAvailable, resources: isResourcesAvailable, } = client.getServerCapabilities() ?? {};
         logger.mcp(`Listing tools from ${mcpServer}`);
-        const tools = isToolsAvailable
+        const skills = isToolsAvailable
             ? await client.listTools().then(({ tools }) => {
                 logger.mcp(`Listing tools from ${mcpServer} completed %O`, tools?.map((i) => i.name));
                 return tools.map((tool) => toolFromMCPTool(tool, { client }));
@@ -91,7 +97,7 @@ export class MCPAgent extends Agent {
         return new MCPAgent({
             name: client.getServerVersion()?.name,
             client,
-            tools,
+            skills,
             prompts,
             resources,
         });
@@ -107,7 +113,7 @@ export class MCPAgent extends Agent {
     client;
     prompts = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
     resources = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
-    get isCallable() {
+    get isInvokable() {
         return false;
     }
     async process(_input, _context) {

package/lib/esm/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/esm/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>>;
+}

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

@@ -0,0 +1,89 @@
+import { mergeAgentResponseChunk, readableStreamToAsyncIterator } from "../utils/stream-utils.js";
+import { isEmpty } from "../utils/type-utils.js";
+import { Agent, } from "./agent.js";
+export var ProcessMode;
+(function (ProcessMode) {
+    /**
+     * Process the agents one by one, passing the output of each agent to the next.
+     */
+    ProcessMode["sequential"] = "sequential";
+    /**
+     * Process all agents in parallel, merging the output of all agents.
+     */
+    ProcessMode["parallel"] = "parallel";
+})(ProcessMode || (ProcessMode = {}));
+export class TeamAgent extends Agent {
+    static from(options) {
+        return new TeamAgent(options);
+    }
+    constructor(options) {
+        super(options);
+        this.mode = options.mode ?? ProcessMode.sequential;
+    }
+    mode;
+    process(input, context) {
+        switch (this.mode) {
+            case ProcessMode.sequential:
+                return this._processSequential(input, context);
+            case ProcessMode.parallel:
+                return this._processParallel(input, context);
+        }
+    }
+    async *_processSequential(input, context) {
+        const output = {};
+        // Clone the agents to run, so that we can update the agents list during the loop
+        const agents = [...this.skills];
+        const newAgents = [];
+        for (const agent of agents) {
+            const [o, transferToAgent] = await context.invoke(agent, { ...input, ...output }, { returnActiveAgent: true, streaming: true });
+            for await (const chunk of readableStreamToAsyncIterator(o)) {
+                yield chunk;
+                mergeAgentResponseChunk(output, chunk);
+            }
+            newAgents.push(await transferToAgent);
+        }
+        this.skills.splice(0);
+        this.skills.push(...newAgents);
+    }
+    async *_processParallel(input, context) {
+        const result = await Promise.all(this.skills.map((agent) => context.invoke(agent, input, { returnActiveAgent: true, streaming: true })));
+        const streams = result.map((i) => i[0]);
+        const read = async (index, reader) => {
+            const promise = reader.read();
+            return promise.then((result) => ({ ...result, reader, index }));
+        };
+        const tasks = new Map(streams.map((stream, index) => [index, read(index, stream.getReader())]));
+        // NOTE: Flag to check if the output key is used by agent at the index,
+        const outputKeyUsed = new Map();
+        while (tasks.size) {
+            const { value, done, reader, index } = await Promise.race(tasks.values());
+            tasks.delete(index);
+            if (!done) {
+                tasks.set(index, read(index, reader));
+            }
+            if (value) {
+                let { delta: { text, ...delta }, } = value;
+                if (text) {
+                    for (const key of Object.keys(text)) {
+                        // the output key is unused, add to map to lock it
+                        if (!outputKeyUsed.has(key)) {
+                            outputKeyUsed.set(key, index);
+                        }
+                        // the output key is used by the agent at the index, abandon it
+                        else if (outputKeyUsed.get(key) !== index) {
+                            delete text[key];
+                        }
+                    }
+                    if (isEmpty(text)) {
+                        text = undefined;
+                    }
+                }
+                if (!isEmpty(delta.json) || !isEmpty(text))
+                    yield { delta: { ...delta, text } };
+            }
+        }
+        const agents = await Promise.all(result.map((i) => i[1]));
+        this.skills.splice(0);
+        this.skills.push(...agents);
+    }
+}

package/lib/esm/agents/user-agent.d.ts

@@ -1,26 +1,25 @@
 import { ReadableStream } from "node:stream/web";
-import { type Context, type Runnable } from "../execution-engine/context.js";
-import type { MessagePayload } from "../execution-engine/message-queue.js";
-import { type PromiseOrValue } from "../utils/type-utils.js";
-import { Agent, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
+import { type Context } from "../aigne/context.js";
+import type { MessagePayload } from "../aigne/message-queue.js";
+import { type Agent, type AgentOptions, type AgentProcessResult, FunctionAgent, type FunctionAgentFn, type Message } from "./agent.js";
 export interface UserAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     context: Context;
-    process?: (input: I, context: Context) => PromiseOrValue<O>;
-    activeAgent?: Runnable;
+    process?: FunctionAgentFn<I, O>;
+    activeAgent?: Agent;
 }
-export declare class UserAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+export declare class UserAgent<I extends Message = Message, O extends Message = Message> extends FunctionAgent<I, O> {
     static from<I extends Message, O extends Message>(options: UserAgentOptions<I, O>): UserAgent<I, O>;
     constructor(options: UserAgentOptions<I, O>);
     context: Context;
     private _process?;
     private activeAgent?;
-    call: Agent<I, O>["call"];
-    process(input: I, context: Context): AgentProcessAsyncGenerator<O>;
+    invoke: Agent<I, O>["invoke"];
+    process(input: I, context: Context): Promise<AgentProcessResult<O>>;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];
     get stream(): ReadableStream<MessagePayload & {
         topic: string;
     }>;
-    protected checkUsageAgentCalls(_context: Context): void;
+    protected checkAgentInvokesUsage(_context: Context): void;
 }

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

@@ -1,9 +1,8 @@
 import { ReadableStream } from "node:stream/web";
-import { createPublishMessage } from "../execution-engine/context.js";
-import { readableStreamToAsyncIterator } from "../utils/stream-utils.js";
+import { createPublishMessage } from "../aigne/context.js";
 import { orArrayToArray } from "../utils/type-utils.js";
-import { Agent, } from "./agent.js";
-export class UserAgent extends Agent {
+import { FunctionAgent, } from "./agent.js";
+export class UserAgent extends FunctionAgent {
     static from(options) {
         return new UserAgent(options);
     }
@@ -16,31 +15,29 @@ export class UserAgent extends Agent {
     context;
     _process;
     activeAgent;
-    call = ((input, context, options) => {
+    invoke = ((input, context, options) => {
         if (!context)
             this.context = this.context.newContext({ reset: true });
-        return super.call(input, context ?? this.context, options);
+        return super.invoke(input, context ?? this.context, options);
     });
-    async *process(input, context) {
+    async process(input, context) {
         if (this._process) {
-            yield { delta: { json: await this._process(input, context) } };
-            return;
+            return this._process(input, context);
         }
         if (this.activeAgent) {
-            const [output, agent] = await context.call(this.activeAgent, input, {
+            const [output, agent] = await context.invoke(this.activeAgent, input, {
                 returnActiveAgent: true,
                 streaming: true,
             });
             agent.then((agent) => {
                 this.activeAgent = agent;
             });
-            yield* readableStreamToAsyncIterator(output);
-            return;
+            return output;
         }
         const publicTopic = typeof this.publishTopic === "function" ? await this.publishTopic(input) : this.publishTopic;
         if (publicTopic?.length) {
             context.publish(publicTopic, createPublishMessage(input, this));
-            return;
+            return {};
         }
         throw new Error("UserAgent must have a process function or a publishTopic");
     }
@@ -69,7 +66,7 @@ export class UserAgent extends Agent {
             },
         });
     }
-    checkUsageAgentCalls(_context) {
+    checkAgentInvokesUsage(_context) {
         // ignore calls usage check for UserAgent
     }
 }

package/lib/{cjs/execution-engine/execution-engine.d.ts → esm/aigne/aigne.d.ts}

@@ -1,29 +1,26 @@
 import { Agent } from "../agents/agent.js";
 import { ChatModel } from "../models/chat-model.js";
-import { type Context, ExecutionContext } from "./context.js";
+import { AIGNEContext, type Context } from "./context.js";
 import { MessageQueue } from "./message-queue.js";
 import type { ContextLimits } from "./usage.js";
-export interface ExecutionEngineOptions {
+export interface AIGNEOptions {
     name?: string;
     description?: string;
     model?: ChatModel;
-    tools?: Agent[];
+    skills?: Agent[];
     agents?: Agent[];
     limits?: ContextLimits;
 }
-export interface ExecutionEngineRunOptions {
-    returnActiveAgent?: boolean;
-}
-export declare class ExecutionEngine {
+export declare class AIGNE {
     static load({ path, ...options }: {
         path: string;
-    } & ExecutionEngineOptions): Promise<ExecutionEngine>;
-    constructor(options?: ExecutionEngineOptions);
+    } & AIGNEOptions): Promise<AIGNE>;
+    constructor(options?: AIGNEOptions);
     name?: string;
     description?: string;
     readonly messageQueue: MessageQueue;
     model?: ChatModel;
-    readonly tools: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[] & {
+    readonly skills: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[] & {
         [key: string]: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>;
     };
     readonly agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[] & {
@@ -31,9 +28,9 @@ export declare class ExecutionEngine {
     };
     limits?: ContextLimits;
     addAgent(...agents: Agent[]): void;
-    newContext(): ExecutionContext;
+    newContext(): AIGNEContext;
     publish: Context["publish"];
-    call: Context["call"];
+    invoke: Context["invoke"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];
     shutdown(): Promise<void>;