@aigne/core 1.0.17 → 1.1.0-beta.2

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

@@ -0,0 +1,55 @@
+import EventEmitter from "node:events";
+import { type ZodObject, type ZodType } from "zod";
+import type { Context } from "../execution-engine/context";
+import { type TransferAgentOutput } from "./types";
+export type AgentInput = Record<string, unknown>;
+export type AgentOutput = Record<string, unknown> & Partial<TransferAgentOutput>;
+export type SubscribeTopic = string | string[];
+export type PublishTopic<O extends AgentOutput = AgentOutput> = string | string[] | ((output: O) => string | string[] | Promise<string | string[]>);
+export interface AgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> {
+    subscribeTopic?: SubscribeTopic;
+    publishTopic?: PublishTopic<O>;
+    name?: string;
+    description?: string;
+    inputSchema?: ZodObject<{
+        [key in keyof I]: ZodType;
+    }>;
+    outputSchema?: ZodObject<{
+        [key in keyof O]: ZodType;
+    }>;
+    includeInputInOutput?: boolean;
+    tools?: (Agent | FunctionAgentFn)[];
+}
+export declare class Agent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends EventEmitter {
+    static from<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput>(options: AgentOptions<I, O>): Agent<I, O>;
+    constructor(options: AgentOptions<I, O>);
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: ZodObject<{
+        [key in keyof I]: ZodType;
+    }>;
+    readonly outputSchema: ZodObject<{
+        [key in keyof O]: ZodType;
+    }>;
+    readonly includeInputInOutput?: boolean;
+    readonly subscribeTopic?: SubscribeTopic;
+    readonly publishTopic?: PublishTopic<AgentOutput>;
+    readonly tools: Agent<AgentInput, AgentOutput>[] & {
+        [key: string]: Agent<AgentInput, AgentOutput>;
+    };
+    addTool<I extends AgentInput, O extends AgentOutput>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
+    get isCallable(): boolean;
+    call(input: I | string, context?: Context): Promise<O>;
+    process?(input: I, context?: Context): Promise<O>;
+    shutdown(): Promise<void>;
+}
+export interface FunctionAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+    fn?: FunctionAgentFn<I, O>;
+}
+export declare class FunctionAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
+    static from<I extends AgentInput, O extends AgentOutput>(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<O>;
+}
+export type FunctionAgentFn<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> = (input: I, context?: Context) => O | Promise<O> | Agent | Promise<Agent>;

package/lib/cjs/agents/agent.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionAgent = exports.Agent = void 0;
+const node_events_1 = __importDefault(require("node:events"));
+const zod_1 = require("zod");
+const prompt_builder_1 = require("../prompt/prompt-builder");
+const logger_1 = require("../utils/logger");
+const types_1 = require("./types");
+class Agent extends node_events_1.default {
+    static from(options) {
+        return new Agent(options);
+    }
+    constructor(options) {
+        super();
+        this.name = options.name || this.constructor.name;
+        this.description = options.description;
+        this.inputSchema =
+            options.inputSchema || zod_1.z.object({});
+        this.outputSchema =
+            options.outputSchema || zod_1.z.object({});
+        this.includeInputInOutput = options.includeInputInOutput;
+        this.subscribeTopic = options.subscribeTopic;
+        this.publishTopic = options.publishTopic;
+        if (options.tools?.length)
+            this.tools.push(...options.tools.map(functionToAgent));
+    }
+    name;
+    description;
+    inputSchema;
+    outputSchema;
+    includeInputInOutput;
+    subscribeTopic;
+    publishTopic;
+    tools = new Proxy([], {
+        get: (t, p, r) => Reflect.get(t, p, r) ?? t.find((t) => t.name === p),
+    });
+    addTool(tool) {
+        this.tools.push(typeof tool === "function" ? functionToAgent(tool) : tool);
+    }
+    get isCallable() {
+        return !!this.process;
+    }
+    async call(input, context) {
+        if (!this.process)
+            throw new Error("Agent must implement process method");
+        const _input = typeof input === "string" ? (0, prompt_builder_1.userInput)(input) : input;
+        const parsedInput = this.inputSchema.passthrough().parse(_input);
+        logger_1.logger.debug(`Call agent ${this.name} start`, parsedInput);
+        const output = await this.process(parsedInput, context);
+        const parsedOutput = this.outputSchema.passthrough().parse(output);
+        const finalOutput = this.includeInputInOutput
+            ? { ...parsedInput, ...parsedOutput }
+            : parsedOutput;
+        logger_1.logger.debug(`Call agent ${this.name} successfully`, {
+            ...finalOutput,
+            ...(finalOutput[types_1.transferAgentOutputKey]
+                ? { [types_1.transferAgentOutputKey]: finalOutput[types_1.transferAgentOutputKey].agent.name }
+                : {}),
+        });
+        return finalOutput;
+    }
+    async shutdown() { }
+}
+exports.Agent = Agent;
+class FunctionAgent extends Agent {
+    static from(options) {
+        return typeof options === "function" ? functionToAgent(options) : new FunctionAgent(options);
+    }
+    constructor(options) {
+        super(options);
+        this.fn = options.fn ?? (() => ({}));
+    }
+    fn;
+    async process(input, context) {
+        const result = await this.fn(input, context);
+        if (result instanceof Agent) {
+            return (0, types_1.transferToAgentOutput)(result);
+        }
+        return result;
+    }
+}
+exports.FunctionAgent = FunctionAgent;
+function functionToAgent(agent) {
+    if (typeof agent === "function") {
+        return FunctionAgent.from({ name: agent.name, fn: agent });
+    }
+    return agent;
+}

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

@@ -0,0 +1,20 @@
+import type { Context } from "../execution-engine/context";
+import type { ChatModel } from "../models/chat";
+import { PromptBuilder } from "../prompt/prompt-builder";
+import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
+export interface AIAgentOptions<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends AgentOptions<I, O> {
+    model?: ChatModel;
+    instructions?: string | PromptBuilder;
+    outputKey?: string;
+    toolChoice?: AIAgentToolChoice;
+}
+export type AIAgentToolChoice = "auto" | "none" | "required" | "router" | Agent;
+export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
+    static from<I extends AgentInput, O extends AgentOutput>(options: AIAgentOptions<I, O>): AIAgent<I, O>;
+    constructor(options: AIAgentOptions<I, O>);
+    model?: ChatModel;
+    instructions: PromptBuilder;
+    outputKey?: string;
+    toolChoice?: AIAgentToolChoice;
+    process(input: I, context?: Context): Promise<O>;
+}

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIAgent = void 0;
+const prompt_builder_1 = require("../prompt/prompt-builder");
+const template_1 = require("../prompt/template");
+const agent_1 = require("./agent");
+const types_1 = require("./types");
+const DEFAULT_OUTPUT_KEY = "text";
+class AIAgent extends agent_1.Agent {
+    static from(options) {
+        return new AIAgent(options);
+    }
+    constructor(options) {
+        super(options);
+        this.model = options.model;
+        this.instructions =
+            typeof options.instructions === "string"
+                ? prompt_builder_1.PromptBuilder.from(options.instructions)
+                : (options.instructions ?? new prompt_builder_1.PromptBuilder());
+        this.outputKey = options.outputKey;
+        this.toolChoice = options.toolChoice;
+    }
+    model;
+    instructions;
+    outputKey;
+    toolChoice;
+    async process(input, context) {
+        const model = context?.model ?? this.model;
+        if (!model)
+            throw new Error("model is required to run AIAgent");
+        let transferOutput;
+        const { toolAgents, ...modelInput } = await this.instructions.build({
+            agent: this,
+            input,
+            model,
+            context,
+        });
+        const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
+        for (;;) {
+            const { text, json, toolCalls } = await model.call(modelInput, context);
+            if (toolCalls?.length) {
+                const executedToolCalls = [];
+                for (const call of toolCalls) {
+                    const tool = toolsMap.get(call.function.name);
+                    if (!tool)
+                        throw new Error(`Tool not found: ${call.function.name}`);
+                    const output = await tool.call(call.function.arguments, context);
+                    // Save the TransferAgentOutput for later
+                    if ((0, types_1.isTransferAgentOutput)(output)) {
+                        transferOutput = output;
+                    }
+                    else {
+                        executedToolCalls.push({ call, output });
+                    }
+                }
+                if (this.toolChoice === "router") {
+                    const output = executedToolCalls[0]?.output;
+                    if (!output || executedToolCalls.length !== 1) {
+                        throw new Error("Router toolChoice requires exactly one tool to be executed");
+                    }
+                    return output;
+                }
+                // Continue LLM function calling loop if any tools were executed
+                if (executedToolCalls.length) {
+                    modelInput.messages.push(template_1.AgentMessageTemplate.from(executedToolCalls.map(({ call }) => call)).format());
+                    modelInput.messages.push(...executedToolCalls.map(({ call, output }) => template_1.ToolMessageTemplate.from(output, call.id).format()));
+                    continue;
+                }
+            }
+            const result = {};
+            if (modelInput.responseFormat?.type === "json_schema") {
+                Object.assign(result, json);
+            }
+            else {
+                const outputKey = this.outputKey || DEFAULT_OUTPUT_KEY;
+                Object.assign(result, { [outputKey]: text });
+            }
+            // Return the TransferAgentOutput if it exists
+            if (transferOutput) {
+                result[types_1.transferAgentOutputKey] = transferOutput[types_1.transferAgentOutputKey];
+            }
+            return result;
+        }
+    }
+}
+exports.AIAgent = AIAgent;

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

@@ -0,0 +1,27 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
+export interface MCPAgentOptions extends AgentOptions {
+    client: Client;
+}
+export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
+export type SSEServerParameters = {
+    url: string;
+};
+export declare class MCPAgent extends Agent {
+    static from(options: MCPServerOptions): Promise<MCPAgent>;
+    static from(options: MCPAgentOptions): MCPAgent;
+    private static fromTransport;
+    constructor(options: MCPAgentOptions);
+    private client;
+    shutdown(): Promise<void>;
+}
+export interface MCPToolOptions extends AgentOptions {
+    client: Client;
+}
+export declare class MCPTool extends Agent {
+    constructor(options: MCPToolOptions);
+    private client;
+    private get mcpServer();
+    process(input: AgentInput): Promise<AgentOutput>;
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPTool = exports.MCPAgent = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const json_schema_to_zod_1 = require("@n8n/json-schema-to-zod");
+const zod_1 = require("zod");
+const logger_1 = require("../utils/logger");
+const agent_1 = require("./agent");
+const MCP_AGENT_CLIENT_NAME = "MCPAgent";
+const MCP_AGENT_CLIENT_VERSION = "0.0.1";
+const debug = logger_1.logger.base.extend("mcp-agent:debug", "/");
+function isSSEServerParameters(options) {
+    return "url" in options && typeof options.url === "string";
+}
+function isStdioServerParameters(options) {
+    return "command" in options && typeof options.command === "string";
+}
+class MCPAgent extends agent_1.Agent {
+    static from(options) {
+        if (isSSEServerParameters(options)) {
+            const transport = new sse_js_1.SSEClientTransport(new URL(options.url));
+            return MCPAgent.fromTransport(transport);
+        }
+        if (isStdioServerParameters(options)) {
+            const transport = new stdio_js_1.StdioClientTransport(options);
+            return MCPAgent.fromTransport(transport);
+        }
+        return new MCPAgent(options);
+    }
+    static async fromTransport(transport) {
+        const client = new index_js_1.Client({
+            name: MCP_AGENT_CLIENT_NAME,
+            version: MCP_AGENT_CLIENT_VERSION,
+        });
+        debug(`Connecting to MCP server with transport ${transport.constructor.name}`);
+        await client.connect(transport);
+        debug(`Connected to MCP server with transport ${transport.constructor.name}`);
+        const mcpServer = getMCPServerName(client);
+        debug(`Listing tools from ${mcpServer}`);
+        const { tools: mcpTools } = await client.listTools();
+        debug(`Listed tools from ${mcpServer}`, mcpTools.map((i) => i.name));
+        const tools = mcpTools.map((tool) => {
+            return new MCPTool({
+                client,
+                name: tool.name,
+                description: tool.description,
+                inputSchema: (0, json_schema_to_zod_1.jsonSchemaToZod)(tool.inputSchema),
+                outputSchema: zod_1.z
+                    .object({
+                    _meta: zod_1.z.record(zod_1.z.unknown()).optional(),
+                    content: zod_1.z.array(zod_1.z.record(zod_1.z.unknown())),
+                    isError: zod_1.z.boolean().optional(),
+                })
+                    .passthrough(),
+            });
+        });
+        return new MCPAgent({ client, tools });
+    }
+    constructor(options) {
+        super(options);
+        this.client = options.client;
+    }
+    client;
+    async shutdown() {
+        super.shutdown();
+        await this.client.close();
+    }
+}
+exports.MCPAgent = MCPAgent;
+class MCPTool extends agent_1.Agent {
+    constructor(options) {
+        super(options);
+        this.client = options.client;
+    }
+    client;
+    get mcpServer() {
+        return getMCPServerName(this.client);
+    }
+    async process(input) {
+        debug(`Start call tool ${this.name} from ${this.mcpServer} with input`, input);
+        const result = await this.client.callTool({ name: this.name, arguments: input });
+        debug(`End call tool ${this.name} from ${this.mcpServer} with result`, result);
+        return result;
+    }
+}
+exports.MCPTool = MCPTool;
+function getMCPServerName(client) {
+    const info = client.getServerVersion();
+    if (!info)
+        return undefined;
+    const { name, version } = info;
+    return `${name}@${version}`;
+}

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

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

package/lib/cjs/agents/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferAgentOutputKey = void 0;
+exports.transferToAgentOutput = transferToAgentOutput;
+exports.isTransferAgentOutput = isTransferAgentOutput;
+exports.transferAgentOutputKey = "$transferAgentTo";
+function transferToAgentOutput(agent) {
+    return {
+        [exports.transferAgentOutputKey]: {
+            agent,
+        },
+    };
+}
+function isTransferAgentOutput(output) {
+    return exports.transferAgentOutputKey in output;
+}

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

@@ -0,0 +1,10 @@
+import type EventEmitter from "node:events";
+import type { Agent, AgentInput, AgentOutput } from "../agents/agent";
+import type { ChatModel } from "../models/chat";
+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;
+}

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

@@ -0,0 +1,45 @@
+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>;
+}
+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>;
+}

package/lib/cjs/execution-engine/index.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAgent = exports.ExecutionEngine = void 0;
+const node_events_1 = __importDefault(require("node:events"));
+const nanoid_1 = require("nanoid");
+const agent_1 = require("../agents/agent");
+const types_1 = require("../agents/types");
+const prompt_builder_1 = require("../prompt/prompt-builder");
+const type_utils_1 = require("../utils/type-utils");
+const message_queue_1 = require("./message-queue");
+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);
+    }
+    messageQueue = new message_queue_1.MessageQueue();
+    model;
+    tools;
+    agents = [];
+    agentListeners = new Map();
+    addAgent(...agents) {
+        for (const agent of agents) {
+            this.agents.push(agent);
+            this.attachAgentSubscriptions(agent);
+        }
+    }
+    attachAgentSubscriptions(agent) {
+        for (const topic of (0, type_utils_1.orArrayToArray)(agent.subscribeTopic)) {
+            const listener = async (input) => {
+                try {
+                    const { output } = await this.callAgent(input, agent);
+                    const topics = typeof agent.publishTopic === "function"
+                        ? await agent.publishTopic(output)
+                        : agent.publishTopic;
+                    for (const topic of (0, type_utils_1.orArrayToArray)(topics)) {
+                        this.publish(topic, output);
+                    }
+                }
+                catch (error) {
+                    this.emit("error", error);
+                }
+            };
+            this.subscribe(topic, listener);
+            const listeners = this.agentListeners.get(agent) || [];
+            listeners.push({ topic, listener });
+            this.agentListeners.set(agent, listeners);
+        }
+    }
+    publish(topic, message) {
+        this.messageQueue.emit(topic, message);
+    }
+    subscribe(topic, listener) {
+        this.messageQueue.on(topic, listener);
+    }
+    unsubscribe(topic, listener) {
+        this.messageQueue.off(topic, listener);
+    }
+    async run(_input, _options, ..._agents) {
+        if (_input instanceof agent_1.Agent)
+            return this.runChatLoop(_input);
+        const [options, agents] = this.splitOptionsAndAgents(_options, ..._agents);
+        const input = typeof _input === "string" ? (0, prompt_builder_1.userInput)(_input) : _input;
+        if (agents.length === 0)
+            return this.publishUserInputTopic(input);
+        if (options?.concurrency)
+            return this.runParallel(input, ...agents);
+        return this.runSequential(input, ...agents);
+    }
+    splitOptionsAndAgents(options, ...agents) {
+        if (options instanceof agent_1.Agent) {
+            return [{}, [options, ...agents]];
+        }
+        return [options, agents];
+    }
+    async runSequential(input, ...agents) {
+        const output = {};
+        for (const agent of agents.flat()) {
+            const { output: o } = await this.callAgent({ ...input, ...output }, agent);
+            Object.assign(output, o);
+        }
+        return output;
+    }
+    async runParallel(input, ...agents) {
+        const outputs = await Promise.all(agents.map((agent) => this.callAgent(input, agent).then((res) => res.output)));
+        return Object.assign({}, ...outputs);
+    }
+    async publishUserInputTopic(input) {
+        this.publish(message_queue_1.UserInputTopic, input);
+        // TODO: 处理超时、错误、无限循环、饿死等情况
+        const result = await new Promise((resolve) => {
+            this.messageQueue.on(message_queue_1.UserOutputTopic, (result) => resolve(result));
+        });
+        return result;
+    }
+    async runChatLoop(agent) {
+        const inputStream = new TransformStream({});
+        const inputWriter = inputStream.writable.getWriter();
+        const userAgent = new UserAgent({
+            async run(input) {
+                const wait = Promise.withResolvers();
+                inputWriter.write({ ...wait, input });
+                return wait.promise;
+            },
+        });
+        // Run the loop in a separate async function, so that we can return the userAgent
+        (async () => {
+            let activeAgent = agent;
+            const reader = inputStream.readable.getReader();
+            for (;;) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                const { input, resolve } = value;
+                const { agent, output } = await this.callAgent(input, activeAgent);
+                if (agent)
+                    activeAgent = agent;
+                resolve(output);
+            }
+        })();
+        return userAgent;
+    }
+    async callAgent(input, agent) {
+        let activeAgent = agent;
+        let output;
+        for (;;) {
+            output = await activeAgent.call(input, this);
+            if ((0, types_1.isTransferAgentOutput)(output)) {
+                // TODO: 不要修改原始对象，可能被外部丢弃
+                const transferToolCallId = (0, nanoid_1.nanoid)();
+                Object.assign(input, (0, prompt_builder_1.addMessagesToInput)(input, [
+                    {
+                        role: "agent",
+                        name: agent.name,
+                        toolCalls: [
+                            {
+                                id: transferToolCallId,
+                                type: "function",
+                                function: {
+                                    name: "transfer_to_agent",
+                                    arguments: {
+                                        to: output[types_1.transferAgentOutputKey].agent.name,
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                    {
+                        role: "tool",
+                        toolCallId: transferToolCallId,
+                        content: `Transferred to ${output[types_1.transferAgentOutputKey].agent.name}. Adopt persona immediately.`,
+                    },
+                ]));
+                activeAgent = output[types_1.transferAgentOutputKey].agent;
+            }
+            else {
+                break;
+            }
+        }
+        return {
+            agent: activeAgent,
+            output,
+        };
+    }
+    async shutdown() {
+        for (const tool of this.tools) {
+            await tool.shutdown();
+        }
+        for (const agent of this.agents) {
+            await agent.shutdown();
+        }
+    }
+}
+exports.ExecutionEngine = ExecutionEngine;
+class UserAgent extends agent_1.Agent {
+    options;
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    process(input) {
+        return this.options.run(input);
+    }
+}
+exports.UserAgent = UserAgent;

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

@@ -0,0 +1,5 @@
+import { EventEmitter } from "node:events";
+export declare const UserInputTopic = "UserInputTopic";
+export declare const UserOutputTopic = "UserOutputTopic";
+export declare class MessageQueue extends EventEmitter {
+}

package/lib/cjs/execution-engine/message-queue.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueue = exports.UserOutputTopic = exports.UserInputTopic = void 0;
+const node_events_1 = require("node:events");
+exports.UserInputTopic = "UserInputTopic";
+exports.UserOutputTopic = "UserOutputTopic";
+class MessageQueue extends node_events_1.EventEmitter {
+}
+exports.MessageQueue = MessageQueue;