@aigne/core 1.1.0-beta.5 → 1.3.0

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

@@ -0,0 +1,26 @@
+import type { Context } from "../execution-engine/context.js";
+import type { Message } from "./agent.js";
+export interface AgentMemoryOptions {
+    /**
+     * Enable memory, default is true
+     */
+    enabled?: boolean;
+    subscribeTopic?: string | string[];
+    maxMemoriesInChat?: number;
+}
+export interface Memory {
+    role: "user" | "agent";
+    content: Message;
+    source?: string;
+}
+export declare class AgentMemory {
+    constructor(options: AgentMemoryOptions);
+    enabled?: boolean;
+    subscribeTopic?: string | string[];
+    maxMemoriesInChat?: number;
+    memories: Memory[];
+    private subscriptions;
+    addMemory(memory: Memory): void;
+    attach(context: Context): void;
+    detach(): void;
+}

package/lib/cjs/agents/memory.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentMemory = void 0;
+const type_utils_js_1 = require("../utils/type-utils.js");
+class AgentMemory {
+    constructor(options) {
+        this.enabled = options.enabled ?? true;
+        this.subscribeTopic = options.subscribeTopic;
+        this.maxMemoriesInChat = options.maxMemoriesInChat;
+    }
+    enabled;
+    subscribeTopic;
+    maxMemoriesInChat;
+    memories = [];
+    subscriptions = [];
+    addMemory(memory) {
+        if (this.memories.at(-1)?.content === memory.content)
+            return;
+        // TODO: save all memories into database instead of in-memory,
+        // and give every memory a unique id to avoid duplication
+        this.memories.push(memory);
+    }
+    attach(context) {
+        for (const topic of (0, type_utils_js_1.orArrayToArray)(this.subscribeTopic)) {
+            const sub = context.subscribe(topic, ({ role, message, source }) => {
+                this.addMemory({ role, source, content: message });
+            });
+            this.subscriptions.push(sub);
+        }
+    }
+    detach() {
+        for (const sub of this.subscriptions) {
+            sub();
+        }
+        this.subscriptions = [];
+    }
+}
+exports.AgentMemory = AgentMemory;

package/lib/cjs/agents/types.d.ts

@@ -1,9 +1,10 @@
-import type { Agent, AgentOutput } from "./agent";
+import type { Agent, Message } from "./agent.js";
 export declare const transferAgentOutputKey = "$transferAgentTo";
-export interface TransferAgentOutput extends Record<string, unknown> {
+export interface TransferAgentOutput extends Message {
     [transferAgentOutputKey]: {
         agent: Agent;
     };
 }
 export declare function transferToAgentOutput(agent: Agent): TransferAgentOutput;
-export declare function isTransferAgentOutput(output: AgentOutput): output is TransferAgentOutput;
+export declare function isTransferAgentOutput(output: Message): output is TransferAgentOutput;
+export declare function replaceTransferAgentToName(output: Message): Message;

package/lib/cjs/agents/types.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transferAgentOutputKey = void 0;
 exports.transferToAgentOutput = transferToAgentOutput;
 exports.isTransferAgentOutput = isTransferAgentOutput;
+exports.replaceTransferAgentToName = replaceTransferAgentToName;
 exports.transferAgentOutputKey = "$transferAgentTo";
 function transferToAgentOutput(agent) {
     return {
@@ -12,5 +13,14 @@ function transferToAgentOutput(agent) {
     };
 }
 function isTransferAgentOutput(output) {
-    return exports.transferAgentOutputKey in output;
+    return !!output[exports.transferAgentOutputKey]?.agent;
+}
+function replaceTransferAgentToName(output) {
+    if (isTransferAgentOutput(output)) {
+        return {
+            ...output,
+            [exports.transferAgentOutputKey]: output[exports.transferAgentOutputKey].agent.name,
+        };
+    }
+    return output;
 }

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

@@ -0,0 +1,24 @@
+import type { Context } from "../execution-engine/context.js";
+import type { MessagePayload, MessageQueueListener, Unsubscribe } 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>;
+}
+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?;
+    private get ctx();
+    private _process?;
+    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;
+    get stream(): ReadableStream<MessagePayload & {
+        topic: string;
+    }>;
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAgent = void 0;
+const type_utils_js_1 = require("../utils/type-utils.js");
+const agent_js_1 = require("./agent.js");
+class UserAgent extends agent_js_1.Agent {
+    static from(options) {
+        return new UserAgent(options);
+    }
+    constructor(options) {
+        super({ ...options, disableLogging: true });
+        this._process = options.process;
+        this.context = options.context;
+    }
+    context;
+    get ctx() {
+        if (!this.context)
+            throw new Error("UserAgent must have a context");
+        return this.context;
+    }
+    _process;
+    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);
+        }
+        const publicTopic = typeof this.publishTopic === "function" ? await this.publishTopic(input) : this.publishTopic;
+        if (publicTopic?.length) {
+            ctx.publish(publicTopic, input, this);
+            return {};
+        }
+        throw new Error("UserAgent must have a process function or a publishTopic");
+    }
+    publish(topic, message) {
+        return this.ctx.publish(topic, message, this);
+    }
+    subscribe(topic, listener) {
+        return this.ctx.subscribe(topic, listener);
+    }
+    unsubscribe(topic, listener) {
+        this.ctx.unsubscribe(topic, listener);
+    }
+    get stream() {
+        let subscriptions = [];
+        return new ReadableStream({
+            start: (controller) => {
+                const subscribeTopic = (0, type_utils_js_1.orArrayToArray)(this.subscribeTopic);
+                subscriptions = subscribeTopic.map((topic) => this.subscribe(topic, (message) => {
+                    controller.enqueue({ ...message, topic });
+                }));
+            },
+            cancel: () => {
+                for (const unsubscribe of subscriptions) {
+                    unsubscribe();
+                }
+            },
+        });
+    }
+}
+exports.UserAgent = UserAgent;

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

@@ -1,10 +1,40 @@
 import type EventEmitter from "node:events";
-import type { Agent, AgentInput, AgentOutput } from "../agents/agent";
-import type { ChatModel } from "../models/chat";
+import type { Agent, FunctionAgentFn, Message } from "../agents/agent.js";
+import type { ChatModel } from "../models/chat-model.js";
+import type { MessagePayload, MessageQueueListener, Unsubscribe } from "./message-queue.js";
+export type Runnable<I extends Message = Message, O extends Message = Message> = Agent<I, O> | FunctionAgentFn;
 export interface Context extends EventEmitter {
     model?: ChatModel;
     tools?: Agent[];
-    publish(topic: string, message: unknown): void;
-    subscribe(topic: string, listener: (message: AgentInput) => void): void;
-    unsubscribe(topic: string, listener: (message: AgentOutput) => void): void;
+    /**
+     * 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;
+    }): 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
+     */
+    publish(topic: string | string[], message: Message | string, from?: Agent): 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;
 }

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

@@ -0,0 +1,64 @@
+import EventEmitter from "node:events";
+import { Agent, type Message } from "../agents/agent.js";
+import { UserAgent } from "../agents/user-agent.js";
+import type { ChatModel } from "../models/chat-model.js";
+import type { Context, 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[];
+}
+export declare class ExecutionEngine extends EventEmitter implements Context {
+    constructor(options?: ExecutionEngineOptions);
+    readonly messageQueue: MessageQueue;
+    model?: ChatModel;
+    tools: Agent[];
+    private agents;
+    addAgent(...agents: Agent[]): void;
+    private createMessageFromInput;
+    /**
+     * 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 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;
+    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/cjs/execution-engine/execution-engine.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionEngine = void 0;
+const node_events_1 = __importDefault(require("node:events"));
+const lodash_es_1 = require("lodash-es");
+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 message_queue_js_1 = require("./message-queue.js");
+class ExecutionEngine extends node_events_1.default {
+    constructor(options) {
+        super();
+        this.model = options?.model;
+        this.tools = options?.tools ?? [];
+        if (options?.agents?.length)
+            this.addAgent(...options.agents);
+        this.initProcessExitHandler();
+    }
+    messageQueue = new message_queue_js_1.MessageQueue();
+    model;
+    tools;
+    agents = [];
+    addAgent(...agents) {
+        for (const agent of agents) {
+            this.agents.push(agent);
+            agent.attach(this);
+        }
+    }
+    createMessageFromInput(message) {
+        return typeof message === "string" ? (0, prompt_builder_js_1.createMessage)(message) : message;
+    }
+    /**
+     * 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, message, from) {
+        const request = {
+            role: !from || from instanceof user_agent_js_1.UserAgent ? "user" : "agent",
+            source: from?.name,
+            message: this.createMessageFromInput(message),
+        };
+        this.messageQueue.publish(topic, request);
+    }
+    call(agent, message, options) {
+        if ((0, lodash_es_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 this._call(agent, this.createMessageFromInput(message)).then((result) => options?.returnActiveAgent ? [result.output, result.agent] : result.output);
+    }
+    /**
+     * 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
+     */
+    async _call(agent, message) {
+        const { output, agent: activeAgent } = await this.callAgent(agent, message);
+        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);
+            }
+        }
+        return { output, agent: activeAgent };
+    }
+    subscribe(topic, listener) {
+        return this.messageQueue.subscribe(topic, listener);
+    }
+    unsubscribe(topic, listener) {
+        this.messageQueue.unsubscribe(topic, listener);
+    }
+    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,
+        };
+    }
+    async shutdown() {
+        for (const tool of this.tools) {
+            await tool.shutdown();
+        }
+        for (const agent of this.agents) {
+            await agent.shutdown();
+        }
+    }
+    initProcessExitHandler() {
+        const shutdownAndExit = () => this.shutdown().finally(() => process.exit(0));
+        process.on("SIGINT", shutdownAndExit);
+        process.on("exit", shutdownAndExit);
+    }
+}
+exports.ExecutionEngine = ExecutionEngine;

package/lib/cjs/execution-engine/index.d.ts

@@ -1,46 +1,4 @@
-import EventEmitter from "node:events";
-import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "../agents/agent";
-import type { ChatModel } from "../models/chat";
-import type { Context } from "./context";
-export interface ExecutionEngineOptions {
-    model?: ChatModel;
-    tools?: Agent[];
-    agents?: Agent[];
-}
-export interface ExecutionEngineRunOptions {
-    concurrency?: boolean;
-}
-export declare class ExecutionEngine extends EventEmitter implements Context {
-    constructor(options?: ExecutionEngineOptions);
-    private messageQueue;
-    model?: ChatModel;
-    tools: Agent[];
-    private agents;
-    private agentListeners;
-    addAgent(...agents: Agent[]): void;
-    private attachAgentSubscriptions;
-    publish(topic: string, message: unknown): void;
-    subscribe(topic: string, listener: (message: AgentOutput) => void): void;
-    unsubscribe(topic: string, listener: (message: AgentOutput) => void): void;
-    run(agent: Agent): Promise<UserAgent>;
-    run(input: AgentInput | string): Promise<AgentOutput>;
-    run(input: AgentInput | string, ...agents: Agent[]): Promise<AgentOutput>;
-    run(input: AgentInput | string, options: ExecutionEngineRunOptions, ...agents: Agent[]): Promise<AgentOutput>;
-    private splitOptionsAndAgents;
-    private runSequential;
-    private runParallel;
-    private publishUserInputTopic;
-    private runChatLoop;
-    private callAgent;
-    shutdown(): Promise<void>;
-    private initProcessExitHandler;
-}
-export declare class UserAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
-    options: AgentOptions<I, O> & {
-        run: (input: I) => Promise<O>;
-    };
-    constructor(options: AgentOptions<I, O> & {
-        run: (input: I) => Promise<O>;
-    });
-    process(input: I): Promise<O>;
-}
+export * from "./context.js";
+export * from "./execution-engine.js";
+export * from "./message-queue.js";
+export * from "./utils.js";