@aigne/core 1.5.0 → 1.5.1-1

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

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionAgent = exports.Agent = void 0;
 const zod_1 = require("zod");
@@ -69,7 +102,7 @@ class Agent {
     attach(context) {
         this.memory?.attach(context);
         for (const topic of (0, type_utils_js_1.orArrayToArray)(this.subscribeTopic).concat(this.topic)) {
-            context.subscribe(topic, async ({ message }) => {
+            context.subscribe(topic, async ({ message, context }) => {
                 try {
                     await context.call(this, message);
                 }
@@ -85,26 +118,54 @@ 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 Promise.resolve().then(() => __importStar(require("../execution-engine/context.js"))).then((m) => new m.ExecutionContext());
+    }
     async call(input, context) {
+        const ctx = context ?? (await this.newDefaultContext());
         const _input = typeof input === "string" ? (0, prompt_builder_js_1.createMessage)(input) : input;
         const parsedInput = this.inputSchema.parse(_input);
         logger_js_1.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: (0, types_js_1.replaceTransferAgentToName)(output),
-                source: this.name,
-            });
+            this.postprocess(parsedInput, output, ctx);
             return output;
         });
         return logger_js_1.logger.debug.spinner(result, `Call agent ${this.name}`, (output) => logger_js_1.logger.debug("Call agent %s succeed with output: %O", this.name, (0, types_js_1.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: (0, types_js_1.replaceTransferAgentToName)(output),
+            source: this.name,
+        });
+    }
     async shutdown() {
         this.memory?.detach();
     }

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

@@ -50,9 +50,7 @@ class AIAgent extends agent_js_1.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/cjs/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/cjs/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/cjs/agents/user-agent.js

@@ -19,16 +19,16 @@ class UserAgent extends agent_js_1.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/cjs/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/cjs/execution-engine/context.js

@@ -1,2 +1,171 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionContext = void 0;
+const node_events_1 = __importDefault(require("node:events"));
+const zod_1 = require("zod");
+const agent_js_1 = require("../agents/agent.js");
+const types_js_1 = require("../agents/types.js");
+const user_agent_js_1 = require("../agents/user-agent.js");
+const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
+const message_queue_js_1 = require("./message-queue.js");
+class ExecutionContext extends node_events_1.default {
+    engine;
+    constructor(engine) {
+        super();
+        this.engine = engine;
+        this.limits = engine?.limits;
+        this.messageQueue = engine?.messageQueue ?? new message_queue_js_1.MessageQueue();
+    }
+    messageQueue;
+    get model() {
+        return this.engine?.model;
+    }
+    get tools() {
+        return this.engine?.tools;
+    }
+    usage = {
+        promptTokens: 0,
+        completionTokens: 0,
+        agentCalls: 0,
+    };
+    limits;
+    abortController = new AbortController();
+    timer;
+    initTimeout() {
+        if (this.timer)
+            return;
+        const timeout = this.limits?.timeout;
+        if (timeout) {
+            this.timer = setTimeout(() => {
+                this.abortController.abort();
+            }, timeout);
+        }
+    }
+    get status() {
+        return this.abortController.signal.aborted ? "timeout" : "normal";
+    }
+    call(agent, message, options) {
+        (0, type_utils_js_1.checkArguments)("ExecutionEngine._call", executionEngineCallArgsSchema, {
+            agent,
+            message,
+            options,
+        });
+        if ((0, type_utils_js_1.isNil)(message)) {
+            let activeAgent = agent;
+            return user_agent_js_1.UserAgent.from({
+                context: this,
+                process: async (input, context) => {
+                    const [output, agent] = await context.call(activeAgent, input, {
+                        returnActiveAgent: true,
+                    });
+                    activeAgent = agent;
+                    return output;
+                },
+            });
+        }
+        return withAbortSignal(this.abortController.signal, new Error("ExecutionEngine is timeout"), async () => {
+            this.initTimeout();
+            const msg = createMessageFromInput(message);
+            return this.callAgent(agent, msg).then(async ({ output, agent: activeAgent }) => {
+                if (activeAgent instanceof agent_js_1.Agent) {
+                    const publishTopics = typeof activeAgent.publishTopic === "function"
+                        ? await activeAgent.publishTopic(output)
+                        : activeAgent.publishTopic;
+                    if (publishTopics?.length) {
+                        this.publish(publishTopics, output, activeAgent);
+                    }
+                }
+                if (options?.returnActiveAgent) {
+                    return [output, activeAgent];
+                }
+                return output;
+            });
+        });
+    }
+    publish(topic, message, from) {
+        (0, type_utils_js_1.checkArguments)("ExecutionEngineContext.publish", executionEnginePublishArgsSchema, {
+            topic,
+            message,
+            from,
+        });
+        const request = {
+            role: !from || from instanceof user_agent_js_1.UserAgent ? "user" : "agent",
+            source: from?.name,
+            message: createMessageFromInput(message),
+            context: this,
+        };
+        this.messageQueue.publish(topic, request);
+    }
+    subscribe(topic, listener) {
+        return this.messageQueue.subscribe(topic, listener);
+    }
+    unsubscribe(topic, listener) {
+        this.messageQueue.unsubscribe(topic, listener);
+    }
+    emit(eventName, ...args) {
+        if (this.engine?.emit)
+            return this.engine.emit(eventName, ...args);
+        return super.emit(eventName, ...args);
+    }
+    async callAgent(agent, input) {
+        let activeAgent = agent;
+        let output;
+        for (;;) {
+            let result;
+            if (typeof activeAgent === "function") {
+                result = await activeAgent(input, this);
+            }
+            else {
+                result = await activeAgent.call(input, this);
+            }
+            if (!(result instanceof agent_js_1.Agent))
+                output = result;
+            const transferToAgent = result instanceof agent_js_1.Agent
+                ? result
+                : (0, types_js_1.isTransferAgentOutput)(result)
+                    ? result[types_js_1.transferAgentOutputKey].agent
+                    : undefined;
+            if (transferToAgent) {
+                activeAgent = transferToAgent;
+            }
+            else {
+                break;
+            }
+        }
+        if (!output)
+            throw new Error("Unexpected empty output");
+        return {
+            agent: activeAgent,
+            output,
+        };
+    }
+}
+exports.ExecutionContext = ExecutionContext;
+function withAbortSignal(signal, error, fn) {
+    return new Promise((resolve, reject) => {
+        const listener = () => reject(error);
+        signal.addEventListener("abort", listener);
+        fn()
+            .then(resolve, reject)
+            .finally(() => {
+            signal.removeEventListener("abort", listener);
+        });
+    });
+}
+function createMessageFromInput(message) {
+    return typeof message === "string" ? (0, prompt_builder_js_1.createMessage)(message) : message;
+}
+const executionEnginePublishArgsSchema = zod_1.z.object({
+    topic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]),
+    message: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.unknown())]),
+    from: zod_1.z.instanceof(agent_js_1.Agent).optional(),
+});
+const executionEngineCallArgsSchema = 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/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;
 }