@aigne/core 1.1.0-beta.6 → 1.3.1

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

@@ -1,188 +1,4 @@
-import EventEmitter from "node:events";
-import { nanoid } from "nanoid";
-import { Agent } from "../agents/agent";
-import { isTransferAgentOutput, transferAgentOutputKey } from "../agents/types";
-import { addMessagesToInput, userInput } from "../prompt/prompt-builder";
-import { orArrayToArray } from "../utils/type-utils";
-import { MessageQueue, UserInputTopic, UserOutputTopic } from "./message-queue";
-export class ExecutionEngine extends EventEmitter {
-    constructor(options) {
-        super();
-        this.model = options?.model;
-        this.tools = options?.tools ?? [];
-        if (options?.agents?.length)
-            this.addAgent(...options.agents);
-        this.initProcessExitHandler();
-    }
-    messageQueue = new 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 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 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)
-            return this.runChatLoop(_input);
-        const [options, agents] = this.splitOptionsAndAgents(_options, ..._agents);
-        const input = typeof _input === "string" ? 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) {
-            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(UserInputTopic, input);
-        // TODO: 处理超时、错误、无限循环、饿死等情况
-        const result = await new Promise((resolve) => {
-            this.messageQueue.on(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 (isTransferAgentOutput(output)) {
-                // TODO: 不要修改原始对象，可能被外部丢弃
-                const transferToolCallId = nanoid();
-                Object.assign(input, addMessagesToInput(input, [
-                    {
-                        role: "agent",
-                        name: agent.name,
-                        toolCalls: [
-                            {
-                                id: transferToolCallId,
-                                type: "function",
-                                function: {
-                                    name: "transfer_to_agent",
-                                    arguments: {
-                                        to: output[transferAgentOutputKey].agent.name,
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                    {
-                        role: "tool",
-                        toolCallId: transferToolCallId,
-                        content: `Transferred to ${output[transferAgentOutputKey].agent.name}. Adopt persona immediately.`,
-                    },
-                ]));
-                activeAgent = output[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();
-        }
-    }
-    initProcessExitHandler() {
-        const shutdownAndExit = () => this.shutdown().finally(() => process.exit(0));
-        process.on("SIGINT", shutdownAndExit);
-        process.on("exit", shutdownAndExit);
-    }
-}
-export class UserAgent extends Agent {
-    options;
-    constructor(options) {
-        super({ ...options, disableLogging: true });
-        this.options = options;
-    }
-    process(input) {
-        return this.options.run(input);
-    }
-}
+export * from "./context.js";
+export * from "./execution-engine.js";
+export * from "./message-queue.js";
+export * from "./utils.js";

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

@@ -1,5 +1,20 @@
-import { EventEmitter } from "node:events";
+import type { Message } from "../agents/agent.js";
 export declare const UserInputTopic = "UserInputTopic";
 export declare const UserOutputTopic = "UserOutputTopic";
-export declare class MessageQueue extends EventEmitter {
+export interface MessagePayload {
+    role: "user" | "agent";
+    source?: string;
+    message: Message;
+}
+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;
+    error(error: Error): 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/esm/execution-engine/message-queue.js

@@ -1,5 +1,41 @@
 import { EventEmitter } from "node:events";
+import { orArrayToArray } from "../utils/type-utils.js";
 export const UserInputTopic = "UserInputTopic";
 export const UserOutputTopic = "UserOutputTopic";
-export class MessageQueue extends EventEmitter {
+export class MessageQueue {
+    events = new EventEmitter();
+    publish(topic, message) {
+        for (const t of orArrayToArray(topic)) {
+            this.events.emit(t, message);
+        }
+    }
+    error(error) {
+        this.events.emit("error", error);
+    }
+    subscribe(topic, listener) {
+        if (!listener) {
+            return new Promise((resolve, reject) => {
+                const unsubscribe1 = once(this.events, topic, (message) => {
+                    unsubscribe2();
+                    resolve(message);
+                });
+                const unsubscribe2 = once(this.events, "error", (error) => {
+                    unsubscribe1();
+                    reject(error);
+                });
+            });
+        }
+        return on(this.events, topic, listener);
+    }
+    unsubscribe(topic, listener) {
+        this.events.off(topic, listener);
+    }
+}
+function on(events, event, listener) {
+    events.on(event, listener);
+    return () => events.off(event, listener);
+}
+function once(events, event, listener) {
+    events.once(event, listener);
+    return () => events.off(event, listener);
 }

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

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

package/lib/esm/execution-engine/utils.js

@@ -0,0 +1,28 @@
+export function sequential(..._agents) {
+    let agents = [..._agents];
+    return async (input, context) => {
+        if (!context)
+            throw new Error("Context is required for executing sequential agents. Please provide a valid context.");
+        const output = {};
+        // Clone the agents to run, so that we can update the agents list during the loop
+        const agentsToRun = [...agents];
+        agents = [];
+        for (const agent of agentsToRun) {
+            const [o, transferToAgent] = await context.call(agent, { ...input, ...output }, { returnActiveAgent: true });
+            Object.assign(output, o);
+            agents.push(transferToAgent);
+        }
+        return output;
+    };
+}
+export function parallel(..._agents) {
+    let agents = [..._agents];
+    return async (input, context) => {
+        if (!context)
+            throw new Error("Context is required for executing parallel agents. Please provide a valid context.");
+        const result = await Promise.all(agents.map((agent) => context.call(agent, input, { returnActiveAgent: true })));
+        agents = result.map((i) => i[1]);
+        const outputs = result.map((i) => i[0]);
+        return Object.assign({}, ...outputs);
+    };
+}

package/lib/esm/index.d.ts

@@ -1,12 +1,14 @@
-export * from "./agents/agent";
-export * from "./agents/ai-agent";
-export * from "./agents/mcp-agent";
-export * from "./execution-engine";
-export * from "./execution-engine/context";
-export * from "./execution-engine/message-queue";
-export * from "./models/chat";
-export * from "./models/chat-openai";
-export * from "./prompt/prompt-builder";
-export * from "./prompt/template";
-export * from "./utils/logger";
-export * from "./utils/run-chat-loop";
+export * from "./agents/agent.js";
+export * from "./agents/ai-agent.js";
+export * from "./agents/mcp-agent.js";
+export * from "./agents/memory.js";
+export * from "./agents/types.js";
+export * from "./agents/user-agent.js";
+export * from "./execution-engine/index.js";
+export * from "./models/chat-model.js";
+export * from "./models/claude-chat-model.js";
+export * from "./models/openai-chat-model.js";
+export * from "./prompt/prompt-builder.js";
+export * from "./prompt/template.js";
+export * from "./utils/logger.js";
+export * from "./utils/run-chat-loop.js";

package/lib/esm/index.js

@@ -1,12 +1,14 @@
-export * from "./agents/agent";
-export * from "./agents/ai-agent";
-export * from "./agents/mcp-agent";
-export * from "./execution-engine";
-export * from "./execution-engine/context";
-export * from "./execution-engine/message-queue";
-export * from "./models/chat";
-export * from "./models/chat-openai";
-export * from "./prompt/prompt-builder";
-export * from "./prompt/template";
-export * from "./utils/logger";
-export * from "./utils/run-chat-loop";
+export * from "./agents/agent.js";
+export * from "./agents/ai-agent.js";
+export * from "./agents/mcp-agent.js";
+export * from "./agents/memory.js";
+export * from "./agents/types.js";
+export * from "./agents/user-agent.js";
+export * from "./execution-engine/index.js";
+export * from "./models/chat-model.js";
+export * from "./models/claude-chat-model.js";
+export * from "./models/openai-chat-model.js";
+export * from "./prompt/prompt-builder.js";
+export * from "./prompt/template.js";
+export * from "./utils/logger.js";
+export * from "./utils/run-chat-loop.js";

package/lib/{cjs/models/chat.d.ts → esm/models/chat-model.d.ts}

@@ -1,8 +1,8 @@
-import { Agent, type AgentInput, type AgentOutput } from "../agents/agent";
+import { Agent, type Message } from "../agents/agent.js";
 export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
     constructor();
 }
-export interface ChatModelInput extends AgentInput {
+export interface ChatModelInput extends Message {
     messages: ChatModelInputMessage[];
     responseFormat?: ChatModelInputResponseFormat;
     tools?: ChatModelInputTool[];
@@ -12,24 +12,27 @@ export interface ChatModelInput extends AgentInput {
 export type Role = "system" | "user" | "agent" | "tool";
 export interface ChatModelInputMessage {
     role: Role;
-    content?: string | ({
-        type: "text";
-        text: string;
-    } | {
-        type: "image_url";
-        url: string;
-    })[];
+    content?: ChatModelInputMessageContent;
     toolCalls?: {
         id: string;
         type: "function";
         function: {
             name: string;
-            arguments: AgentInput;
+            arguments: Message;
         };
     }[];
     toolCallId?: string;
     name?: string;
 }
+export type ChatModelInputMessageContent = string | (TextContent | ImageUrlContent)[];
+export type TextContent = {
+    type: "text";
+    text: string;
+};
+export type ImageUrlContent = {
+    type: "image_url";
+    url: string;
+};
 export type ChatModelInputResponseFormat = {
     type: "text";
 } | {
@@ -63,7 +66,7 @@ export interface ChatModelOptions {
     frequencyPenalty?: number;
     presencePenalty?: number;
 }
-export interface ChatModelOutput extends AgentOutput {
+export interface ChatModelOutput extends Message {
     text?: string;
     json?: object;
     toolCalls?: ChatModelOutputToolCall[];
@@ -73,6 +76,6 @@ export interface ChatModelOutputToolCall {
     type: "function";
     function: {
         name: string;
-        arguments: AgentInput;
+        arguments: Message;
     };
 }

package/lib/esm/models/{chat.js → chat-model.js}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Agent } from "../agents/agent";
+import { Agent } from "../agents/agent.js";
 export class ChatModel extends Agent {
     constructor() {
         super({
@@ -32,8 +32,8 @@ const chatModelInputMessageSchema = z.object({
     toolCallId: z.string().optional(),
     name: z.string().optional(),
 });
-const chatModelInputResponseFormatSchema = z.union([
-    z.literal("text"),
+const chatModelInputResponseFormatSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("text") }),
     z.object({
         type: z.literal("json_schema"),
         jsonSchema: z.object({
@@ -82,6 +82,6 @@ const chatModelOutputToolCallSchema = z.object({
 });
 const chatModelOutputSchema = z.object({
     text: z.string().optional(),
-    json: z.unknown().optional(),
+    json: z.record(z.unknown()).optional(),
     toolCalls: z.array(chatModelOutputToolCallSchema).optional(),
 });

package/lib/esm/models/claude-chat-model.d.ts

@@ -0,0 +1,17 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat-model.js";
+export declare class ClaudeChatModel extends ChatModel {
+    config?: {
+        apiKey?: string;
+        model?: string;
+    } | undefined;
+    constructor(config?: {
+        apiKey?: string;
+        model?: string;
+    } | undefined);
+    private _client?;
+    get client(): Anthropic;
+    process(input: ChatModelInput): Promise<ChatModelOutput>;
+    private extractResultFromClaudeStream;
+    private requestStructuredOutput;
+}

package/lib/esm/models/claude-chat-model.js

@@ -0,0 +1,203 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { isEmpty } from "lodash-es";
+import { parseJSON } from "../utils/json-schema.js";
+import { isNonNullable } from "../utils/type-utils.js";
+import { ChatModel, } from "./chat-model.js";
+const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
+export class ClaudeChatModel extends ChatModel {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    _client;
+    get client() {
+        if (!this.config?.apiKey)
+            throw new Error("Api Key is required for ClaudeChatModel");
+        this._client ??= new Anthropic({ apiKey: this.config.apiKey });
+        return this._client;
+    }
+    async process(input) {
+        const model = this.config?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL;
+        const body = {
+            model,
+            temperature: input.modelOptions?.temperature,
+            top_p: input.modelOptions?.topP,
+            // TODO: make dynamic based on model https://docs.anthropic.com/en/docs/about-claude/models/all-models
+            max_tokens: /claude-3-[5|7]/.test(model) ? 8192 : 4096,
+            ...convertMessages(input),
+            ...convertTools(input),
+        };
+        const stream = this.client.messages.stream({
+            ...body,
+            stream: true,
+        });
+        const result = await this.extractResultFromClaudeStream(stream);
+        // Claude doesn't support json_schema response and tool calls in the same request,
+        // so we need to make a separate request for json_schema response when the tool calls is empty
+        if (!result.toolCalls?.length && input.responseFormat?.type === "json_schema") {
+            return this.requestStructuredOutput(body, input.responseFormat);
+        }
+        return result;
+    }
+    async extractResultFromClaudeStream(stream) {
+        let text = "";
+        const toolCalls = [];
+        for await (const chunk of stream) {
+            // handle streaming text
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                text += chunk.delta.text;
+            }
+            if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
+                toolCalls[chunk.index] = {
+                    type: "function",
+                    id: chunk.content_block.id,
+                    function: {
+                        name: chunk.content_block.name,
+                        arguments: {},
+                    },
+                    args: "",
+                };
+            }
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
+                const call = toolCalls[chunk.index];
+                if (!call)
+                    throw new Error("Tool call not found");
+                call.args += chunk.delta.partial_json;
+            }
+        }
+        const result = { text };
+        if (toolCalls.length) {
+            result.toolCalls = toolCalls
+                .map(({ args, ...c }) => ({
+                ...c,
+                function: { ...c.function, arguments: parseJSON(args) },
+            }))
+                .filter(isNonNullable);
+        }
+        return result;
+    }
+    async requestStructuredOutput(body, responseFormat) {
+        if (responseFormat?.type !== "json_schema") {
+            throw new Error("Expected json_schema response format");
+        }
+        const result = await this.client.messages.create({
+            ...body,
+            tools: [
+                {
+                    name: "generate_json",
+                    description: "Generate a json result by given context",
+                    input_schema: responseFormat.jsonSchema.schema,
+                },
+            ],
+            tool_choice: {
+                type: "tool",
+                name: "generate_json",
+                disable_parallel_tool_use: true,
+            },
+            stream: false,
+        });
+        const jsonTool = result.content.find((i) => i.type === "tool_use" && i.name === "generate_json");
+        if (!jsonTool)
+            throw new Error("Json tool not found");
+        return {
+            json: jsonTool.input,
+        };
+    }
+}
+function convertMessages({ messages, responseFormat }) {
+    const systemMessages = [];
+    const msgs = [];
+    for (const msg of messages) {
+        if (msg.role === "system") {
+            if (typeof msg.content !== "string")
+                throw new Error("System message must have content");
+            systemMessages.push(msg.content);
+        }
+        else if (msg.role === "tool") {
+            if (!msg.toolCallId)
+                throw new Error("Tool message must have toolCallId");
+            if (typeof msg.content !== "string")
+                throw new Error("Tool message must have string content");
+            msgs.push({
+                role: "user",
+                content: [{ type: "tool_result", tool_use_id: msg.toolCallId, content: msg.content }],
+            });
+        }
+        else if (msg.role === "user") {
+            if (!msg.content)
+                throw new Error("User message must have content");
+            msgs.push({ role: "user", content: convertContent(msg.content) });
+        }
+        else if (msg.role === "agent") {
+            if (msg.toolCalls?.length) {
+                msgs.push({
+                    role: "assistant",
+                    content: msg.toolCalls.map((i) => ({
+                        type: "tool_use",
+                        id: i.id,
+                        name: i.function.name,
+                        input: i.function.arguments,
+                    })),
+                });
+            }
+            else if (msg.content) {
+                msgs.push({ role: "assistant", content: convertContent(msg.content) });
+            }
+            else {
+                throw new Error("Agent message must have content or toolCalls");
+            }
+        }
+    }
+    if (responseFormat?.type === "json_schema") {
+        systemMessages.push(`You should provide a json response with schema: ${JSON.stringify(responseFormat.jsonSchema.schema)}`);
+    }
+    const system = systemMessages.join("\n").trim() || undefined;
+    // Claude requires at least one message, so we add a system message if there are no messages
+    if (msgs.length === 0) {
+        if (!system)
+            throw new Error("No messages provided");
+        return { messages: [{ role: "user", content: system }] };
+    }
+    return { messages: msgs, system };
+}
+function convertContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((item) => item.type === "image_url"
+            ? { type: "image", source: { type: "url", url: item.url } }
+            : { type: "text", text: item.text });
+    }
+    throw new Error("Invalid chat message content");
+}
+function convertTools({ tools, toolChoice, }) {
+    let choice;
+    if (typeof toolChoice === "object" && "type" in toolChoice && toolChoice.type === "function") {
+        choice = {
+            type: "tool",
+            name: toolChoice.function.name,
+        };
+    }
+    else if (toolChoice === "required") {
+        choice = { type: "any" };
+    }
+    else if (toolChoice === "auto") {
+        choice = { type: "auto" };
+    }
+    else if (toolChoice === "none") {
+        choice = { type: "none" };
+    }
+    return {
+        tools: tools?.length
+            ? tools.map((i) => ({
+                name: i.function.name,
+                description: i.function.description,
+                input_schema: isEmpty(i.function.parameters)
+                    ? { type: "object" }
+                    : i.function.parameters,
+            }))
+            : undefined,
+        tool_choice: choice,
+    };
+}

package/lib/esm/models/{chat-openai.d.ts → openai-chat-model.d.ts}

@@ -1,5 +1,5 @@
-import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat";
-export declare class ChatModelOpenAI extends ChatModel {
+import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat-model.js";
+export declare class OpenAIChatModel extends ChatModel {
     config?: {
         apiKey?: string;
         model?: string;