@aigne/core 1.11.0 → 1.12.0

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamAgent = exports.ProcessMode = void 0;
+const stream_utils_js_1 = require("../utils/stream-utils.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const agent_js_1 = require("./agent.js");
+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 || (exports.ProcessMode = ProcessMode = {}));
+class TeamAgent extends agent_js_1.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 (0, stream_utils_js_1.readableStreamToAsyncIterator)(o)) {
+                yield chunk;
+                (0, stream_utils_js_1.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 ((0, type_utils_js_1.isEmpty)(text)) {
+                        text = undefined;
+                    }
+                }
+                if (!(0, type_utils_js_1.isEmpty)(delta.json) || !(0, type_utils_js_1.isEmpty)(text))
+                    yield { delta: { ...delta, text } };
+            }
+        }
+        const agents = await Promise.all(result.map((i) => i[1]));
+        this.skills.splice(0);
+        this.skills.push(...agents);
+    }
+}
+exports.TeamAgent = TeamAgent;

package/lib/cjs/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/cjs/agents/user-agent.js

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserAgent = void 0;
 const web_1 = require("node:stream/web");
-const context_js_1 = require("../execution-engine/context.js");
-const stream_utils_js_1 = require("../utils/stream-utils.js");
+const context_js_1 = require("../aigne/context.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
-class UserAgent extends agent_js_1.Agent {
+class UserAgent extends agent_js_1.FunctionAgent {
     static from(options) {
         return new UserAgent(options);
     }
@@ -19,31 +18,29 @@ class UserAgent extends agent_js_1.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* (0, stream_utils_js_1.readableStreamToAsyncIterator)(output);
-            return;
+            return output;
         }
         const publicTopic = typeof this.publishTopic === "function" ? await this.publishTopic(input) : this.publishTopic;
         if (publicTopic?.length) {
             context.publish(publicTopic, (0, context_js_1.createPublishMessage)(input, this));
-            return;
+            return {};
         }
         throw new Error("UserAgent must have a process function or a publishTopic");
     }
@@ -72,7 +69,7 @@ class UserAgent extends agent_js_1.Agent {
             },
         });
     }
-    checkUsageAgentCalls(_context) {
+    checkAgentInvokesUsage(_context) {
         // ignore calls usage check for UserAgent
     }
 }

package/lib/{esm/execution-engine/execution-engine.d.ts → cjs/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>;

package/lib/cjs/{execution-engine/execution-engine.js → aigne/aigne.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionEngine = void 0;
+exports.AIGNE = void 0;
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const index_js_1 = require("../loader/index.js");
@@ -8,27 +8,27 @@ const chat_model_js_1 = require("../models/chat-model.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const context_js_1 = require("./context.js");
 const message_queue_js_1 = require("./message-queue.js");
-class ExecutionEngine {
+class AIGNE {
     static async load({ path, ...options }) {
-        const { model, agents, tools, ...aigne } = await (0, index_js_1.load)({ path });
-        return new ExecutionEngine({
+        const { model, agents, skills, ...aigne } = await (0, index_js_1.load)({ path });
+        return new AIGNE({
             ...options,
             model: options.model || model,
             name: options.name || aigne.name || undefined,
             description: options.description || aigne.description || undefined,
             agents: agents.concat(options.agents ?? []),
-            tools: tools.concat(options.tools ?? []),
+            skills: skills.concat(options.skills ?? []),
         });
     }
     constructor(options) {
         if (options)
-            (0, type_utils_js_1.checkArguments)("ExecutionEngine", executionEngineOptionsSchema, options);
+            (0, type_utils_js_1.checkArguments)("AIGNE", aigneOptionsSchema, options);
         this.name = options?.name;
         this.description = options?.description;
         this.model = options?.model;
         this.limits = options?.limits;
-        if (options?.tools?.length)
-            this.tools.push(...options.tools);
+        if (options?.skills?.length)
+            this.skills.push(...options.skills);
         if (options?.agents?.length)
             this.addAgent(...options.agents);
         this.initProcessExitHandler();
@@ -37,24 +37,24 @@ class ExecutionEngine {
     description;
     messageQueue = new message_queue_js_1.MessageQueue();
     model;
-    tools = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
+    skills = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
     agents = (0, type_utils_js_1.createAccessorArray)([], (arr, name) => arr.find((i) => i.name === name));
     limits;
     addAgent(...agents) {
-        (0, type_utils_js_1.checkArguments)("ExecutionEngine.addAgent", executionEngineAddAgentArgsSchema, agents);
+        (0, type_utils_js_1.checkArguments)("AIGNE.addAgent", aigneAddAgentArgsSchema, agents);
         for (const agent of agents) {
             this.agents.push(agent);
             agent.attach(this);
         }
     }
     newContext() {
-        return new context_js_1.ExecutionContext(this);
+        return new context_js_1.AIGNEContext(this);
     }
     publish = ((...args) => {
-        return new context_js_1.ExecutionContext(this).publish(...args);
+        return new context_js_1.AIGNEContext(this).publish(...args);
     });
-    call = ((...args) => {
-        return new context_js_1.ExecutionContext(this).call(...args);
+    invoke = ((...args) => {
+        return new context_js_1.AIGNEContext(this).invoke(...args);
     });
     subscribe = ((...args) => {
         return this.messageQueue.subscribe(...args);
@@ -63,7 +63,7 @@ class ExecutionEngine {
         this.messageQueue.unsubscribe(...args);
     });
     async shutdown() {
-        for (const tool of this.tools) {
+        for (const tool of this.skills) {
             await tool.shutdown();
         }
         for (const agent of this.agents) {
@@ -76,10 +76,10 @@ class ExecutionEngine {
         process.on("exit", shutdownAndExit);
     }
 }
-exports.ExecutionEngine = ExecutionEngine;
-const executionEngineOptionsSchema = zod_1.z.object({
+exports.AIGNE = AIGNE;
+const aigneOptionsSchema = zod_1.z.object({
     model: zod_1.z.instanceof(chat_model_js_1.ChatModel).optional(),
-    tools: zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent)).optional(),
+    skills: zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent)).optional(),
     agents: zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent)).optional(),
 });
-const executionEngineAddAgentArgsSchema = zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent));
+const aigneAddAgentArgsSchema = zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent));

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

@@ -1,12 +1,11 @@
 import EventEmitter from "node:events";
-import { Agent, type AgentCallOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type FunctionAgentFn, type Message } from "../agents/agent.js";
+import { Agent, type AgentInvokeOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
 import { UserAgent } from "../agents/user-agent.js";
 import type { ChatModel } from "../models/chat-model.js";
 import { type OmitPropertiesFromArrayFirstElement } from "../utils/type-utils.js";
 import type { Args, Listener, TypedEventEmitter } from "../utils/typed-event-emtter.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 import { type ContextLimits, type ContextUsage } from "./usage.js";
-export type Runnable<I extends Message = Message, O extends Message = Message> = Agent<I, O> | FunctionAgentFn;
 export interface AgentEvent {
     parentContextId?: string;
     contextId: string;
@@ -27,53 +26,53 @@ export interface ContextEventMap {
 export type ContextEmitEventMap = {
     [K in keyof ContextEventMap]: OmitPropertiesFromArrayFirstElement<ContextEventMap[K], "contextId" | "parentContextId" | "timestamp">;
 };
-export interface CallOptions extends AgentCallOptions {
+export interface InvokeOptions extends AgentInvokeOptions {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
 }
 export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
     model?: ChatModel;
-    tools?: Agent[];
+    skills?: Agent[];
     usage: ContextUsage;
     limits?: ContextLimits;
     status?: "normal" | "timeout";
     /**
-     * Create a user agent to consistently call an agent
-     * @param agent Agent to call
+     * Create a user agent to consistently invoke an agent
+     * @param agent Agent to invoke
      * @returns User agent
      */
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>): UserAgent<I, O>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>): UserAgent<I, O>;
     /**
-     * Call an agent with a message and return the output and the active agent
-     * @param agent Agent to call
+     * Invoke an agent with a message and return the output and the active agent
+     * @param agent Agent to invoke
      * @param message Message to pass to the agent
      * @param options.returnActiveAgent return the active agent
      * @param options.streaming return a stream of the output
      * @returns the output of the agent and the final active agent
      */
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
         returnActiveAgent: true;
         streaming?: false;
-    }): Promise<[O, Runnable]>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+    }): Promise<[O, Agent]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
         returnActiveAgent: true;
         streaming: true;
-    }): Promise<[AgentResponseStream<O>, Promise<Runnable>]>;
+    }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
     /**
-     * Call an agent with a message
-     * @param agent Agent to call
+     * Invoke an agent with a message
+     * @param agent Agent to invoke
      * @param message Message to pass to the agent
      * @returns the output of the agent
      */
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options?: CallOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options?: InvokeOptions & {
         streaming?: false;
     }): Promise<O>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: CallOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Runnable]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message?: I | string, options?: InvokeOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
     /**
-     * Publish a message to a topic, the engine will call the listeners of the topic
+     * Publish a message to a topic, the aigne will invoke the listeners of the topic
      * @param topic topic name, or an array of topic names
      * @param payload message to publish
      */
@@ -96,21 +95,21 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
     }): Context;
 }
 export declare function createPublishMessage(message: string | Message, from?: Agent): Omit<MessagePayload, "context">;
-export declare class ExecutionContext implements Context {
-    constructor(parent?: ConstructorParameters<typeof ExecutionContextInternal>[0]);
+export declare class AIGNEContext implements Context {
+    constructor(parent?: ConstructorParameters<typeof AIGNEContextInternal>[0]);
     parentId?: string;
     id: string;
-    readonly internal: ExecutionContextInternal;
+    readonly internal: AIGNEContextInternal;
     get model(): ChatModel | undefined;
-    get tools(): Agent<Message, Message>[] | undefined;
+    get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     get status(): "normal" | "timeout";
     get usage(): ContextUsage;
     newContext({ reset }?: {
         reset?: boolean;
-    }): ExecutionContext;
-    call: Context["call"];
-    private onCallSuccess;
+    }): AIGNEContext;
+    invoke: Context["invoke"];
+    private onInvokeSuccess;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];
@@ -119,24 +118,24 @@ export declare class ExecutionContext implements Context {
     once<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
     off<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
 }
-declare class ExecutionContextInternal {
+declare class AIGNEContextInternal {
     private readonly parent?;
-    constructor(parent?: (Pick<Context, "model" | "tools" | "limits"> & {
+    constructor(parent?: (Pick<Context, "model" | "skills" | "limits"> & {
         messageQueue?: MessageQueue;
     }) | undefined);
     readonly messageQueue: MessageQueue;
     readonly events: EventEmitter<ContextEventMap>;
     get model(): ChatModel | undefined;
-    get tools(): Agent<Message, Message>[] | undefined;
+    get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     usage: ContextUsage;
     private abortController;
     private timer?;
     private initTimeout;
     get status(): "normal" | "timeout";
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, input: I, context: Context, options?: CallOptions): AgentProcessAsyncGenerator<O & {
-        __activeAgent__: Runnable;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, input: I, context: Context, options?: InvokeOptions): AgentProcessAsyncGenerator<O & {
+        __activeAgent__: Agent;
     }>;
-    private callAgent;
+    private invokeAgent;
 }
 export {};

package/lib/cjs/{execution-engine → aigne}/context.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionContext = void 0;
+exports.AIGNEContext = void 0;
 exports.createPublishMessage = createPublishMessage;
 const node_events_1 = __importDefault(require("node:events"));
 const uuid_1 = require("uuid");
@@ -23,14 +23,14 @@ function createPublishMessage(message, from) {
         message: (0, prompt_builder_js_1.createMessage)(message),
     };
 }
-class ExecutionContext {
+class AIGNEContext {
     constructor(parent) {
-        if (parent instanceof ExecutionContext) {
+        if (parent instanceof AIGNEContext) {
             this.parentId = parent.id;
             this.internal = parent.internal;
         }
         else {
-            this.internal = new ExecutionContextInternal(parent);
+            this.internal = new AIGNEContextInternal(parent);
         }
     }
     parentId;
@@ -39,8 +39,8 @@ class ExecutionContext {
     get model() {
         return this.internal.model;
     }
-    get tools() {
-        return this.internal.tools;
+    get skills() {
+        return this.internal.skills;
     }
     get limits() {
         return this.internal.limits;
@@ -53,11 +53,11 @@ class ExecutionContext {
     }
     newContext({ reset } = {}) {
         if (reset)
-            return new ExecutionContext(this.internal);
-        return new ExecutionContext(this);
+            return new AIGNEContext(this.internal);
+        return new AIGNEContext(this);
     }
-    call = ((agent, message, options) => {
-        (0, type_utils_js_1.checkArguments)("ExecutionContext.call", executionContextCallArgsSchema, {
+    invoke = ((agent, message, options) => {
+        (0, type_utils_js_1.checkArguments)("AIGNEContext.invoke", aigneContextInvokeArgsSchema, {
             agent,
             message,
             options,
@@ -70,10 +70,10 @@ class ExecutionContext {
         }
         const newContext = this.newContext();
         const msg = (0, prompt_builder_js_1.createMessage)(message);
-        return Promise.resolve(newContext.internal.call(agent, msg, newContext, options)).then(async (response) => {
+        return Promise.resolve(newContext.internal.invoke(agent, msg, newContext, options)).then(async (response) => {
             if (!options?.streaming) {
                 const { __activeAgent__: activeAgent, ...output } = await (0, stream_utils_js_1.agentResponseStreamToObject)(response);
-                this.onCallSuccess(activeAgent, output, newContext);
+                this.onInvokeSuccess(activeAgent, output, newContext);
                 if (options?.returnActiveAgent) {
                     return [output, activeAgent];
                 }
@@ -81,7 +81,7 @@ class ExecutionContext {
             }
             const activeAgentPromise = Promise.withResolvers();
             const stream = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.asyncGeneratorToReadableStream)(response), async ({ __activeAgent__: activeAgent, ...output }) => {
-                this.onCallSuccess(activeAgent, output, newContext);
+                this.onInvokeSuccess(activeAgent, output, newContext);
                 activeAgentPromise.resolve(activeAgent);
             }, {
                 processChunk(chunk) {
@@ -103,7 +103,7 @@ class ExecutionContext {
             return stream;
         });
     });
-    async onCallSuccess(activeAgent, output, context) {
+    async onInvokeSuccess(activeAgent, output, context) {
         if (activeAgent instanceof agent_js_1.Agent) {
             const publishTopics = typeof activeAgent.publishTopic === "function"
                 ? await activeAgent.publishTopic(output)
@@ -145,8 +145,8 @@ class ExecutionContext {
         return this;
     }
 }
-exports.ExecutionContext = ExecutionContext;
-class ExecutionContextInternal {
+exports.AIGNEContext = AIGNEContext;
+class AIGNEContextInternal {
     parent;
     constructor(parent) {
         this.parent = parent;
@@ -157,8 +157,8 @@ class ExecutionContextInternal {
     get model() {
         return this.parent?.model;
     }
-    get tools() {
-        return this.parent?.tools;
+    get skills() {
+        return this.parent?.skills;
     }
     get limits() {
         return this.parent?.limits;
@@ -179,33 +179,23 @@ class ExecutionContextInternal {
     get status() {
         return this.abortController.signal.aborted ? "timeout" : "normal";
     }
-    call(agent, input, context, options) {
+    invoke(agent, input, context, options) {
         this.initTimeout();
-        return withAbortSignal(this.abortController.signal, new Error("ExecutionContext is timeout"), () => this.callAgent(agent, input, context, options));
+        return withAbortSignal(this.abortController.signal, new Error("AIGNEContext is timeout"), () => this.invokeAgent(agent, input, context, options));
     }
-    async *callAgent(agent, input, context, options) {
+    async *invokeAgent(agent, input, context, options) {
         let activeAgent = agent;
         let output;
         for (;;) {
-            let result;
-            if (typeof activeAgent === "function") {
-                result = await activeAgent(input, context);
-            }
-            else {
-                result = {};
-                const stream = await activeAgent.call(input, context, { streaming: true });
-                for await (const value of (0, stream_utils_js_1.readableStreamToAsyncIterator)(stream)) {
-                    if (value.delta.text) {
-                        yield { delta: { text: value.delta.text } };
-                    }
-                    if (value.delta.json) {
-                        Object.assign(result, value.delta.json);
-                    }
+            const result = {};
+            const stream = await activeAgent.invoke(input, context, { streaming: true });
+            for await (const value of (0, stream_utils_js_1.readableStreamToAsyncIterator)(stream)) {
+                if (value.delta.text) {
+                    yield { delta: { text: value.delta.text } };
+                }
+                if (value.delta.json) {
+                    Object.assign(result, value.delta.json);
                 }
-            }
-            if (result instanceof agent_js_1.Agent) {
-                activeAgent = result;
-                continue;
             }
             if (!options?.disableTransfer) {
                 const transferToAgent = (0, types_js_1.isTransferAgentOutput)(result)
@@ -250,7 +240,7 @@ async function* withAbortSignal(signal, error, fn) {
         signal.removeEventListener("abort", listener);
     }
 }
-const executionContextCallArgsSchema = zod_1.z.object({
+const aigneContextInvokeArgsSchema = zod_1.z.object({
     agent: zod_1.z.union([zod_1.z.function(), zod_1.z.instanceof(agent_js_1.Agent)]),
     message: zod_1.z.union([zod_1.z.record(zod_1.z.unknown()), zod_1.z.string()]).optional(),
     options: zod_1.z.object({ returnActiveAgent: zod_1.z.boolean().optional() }).optional(),

package/lib/cjs/aigne/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./context.js";
+export * from "./aigne.js";
+export * from "./message-queue.js";
+export * from "./usage.js";

package/lib/cjs/{execution-engine → aigne}/index.js

@@ -15,6 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./context.js"), exports);
-__exportStar(require("./execution-engine.js"), exports);
+__exportStar(require("./aigne.js"), exports);
 __exportStar(require("./message-queue.js"), exports);
-__exportStar(require("./utils.js"), exports);
+__exportStar(require("./usage.js"), exports);