@aigne/core 1.5.0 → 1.5.1-1

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

@@ -3,16 +3,17 @@ import type { MessagePayload, MessageQueueListener, Unsubscribe } from "../execu
 import { type PromiseOrValue } from "../utils/type-utils.js";
 import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface UserAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
-    context?: Context;
+    context: Context;
     process?: (input: I, context: Context) => PromiseOrValue<O>;
 }
 export declare class UserAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static from<I extends Message, O extends Message>(options: UserAgentOptions<I, O>): UserAgent<I, O>;
     constructor(options: UserAgentOptions<I, O>);
-    private context?;
+    readonly context: Context;
     private get ctx();
     private _process?;
-    process(input: I, context?: Context): Promise<O>;
+    call(input: string | I, context?: Context): Promise<O>;
+    process(input: I, context: Context): Promise<O>;
     publish(topic: string | string[], message: Message | string): void;
     subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;

package/lib/dts/execution-engine/context.d.ts

@@ -1,11 +1,31 @@
-import type EventEmitter from "node:events";
-import type { Agent, FunctionAgentFn, Message } from "../agents/agent.js";
+import EventEmitter from "node:events";
+import { Agent, type FunctionAgentFn, type Message } from "../agents/agent.js";
+import { UserAgent } from "../agents/user-agent.js";
 import type { ChatModel } from "../models/chat-model.js";
-import type { MessagePayload, MessageQueueListener, Unsubscribe } from "./message-queue.js";
+import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 export type Runnable<I extends Message = Message, O extends Message = Message> = Agent<I, O> | FunctionAgentFn;
+export interface ContextUsage {
+    promptTokens: number;
+    completionTokens: number;
+    agentCalls: number;
+}
+export interface ContextLimits {
+    maxTokens?: number;
+    maxAgentCalls?: number;
+    timeout?: number;
+}
 export interface Context extends EventEmitter {
     model?: ChatModel;
     tools?: Agent[];
+    usage: ContextUsage;
+    limits?: ContextLimits;
+    status?: "normal" | "timeout";
+    /**
+     * Create a user agent to consistently call an agent
+     * @param agent Agent to call
+     * @returns User agent
+     */
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>): UserAgent<I, O>;
     /**
      * Call an agent with a message
      * @param agent Agent to call
@@ -21,11 +41,11 @@ export interface Context extends EventEmitter {
      * @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: {
-        returnActiveAgent?: true;
+        returnActiveAgent: true;
     }): Promise<[O, Runnable]>;
     call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options?: {
         returnActiveAgent?: boolean;
-    }): Promise<O | [O, Runnable]>;
+    }): UserAgent<I, O> | Promise<O | [O, Runnable]>;
     /**
      * Publish a message to a topic, the engine will call the listeners of the topic
      * @param topic topic name, or an array of topic names
@@ -38,3 +58,36 @@ export interface Context extends EventEmitter {
     subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
     unsubscribe(topic: string, listener: MessageQueueListener): void;
 }
+export declare class ExecutionContext extends EventEmitter implements Context {
+    private readonly engine?;
+    constructor(engine?: {
+        model?: ChatModel;
+        tools?: Agent[];
+        limits?: ContextLimits;
+        messageQueue?: MessageQueue;
+        emit?: EventEmitter["emit"];
+    } | undefined);
+    private messageQueue;
+    get model(): ChatModel | undefined;
+    get tools(): Agent<Message, Message>[] | undefined;
+    usage: ContextUsage;
+    limits?: ContextLimits | undefined;
+    private abortController;
+    private timer?;
+    private initTimeout;
+    get status(): "normal" | "timeout";
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>): UserAgent<I, O>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string): Promise<O>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: {
+        returnActiveAgent: true;
+    }): Promise<[O, Runnable]>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: {
+        returnActiveAgent?: boolean;
+    }): UserAgent<I, O> | Promise<O | [O, Runnable]>;
+    publish(topic: string | string[], message: Message | string, from?: Agent): void;
+    subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
+    subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
+    unsubscribe(topic: string, listener: MessageQueueListener): void;
+    emit(eventName: string | symbol, ...args: unknown[]): boolean;
+    private callAgent;
+}

package/lib/dts/execution-engine/execution-engine.d.ts

@@ -1,22 +1,24 @@
 import EventEmitter from "node:events";
 import { Agent, type Message } from "../agents/agent.js";
-import { UserAgent } from "../agents/user-agent.js";
+import type { UserAgent } from "../agents/user-agent.js";
 import { ChatModel } from "../models/chat-model.js";
-import type { Context, Runnable } from "./context.js";
+import { type ContextLimits, ExecutionContext, type Runnable } from "./context.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 export interface ExecutionEngineOptions {
     model?: ChatModel;
     tools?: Agent[];
     agents?: Agent[];
+    limits?: ContextLimits;
 }
-export declare class ExecutionEngine extends EventEmitter implements Context {
+export declare class ExecutionEngine extends EventEmitter {
     constructor(options?: ExecutionEngineOptions);
     readonly messageQueue: MessageQueue;
     model?: ChatModel;
     tools: Agent[];
     private agents;
+    limits?: ContextLimits;
     addAgent(...agents: Agent[]): void;
-    private createMessageFromInput;
+    newContext(): ExecutionContext;
     /**
      * Publish a message to a topic, the engine will call the listeners of the topic
      * @param topic topic name, or an array of topic names
@@ -45,20 +47,15 @@ export declare class ExecutionEngine extends EventEmitter implements Context {
      * @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: {
-        returnActiveAgent?: true;
+        returnActiveAgent: true;
     }): Promise<[O, Runnable]>;
-    /**
-     * Call an agent with a message and return the output and the active agent
-     * @param agent Agent to call
-     * @param message Message to pass to the agent
-     * @returns the output of the agent and the final active agent
-     */
-    private _call;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: {
+        returnActiveAgent?: boolean;
+    }): UserAgent<I, O> | Promise<O | [O, Runnable]>;
     subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
     subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
     unsubscribe(topic: string, listener: MessageQueueListener): void;
-    private callAgent;
     shutdown(): Promise<void>;
     private initProcessExitHandler;
 }

package/lib/dts/execution-engine/message-queue.d.ts

@@ -1,10 +1,12 @@
 import type { Message } from "../agents/agent.js";
+import type { Context } from "./context.js";
 export declare const UserInputTopic = "UserInputTopic";
 export declare const UserOutputTopic = "UserOutputTopic";
 export interface MessagePayload {
     role: "user" | "agent";
     source?: string;
     message: Message;
+    context: Context;
 }
 export type MessageQueueListener = (message: MessagePayload) => void;
 export type MessageRequest = MessagePayload;

package/lib/dts/execution-engine/utils.d.ts

@@ -1,4 +1,4 @@
 import { type FunctionAgentFn } from "../agents/agent.js";
 import type { Runnable } from "./context.js";
-export declare function sequential(..._agents: [Runnable, ...Runnable[]]): FunctionAgentFn;
-export declare function parallel(..._agents: [Runnable, ...Runnable[]]): FunctionAgentFn;
+export declare function sequential(...agents: [Runnable, ...Runnable[]]): FunctionAgentFn;
+export declare function parallel(...agents: [Runnable, ...Runnable[]]): FunctionAgentFn;

package/lib/dts/models/chat-model.d.ts

@@ -1,6 +1,9 @@
 import { Agent, type Message } from "../agents/agent.js";
+import type { Context } from "../execution-engine/context.js";
 export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
     constructor();
+    protected preprocess(input: ChatModelInput, context: Context): void;
+    protected postprocess(input: ChatModelInput, output: ChatModelOutput, context: Context): void;
 }
 export interface ChatModelInput extends Message {
     messages: ChatModelInputMessage[];
@@ -71,6 +74,7 @@ export interface ChatModelOutput extends Message {
     text?: string;
     json?: object;
     toolCalls?: ChatModelOutputToolCall[];
+    usage?: ChatModelOutputUsage;
 }
 export interface ChatModelOutputToolCall {
     id: string;
@@ -80,3 +84,7 @@ export interface ChatModelOutputToolCall {
         arguments: Message;
     };
 }
+export interface ChatModelOutputUsage {
+    promptTokens: number;
+    completionTokens: number;
+}

package/lib/dts/models/openai-chat-model.d.ts

@@ -1,3 +1,4 @@
+import OpenAI from "openai";
 import { z } from "zod";
 import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
 export interface OpenAIChatModelOptions {
@@ -61,7 +62,7 @@ export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);
     private _client?;
-    private get client();
+    get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;
 }

package/lib/dts/models/xai-chat-model.d.ts

@@ -7,6 +7,5 @@ export interface XAIChatModelOptions {
     baseURL?: string;
 }
 export declare class XAIChatModel extends OpenAIChatModel {
-    options?: XAIChatModelOptions | undefined;
-    constructor(options?: XAIChatModelOptions | undefined);
+    constructor(options?: XAIChatModelOptions);
 }

package/lib/dts/utils/logger.d.ts

@@ -10,7 +10,7 @@ export declare const logger: debug.Debug & {
     debug: debug.Debug;
     default: debug.Debug;
 } & {
-    globalSpinner: import("ora").Ora;
+    globalSpinner: import("@aigne/ora").Ora;
     base: DebugWithSpinner;
     debug: DebugWithSpinner;
     spinner: typeof spinner;

package/lib/dts/utils/model-utils.d.ts

@@ -0,0 +1,3 @@
+import type { ChatModelOutputUsage } from "../models/chat-model.js";
+import type { Nullish } from "./type-utils.js";
+export declare function mergeUsage(...usages: Nullish<ChatModelOutputUsage>[]): ChatModelOutputUsage;

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

@@ -1,12 +1,11 @@
 import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 export type Nullish<T> = T | null | undefined;
+export declare function isNil(value: unknown): value is null | undefined;
+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[]];
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
-export declare function get(obj: unknown, path: string | string[], type?: undefined): unknown | undefined;
-export declare function get(obj: unknown, path: string | string[], type: "string"): string | undefined;
-export declare function get(obj: unknown, path: string | string[], type: "number"): number | undefined;
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };

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

@@ -44,11 +44,15 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * - subscribe to memory topic if memory is enabled
      * @param context Context to attach
      */
-    attach(context: Context): void;
+    attach(context: Pick<Context, "subscribe">): void;
     addTool<I extends Message, O extends Message>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
     get isCallable(): boolean;
+    private checkContextStatus;
+    private newDefaultContext;
     call(input: I | string, context?: Context): Promise<O>;
-    abstract process(input: I, context?: Context): Promise<O | TransferAgentOutput>;
+    protected preprocess(_: I, context: Context): void;
+    protected postprocess(input: I, output: O, context: Context): void;
+    abstract process(input: I, context: Context): Promise<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
 }
 export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
@@ -59,6 +63,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): Promise<TransferAgentOutput | O>;
+    process(input: I, context: Context): Promise<TransferAgentOutput | 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 = Message, O extends Message = Message> = (input: I, context: Context) => O | Promise<O> | Agent | Promise<Agent>;

package/lib/esm/agents/agent.js

@@ -66,7 +66,7 @@ export class Agent {
     attach(context) {
         this.memory?.attach(context);
         for (const topic of orArrayToArray(this.subscribeTopic).concat(this.topic)) {
-            context.subscribe(topic, async ({ message }) => {
+            context.subscribe(topic, async ({ message, context }) => {
                 try {
                     await context.call(this, message);
                 }
@@ -82,26 +82,54 @@ export class Agent {
     get isCallable() {
         return !!this.process;
     }
+    checkContextStatus(context) {
+        if (context) {
+            const { status } = context;
+            if (status === "timeout") {
+                throw new Error(`ExecutionEngine for agent ${this.name} has timed out`);
+            }
+        }
+    }
+    async newDefaultContext() {
+        return import("../execution-engine/context.js").then((m) => new m.ExecutionContext());
+    }
     async call(input, context) {
+        const ctx = context ?? (await this.newDefaultContext());
         const _input = typeof input === "string" ? createMessage(input) : input;
         const parsedInput = this.inputSchema.parse(_input);
         logger.debug("Call agent %s start with input: %O", this.name, input);
-        const result = this.process(parsedInput, context)
+        this.preprocess(parsedInput, ctx);
+        this.checkContextStatus(ctx);
+        const result = this.process(parsedInput, ctx)
             .then((output) => {
             const parsedOutput = this.outputSchema.parse(output);
             return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
         })
             .then((output) => {
-            this.memory?.addMemory({ role: "user", content: _input });
-            this.memory?.addMemory({
-                role: "agent",
-                content: replaceTransferAgentToName(output),
-                source: this.name,
-            });
+            this.postprocess(parsedInput, output, ctx);
             return output;
         });
         return logger.debug.spinner(result, `Call agent ${this.name}`, (output) => logger.debug("Call agent %s succeed with output: %O", this.name, replaceTransferAgentToName(output)), { disabled: this.disableLogging });
     }
+    preprocess(_, context) {
+        this.checkContextStatus(context);
+        if (context) {
+            const { limits, usage } = context;
+            if (limits?.maxAgentCalls && usage.agentCalls >= limits.maxAgentCalls) {
+                throw new Error(`Exceeded max agent calls ${usage.agentCalls}/${limits.maxAgentCalls}`);
+            }
+            usage.agentCalls++;
+        }
+    }
+    postprocess(input, output, context) {
+        this.checkContextStatus(context);
+        this.memory?.addMemory({ role: "user", content: input });
+        this.memory?.addMemory({
+            role: "agent",
+            content: replaceTransferAgentToName(output),
+            source: this.name,
+        });
+    }
     async shutdown() {
         this.memory?.detach();
     }

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

@@ -27,10 +27,10 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     disableLogging: z.ZodOptional<z.ZodBoolean>;
     memory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodAny, z.ZodAny]>>;
 }, "strip", z.ZodTypeAny, {
+    description?: string | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
-    toolChoice?: "auto" | "none" | "required" | Agent<Message, Message> | "router" | 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;
@@ -42,10 +42,10 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     disableLogging?: boolean | undefined;
     memory?: any;
 }, {
+    description?: string | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
-    toolChoice?: "auto" | "none" | "required" | Agent<Message, Message> | "router" | 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;
@@ -64,5 +64,5 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
-    process(input: I, context?: Context): Promise<import("./types.js").TransferAgentOutput | O>;
+    process(input: I, context: Context): Promise<import("./types.js").TransferAgentOutput | O>;
 }

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

@@ -47,9 +47,7 @@ export class AIAgent extends Agent {
     outputKey;
     toolChoice;
     async process(input, context) {
-        if (!context)
-            throw new Error("Context is required to run AIAgent");
-        const model = context?.model ?? this.model;
+        const model = context.model ?? this.model;
         if (!model)
             throw new Error("model is required to run AIAgent");
         const { toolAgents, messages, ...modelInput } = await this.instructions.build({

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

@@ -21,6 +21,6 @@ export declare class AgentMemory {
     memories: Memory[];
     private subscriptions;
     addMemory(memory: Memory): void;
-    attach(context: Context): void;
+    attach(context: Pick<Context, "subscribe">): void;
     detach(): void;
 }

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

@@ -3,16 +3,17 @@ import type { MessagePayload, MessageQueueListener, Unsubscribe } from "../execu
 import { type PromiseOrValue } from "../utils/type-utils.js";
 import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface UserAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
-    context?: Context;
+    context: Context;
     process?: (input: I, context: Context) => PromiseOrValue<O>;
 }
 export declare class UserAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static from<I extends Message, O extends Message>(options: UserAgentOptions<I, O>): UserAgent<I, O>;
     constructor(options: UserAgentOptions<I, O>);
-    private context?;
+    readonly context: Context;
     private get ctx();
     private _process?;
-    process(input: I, context?: Context): Promise<O>;
+    call(input: string | I, context?: Context): Promise<O>;
+    process(input: I, context: Context): Promise<O>;
     publish(topic: string | string[], message: Message | string): void;
     subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;

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

@@ -16,16 +16,16 @@ export class UserAgent extends Agent {
         return this.context;
     }
     _process;
+    call(input, context) {
+        return super.call(input, context ?? this.context);
+    }
     async process(input, context) {
-        const ctx = context ?? this.context;
-        if (!ctx)
-            throw new Error("UserAgent must have a context");
         if (this._process) {
-            return this._process(input, ctx);
+            return this._process(input, context);
         }
         const publicTopic = typeof this.publishTopic === "function" ? await this.publishTopic(input) : this.publishTopic;
         if (publicTopic?.length) {
-            ctx.publish(publicTopic, input, this);
+            context.publish(publicTopic, input, this);
             return {};
         }
         throw new Error("UserAgent must have a process function or a publishTopic");

package/lib/esm/execution-engine/context.d.ts

@@ -1,11 +1,31 @@
-import type EventEmitter from "node:events";
-import type { Agent, FunctionAgentFn, Message } from "../agents/agent.js";
+import EventEmitter from "node:events";
+import { Agent, type FunctionAgentFn, type Message } from "../agents/agent.js";
+import { UserAgent } from "../agents/user-agent.js";
 import type { ChatModel } from "../models/chat-model.js";
-import type { MessagePayload, MessageQueueListener, Unsubscribe } from "./message-queue.js";
+import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 export type Runnable<I extends Message = Message, O extends Message = Message> = Agent<I, O> | FunctionAgentFn;
+export interface ContextUsage {
+    promptTokens: number;
+    completionTokens: number;
+    agentCalls: number;
+}
+export interface ContextLimits {
+    maxTokens?: number;
+    maxAgentCalls?: number;
+    timeout?: number;
+}
 export interface Context extends EventEmitter {
     model?: ChatModel;
     tools?: Agent[];
+    usage: ContextUsage;
+    limits?: ContextLimits;
+    status?: "normal" | "timeout";
+    /**
+     * Create a user agent to consistently call an agent
+     * @param agent Agent to call
+     * @returns User agent
+     */
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>): UserAgent<I, O>;
     /**
      * Call an agent with a message
      * @param agent Agent to call
@@ -21,11 +41,11 @@ export interface Context extends EventEmitter {
      * @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: {
-        returnActiveAgent?: true;
+        returnActiveAgent: true;
     }): Promise<[O, Runnable]>;
     call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options?: {
         returnActiveAgent?: boolean;
-    }): Promise<O | [O, Runnable]>;
+    }): UserAgent<I, O> | Promise<O | [O, Runnable]>;
     /**
      * Publish a message to a topic, the engine will call the listeners of the topic
      * @param topic topic name, or an array of topic names
@@ -38,3 +58,36 @@ export interface Context extends EventEmitter {
     subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
     unsubscribe(topic: string, listener: MessageQueueListener): void;
 }
+export declare class ExecutionContext extends EventEmitter implements Context {
+    private readonly engine?;
+    constructor(engine?: {
+        model?: ChatModel;
+        tools?: Agent[];
+        limits?: ContextLimits;
+        messageQueue?: MessageQueue;
+        emit?: EventEmitter["emit"];
+    } | undefined);
+    private messageQueue;
+    get model(): ChatModel | undefined;
+    get tools(): Agent<Message, Message>[] | undefined;
+    usage: ContextUsage;
+    limits?: ContextLimits | undefined;
+    private abortController;
+    private timer?;
+    private initTimeout;
+    get status(): "normal" | "timeout";
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>): UserAgent<I, O>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string): Promise<O>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: {
+        returnActiveAgent: true;
+    }): Promise<[O, Runnable]>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: {
+        returnActiveAgent?: boolean;
+    }): UserAgent<I, O> | Promise<O | [O, Runnable]>;
+    publish(topic: string | string[], message: Message | string, from?: Agent): void;
+    subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
+    subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
+    unsubscribe(topic: string, listener: MessageQueueListener): void;
+    emit(eventName: string | symbol, ...args: unknown[]): boolean;
+    private callAgent;
+}