@aigne/core 1.6.0 → 1.8.0

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

@@ -28,6 +28,10 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     memory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodAny, z.ZodAny]>>;
 }, "strip", z.ZodTypeAny, {
     description?: string | undefined;
+    memory?: any;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
     toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
@@ -36,13 +40,13 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
-    includeInputInOutput?: boolean | undefined;
-    subscribeTopic?: string | string[] | undefined;
-    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     disableLogging?: boolean | undefined;
-    memory?: any;
 }, {
     description?: string | undefined;
+    memory?: any;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
     toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
@@ -51,11 +55,7 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
-    includeInputInOutput?: boolean | undefined;
-    subscribeTopic?: string | string[] | undefined;
-    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     disableLogging?: boolean | undefined;
-    memory?: any;
 }>;
 export declare class AIAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static from<I extends Message, O extends Message>(options: AIAgentOptions<I, O>): AIAgent<I, O>;

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

@@ -1,4 +1,5 @@
 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 { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
@@ -15,6 +16,15 @@ export interface MCPAgentOptions extends AgentOptions {
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
     url: string;
+    /**
+     * Additional options to pass to the SSEClientTransport.
+     */
+    opts?: SSEClientTransportOptions;
+    /**
+     * The timeout for requests to the server, in milliseconds.
+     * @default 60000
+     */
+    timeout?: number;
     /**
      * Whether to automatically reconnect to the server if the connection is lost.
      * @default 10 set to 0 to disable automatic reconnection
@@ -31,7 +41,7 @@ export declare class MCPAgent extends Agent {
     static from(options: MCPAgentOptions): MCPAgent;
     private static fromTransport;
     constructor(options: MCPAgentOptions);
-    private client;
+    client: Client;
     readonly prompts: MCPPrompt[] & {
         [key: string]: MCPPrompt;
     };
@@ -44,6 +54,7 @@ export declare class MCPAgent extends Agent {
 }
 export interface ClientWithReconnectOptions {
     transportCreator?: () => PromiseOrValue<Transport>;
+    timeout?: number;
     maxReconnects?: number;
     shouldReconnect?: (error: Error) => boolean;
 }
@@ -60,7 +71,6 @@ export interface MCPBaseOptions<I extends Message = Message, O extends Message =
 export declare abstract class MCPBase<I extends Message, O extends Message> extends Agent<I, O> {
     constructor(options: MCPBaseOptions<I, O>);
     protected client: ClientWithReconnect;
-    protected get mcpServer(): string | undefined;
 }
 export declare class MCPTool extends MCPBase<Message, CallToolResult> {
     process(input: Message): Promise<CallToolResult>;

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

@@ -1,26 +1,26 @@
 import { ReadableStream } from "node:stream/web";
-import type { Context } from "../execution-engine/context.js";
-import type { MessagePayload, MessageQueueListener, Unsubscribe } from "../execution-engine/message-queue.js";
+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 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;
 }
 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>);
-    readonly context: Context;
-    private get ctx();
+    context: Context;
     private _process?;
+    private activeAgent?;
     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;
-    subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
-    unsubscribe(topic: string, listener: MessageQueueListener): void;
+    publish: Context["publish"];
+    subscribe: Context["subscribe"];
+    unsubscribe: Context["unsubscribe"];
     get stream(): ReadableStream<MessagePayload & {
         topic: string;
     }>;
+    protected checkUsageAgentCalls(_context: Context): void;
 }

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

@@ -2,19 +2,36 @@ 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 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 ContextUsage {
-    promptTokens: number;
-    completionTokens: number;
-    agentCalls: number;
+export interface AgentEvent {
+    parentContextId?: string;
+    contextId: string;
+    timestamp: number;
+    agent: Agent;
 }
-export interface ContextLimits {
-    maxTokens?: number;
-    maxAgentCalls?: number;
-    timeout?: number;
+export interface ContextEventMap {
+    agentStarted: [AgentEvent & {
+        input: Message;
+    }];
+    agentSucceed: [AgentEvent & {
+        output: Message;
+    }];
+    agentFailed: [AgentEvent & {
+        error: Error;
+    }];
 }
-export interface Context extends EventEmitter {
+export type ContextEmitEventMap = {
+    [K in keyof ContextEventMap]: OmitPropertiesFromArrayFirstElement<ContextEventMap[K], "contextId" | "parentContextId" | "timestamp">;
+};
+export interface CallOptions {
+    returnActiveAgent?: boolean;
+    disableTransfer?: boolean;
+}
+export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
     model?: ChatModel;
     tools?: Agent[];
     usage: ContextUsage;
@@ -26,13 +43,6 @@ export interface Context extends EventEmitter {
      * @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
-     * @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): Promise<O>;
     /**
      * Call an agent with a message and return the output and the active agent
      * @param agent Agent to call
@@ -40,54 +50,82 @@ export interface Context extends EventEmitter {
      * @param options.returnActiveAgent return the active agent
      * @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: {
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
         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]>;
+    /**
+     * Call an agent with a message
+     * @param agent Agent to call
+     * @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): Promise<O>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: CallOptions): 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
-     * @param message message to publish
-     * @param from the agent who publish the message, if not provided, it will be treated as a user message
+     * @param payload message to publish
      */
-    publish(topic: string | string[], message: Message | string, from?: Agent): void;
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context">): void;
     subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
     subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
     unsubscribe(topic: string, listener: MessageQueueListener): void;
+    /**
+     * Create a child context with the same configuration as the parent context.
+     * If `reset` is true, the child context will have a new state (such as: usage).
+     *
+     * @param options
+     * @param options.reset create a new context with initial state (such as: usage)
+     * @returns new context
+     */
+    newContext(options?: {
+        reset?: boolean;
+    }): 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]);
+    parentId?: string;
+    id: string;
+    readonly internal: ExecutionContextInternal;
+    get model(): ChatModel | undefined;
+    get tools(): Agent<Message, Message>[] | undefined;
+    get limits(): ContextLimits | undefined;
+    get status(): "normal" | "timeout";
+    get usage(): ContextUsage;
+    newContext({ reset }?: {
+        reset?: boolean;
+    }): ExecutionContext;
+    call: Context["call"];
+    publish: Context["publish"];
+    subscribe: Context["subscribe"];
+    unsubscribe: Context["unsubscribe"];
+    emit<K extends keyof ContextEmitEventMap>(eventName: K, ...args: Args<K, ContextEmitEventMap>): boolean;
+    on<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
+    once<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
+    off<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
 }
-export declare class ExecutionContext extends EventEmitter implements Context {
-    private readonly engine?;
-    constructor(engine?: {
-        model?: ChatModel;
-        tools?: Agent[];
-        limits?: ContextLimits;
+declare class ExecutionContextInternal {
+    private readonly parent?;
+    constructor(parent?: (Pick<Context, "model" | "tools" | "limits"> & {
         messageQueue?: MessageQueue;
-        emit?: EventEmitter["emit"];
-    } | undefined);
-    private messageQueue;
+    }) | undefined);
+    readonly messageQueue: MessageQueue;
+    readonly events: EventEmitter<ContextEventMap>;
     get model(): ChatModel | undefined;
     get tools(): Agent<Message, Message>[] | undefined;
+    get limits(): ContextLimits | 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;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, input: I, context: Context, options?: CallOptions): Promise<{
+        agent: Runnable;
+        output: O;
+    }>;
     private callAgent;
 }
+export {};

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

@@ -1,9 +1,8 @@
-import EventEmitter from "node:events";
-import { Agent, type Message } from "../agents/agent.js";
-import type { UserAgent } from "../agents/user-agent.js";
+import { Agent } from "../agents/agent.js";
 import { ChatModel } from "../models/chat-model.js";
-import { type ContextLimits, ExecutionContext, type Runnable } from "./context.js";
-import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
+import { type Context, ExecutionContext } from "./context.js";
+import { MessageQueue } from "./message-queue.js";
+import type { ContextLimits } from "./usage.js";
 export interface ExecutionEngineOptions {
     name?: string;
     description?: string;
@@ -12,7 +11,10 @@ export interface ExecutionEngineOptions {
     agents?: Agent[];
     limits?: ContextLimits;
 }
-export declare class ExecutionEngine extends EventEmitter {
+export interface ExecutionEngineRunOptions {
+    returnActiveAgent?: boolean;
+}
+export declare class ExecutionEngine {
     static load({ path, ...options }: {
         path: string;
     } & ExecutionEngineOptions): Promise<ExecutionEngine>;
@@ -21,52 +23,19 @@ export declare class ExecutionEngine extends EventEmitter {
     description?: string;
     readonly messageQueue: MessageQueue;
     model?: ChatModel;
-    readonly tools: Agent<Message, Message>[] & {
-        [key: string]: Agent<Message, Message>;
+    readonly tools: 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<Message, Message>[] & {
-        [key: string]: Agent<Message, Message>;
+    readonly agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[] & {
+        [key: string]: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>;
     };
     limits?: ContextLimits;
     addAgent(...agents: Agent[]): void;
     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
-     * @param message message to publish
-     * @param from the agent who publish the message, if not provided, it will be treated as a user message
-     */
-    publish(topic: string | string[], message: Message | string, from?: Agent): void;
-    /**
-     * 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
-     * @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): Promise<O>;
-    /**
-     * 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
-     * @param options.returnActiveAgent return the active agent
-     * @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;
-    }): 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]>;
-    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;
+    publish: Context["publish"];
+    call: Context["call"];
+    subscribe: Context["subscribe"];
+    unsubscribe: Context["unsubscribe"];
     shutdown(): Promise<void>;
     private initProcessExitHandler;
 }

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

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import type { Message } from "../agents/agent.js";
 import type { Context } from "./context.js";
 export declare const UserInputTopic = "UserInputTopic";
@@ -9,11 +10,10 @@ export interface MessagePayload {
     context: Context;
 }
 export type MessageQueueListener = (message: MessagePayload) => void;
-export type MessageRequest = MessagePayload;
 export type Unsubscribe = () => void;
 export declare class MessageQueue {
-    private events;
-    publish(topic: string | string[], message: MessageRequest): void;
+    events: EventEmitter<[never]>;
+    publish(topic: string | string[], payload: MessagePayload): void;
     error(error: Error): void;
     subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;

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

@@ -0,0 +1,11 @@
+export interface ContextUsage {
+    inputTokens: number;
+    outputTokens: number;
+    agentCalls: number;
+}
+export declare function newEmptyContextUsage(): ContextUsage;
+export interface ContextLimits {
+    maxTokens?: number;
+    maxAgentCalls?: number;
+    timeout?: number;
+}

package/lib/dts/loader/agent-yaml.d.ts

@@ -10,6 +10,7 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     }, {
         [x: string]: any;
     }> | undefined;
+    tool_choice?: "auto" | "none" | "required" | "router" | undefined;
     output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {

package/lib/dts/loader/index.d.ts

@@ -1,5 +1,6 @@
+import { z } from "zod";
 import { type Agent } from "../agents/agent.js";
-import type { ChatModel } from "../models/chat-model.js";
+import type { ChatModel, ChatModelOptions } from "../models/chat-model.js";
 export interface LoadOptions {
     path: string;
 }
@@ -19,6 +20,75 @@ export declare function load(options: LoadOptions): Promise<{
     } | null | undefined;
 }>;
 export declare function loadAgent(path: string): Promise<Agent>;
+export declare function loadModel(model?: z.infer<typeof aigneFileSchema>["chat_model"], modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
+declare const aigneFileSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    chat_model: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        top_p: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        frequent_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        presence_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    }, {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    }>]>>>, {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined, string | {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined>;
+    agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    description?: string | null | undefined;
+    tools?: string[] | null | undefined;
+    name?: string | null | undefined;
+    chat_model?: {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined;
+    agents?: string[] | null | undefined;
+}, {
+    description?: string | null | undefined;
+    tools?: string[] | null | undefined;
+    name?: string | null | undefined;
+    chat_model?: string | {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined;
+    agents?: string[] | null | undefined;
+}>;
 export declare function loadAIGNEFile(path: string): Promise<{
     description?: string | null | undefined;
     tools?: string[] | null | undefined;
@@ -33,3 +103,4 @@ export declare function loadAIGNEFile(path: string): Promise<{
     } | null | undefined;
     agents?: string[] | null | undefined;
 }>;
+export {};

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

@@ -75,6 +75,7 @@ export interface ChatModelOutput extends Message {
     json?: object;
     toolCalls?: ChatModelOutputToolCall[];
     usage?: ChatModelOutputUsage;
+    model?: string;
 }
 export interface ChatModelOutputToolCall {
     id: string;
@@ -85,6 +86,6 @@ export interface ChatModelOutputToolCall {
     };
 }
 export interface ChatModelOutputUsage {
-    promptTokens: number;
-    completionTokens: number;
+    inputTokens: number;
+    outputTokens: number;
 }

package/lib/dts/prompt/prompt-builder.d.ts

@@ -7,7 +7,7 @@ import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
 export declare const DEFAULT_MAX_HISTORY_MESSAGES = 10;
-export declare function createMessage(message: string | object): Message;
+export declare function createMessage<I extends Message>(message: string | I): I;
 export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;

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

@@ -1,20 +1,8 @@
-import debug, { type Debugger } from "debug";
-import type { Ora } from "ora";
-interface DebugWithSpinner extends Debugger {
-    spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void, options?: {
-        disabled?: boolean;
-    }): Promise<T>;
-    extend: (namespace: string) => DebugWithSpinner;
-}
-declare function spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void): Promise<T>;
+import debug from "debug";
 export declare const logger: debug.Debug & {
     debug: debug.Debug;
     default: debug.Debug;
 } & {
-    globalSpinner: Ora | undefined;
-    base: DebugWithSpinner;
-    debug: DebugWithSpinner;
-    spinner: typeof spinner;
-    setSpinner: (spinner: Ora) => void;
+    core: debug.Debugger;
+    mcp: debug.Debugger;
 };
-export {};

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

@@ -1,6 +1,7 @@
 import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 export type Nullish<T> = T | null | undefined;
+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 isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;

package/lib/dts/utils/typed-event-emtter.d.ts

@@ -0,0 +1,10 @@
+type EventMap<T> = Record<keyof T, unknown[]>;
+export type Args<K, T> = K extends keyof T ? T[K] : never;
+export type Listener<K, T> = K extends keyof T ? T[K] extends unknown[] ? (...args: T[K]) => void : never : never;
+export interface TypedEventEmitter<T extends EventMap<T>, E extends EventMap<E> = T> {
+    emit<K extends keyof E>(eventName: K, ...args: Args<K, E>): boolean;
+    on<K extends keyof T>(eventName: K, listener: Listener<K, T>): this;
+    once<K extends keyof T>(eventName: K, listener: Listener<K, T>): this;
+    off<K extends keyof T>(eventName: K, listener: Listener<K, T>): this;
+}
+export {};

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

@@ -1,3 +1,4 @@
+import { inspect } from "node:util";
 import { type ZodType } from "zod";
 import type { Context } from "../execution-engine/context.js";
 import { type Nullish, type PromiseOrValue } from "../utils/type-utils.js";
@@ -15,7 +16,7 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
     outputSchema?: AgentInputOutputSchema<O>;
     includeInputInOutput?: boolean;
     tools?: (Agent | FunctionAgentFn)[];
-    disableLogging?: boolean;
+    disableEvents?: boolean;
     memory?: AgentMemory | AgentMemoryOptions | true;
 }
 export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
@@ -37,7 +38,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     readonly tools: Agent<Message, Message>[] & {
         [key: string]: Agent<Message, Message>;
     };
-    private disableLogging?;
+    private disableEvents?;
     /**
      * Attach agent to context:
      * - subscribe to topic and call process method when message received
@@ -50,10 +51,12 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     private checkContextStatus;
     private newDefaultContext;
     call(input: I | string, context?: Context): Promise<O>;
+    protected checkUsageAgentCalls(context: Context): void;
     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>;
+    [inspect.custom](): string;
 }
 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> {