@aigne/core 1.10.0 → 1.12.0

package/lib/cjs/utils/stream-utils.js

@@ -10,14 +10,16 @@ exports.asyncGeneratorToReadableStream = asyncGeneratorToReadableStream;
 exports.onAgentResponseStreamEnd = onAgentResponseStreamEnd;
 exports.isAsyncGenerator = isAsyncGenerator;
 exports.arrayToAgentProcessAsyncGenerator = arrayToAgentProcessAsyncGenerator;
-exports.arrayToAgentResponseStream = arrayToAgentResponseStream;
+exports.arrayToReadableStream = arrayToReadableStream;
 exports.readableStreamToArray = readableStreamToArray;
 exports.readableStreamToAsyncIterator = readableStreamToAsyncIterator;
+exports.stringToAgentResponseStream = stringToAgentResponseStream;
 const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("./type-utils.js");
 function objectToAgentResponseStream(json) {
     return new ReadableStream({
-        start(controller) {
+        pull(controller) {
             controller.enqueue({ delta: { json } });
             controller.close();
         },
@@ -63,40 +65,40 @@ async function agentResponseStreamToObject(stream) {
 }
 function asyncGeneratorToReadableStream(generator) {
     return new ReadableStream({
-        async start(controller) {
+        async pull(controller) {
             try {
-                for (;;) {
-                    const chunk = await generator.next();
-                    if (chunk.value) {
-                        if (chunk.done) {
-                            controller.enqueue({ delta: { json: chunk.value } });
-                        }
-                        else {
-                            controller.enqueue(chunk.value);
-                        }
+                const chunk = await generator.next();
+                if (chunk.value) {
+                    if (chunk.done) {
+                        controller.enqueue({ delta: { json: chunk.value } });
                     }
-                    if (chunk.done)
-                        break;
+                    else {
+                        controller.enqueue(chunk.value);
+                    }
+                }
+                if (chunk.done) {
+                    controller.close();
                 }
             }
             catch (error) {
                 controller.error(error);
             }
-            finally {
-                controller.close();
-            }
         },
     });
 }
 function onAgentResponseStreamEnd(stream, callback, options) {
+    const json = {};
+    const reader = stream.getReader();
     return new ReadableStream({
-        async start(controller) {
+        async pull(controller) {
             try {
-                const json = {};
-                for await (const value of readableStreamToAsyncIterator(stream)) {
+                const { value, done } = await reader.read();
+                if (!done) {
                     const chunk = options?.processChunk ? options.processChunk(value) : value;
-                    controller.enqueue(chunk);
+                    if (!(0, agent_js_1.isEmptyChunk)(chunk))
+                        controller.enqueue(chunk);
                     mergeAgentResponseChunk(json, value);
+                    return;
                 }
                 const result = await callback(json);
                 if (result && !(0, fast_deep_equal_1.default)(result, json)) {
@@ -105,13 +107,11 @@ function onAgentResponseStreamEnd(stream, callback, options) {
                         chunk = options.processChunk(chunk);
                     controller.enqueue(chunk);
                 }
+                controller.close();
             }
             catch (error) {
                 controller.error(options?.errorCallback?.(error) ?? error);
             }
-            finally {
-                controller.close();
-            }
         },
     });
 }
@@ -127,24 +127,34 @@ async function* arrayToAgentProcessAsyncGenerator(chunks, result) {
     if (result !== undefined)
         return result;
 }
-function arrayToAgentResponseStream(chunks) {
+function arrayToReadableStream(chunks) {
+    const list = [...chunks];
     return new ReadableStream({
-        start(controller) {
-            for (const chunk of chunks) {
-                if (chunk instanceof Error) {
-                    controller.error(chunk);
-                    return;
-                }
-                controller.enqueue(chunk);
+        pull(controller) {
+            const item = list.shift();
+            if (!item) {
+                controller.close();
+                return;
             }
-            controller.close();
+            if (item instanceof Error) {
+                controller.error(item);
+                return;
+            }
+            controller.enqueue(item);
         },
     });
 }
-async function readableStreamToArray(stream) {
+async function readableStreamToArray(stream, options) {
     const result = [];
-    for await (const value of readableStreamToAsyncIterator(stream)) {
-        result.push(value);
+    try {
+        for await (const value of readableStreamToAsyncIterator(stream)) {
+            result.push(value);
+        }
+    }
+    catch (error) {
+        if (!options?.catchError)
+            throw error;
+        result.push(error);
     }
     return result;
 }
@@ -157,3 +167,8 @@ async function* readableStreamToAsyncIterator(stream) {
         yield value;
     }
 }
+function stringToAgentResponseStream(str, key = "text") {
+    const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+    const segments = segmenter.segment(str);
+    return arrayToReadableStream(Array.from(segments).map((segment) => ({ delta: { text: { [key]: segment.segment } } })));
+}

package/lib/cjs/utils/type-utils.d.ts

@@ -1,8 +1,9 @@
 import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
-export type Nullish<T> = T | null | undefined;
+export type Nullish<T> = T | null | undefined | void;
 export type OmitPropertiesFromArrayFirstElement<T extends unknown[], K extends string | number | symbol> = T extends [infer U, ...infer Rest] ? [Omit<U, K>, ...Rest] : never;
 export declare function isNil(value: unknown): value is null | undefined;
+export declare function isRecord<T>(value: unknown): value is Record<string, T>;
 export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
 export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
@@ -12,5 +13,6 @@ export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };
-export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): T;
+export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T | unknown): T;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;
+export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error?: Nullish<string | Error | ((error: Error) => Nullish<Error>)>): P | undefined;

package/lib/cjs/utils/type-utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNil = isNil;
+exports.isRecord = isRecord;
 exports.isEmpty = isEmpty;
 exports.isNonNullable = isNonNullable;
 exports.isNotEmpty = isNotEmpty;
@@ -14,6 +15,9 @@ const zod_1 = require("zod");
 function isNil(value) {
     return value === null || value === undefined;
 }
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
 function isEmpty(obj) {
     if (isNil(obj))
         return true;
@@ -113,12 +117,16 @@ function tryOrThrow(fn, error) {
         const result = fn();
         if (result instanceof Promise) {
             return result.catch((e) => {
-                throw createError(e);
+                const error = createError(e);
+                if (error)
+                    throw error;
             });
         }
         return result;
     }
     catch (e) {
-        throw createError(e);
+        const error = createError(e);
+        if (error)
+            throw error;
     }
 }

package/lib/dts/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,52 +38,53 @@ 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;
 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>;
@@ -92,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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/{execution-engine/execution-engine.d.ts → 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>;