@aigne/core 1.0.17 → 1.1.0-beta.2

package/lib/cjs/index.d.ts

@@ -1,21 +1,10 @@
-export * from "./agent";
-export * from "./constants";
-export * from "./context";
-export * from "./definitions/data-type";
-export * from "./definitions/data-schema";
-export * from "./definitions/memory";
-export * from "./definitions/open-api";
-export * from "./function-agent";
-export * from "./llm-agent";
-export * from "./llm-decision-agent";
-export * from "./llm-model";
-export * from "./llm-models/gemini-llm-model";
-export * from "./llm-models/openai-llm-model";
-export * from "./memorable";
-export * from "./open-api-agent";
-export * from "./pipeline-agent";
-export * from "./runnable";
-export * from "./runtime";
-export * from "./sandbox-function-agent";
-export * from "./sandbox-function-runner";
-export * from "./utils";
+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";

package/lib/cjs/index.js

@@ -14,24 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./agent"), exports);
-__exportStar(require("./constants"), exports);
-__exportStar(require("./context"), exports);
-__exportStar(require("./definitions/data-type"), exports);
-__exportStar(require("./definitions/data-schema"), exports);
-__exportStar(require("./definitions/memory"), exports);
-__exportStar(require("./definitions/open-api"), exports);
-__exportStar(require("./function-agent"), exports);
-__exportStar(require("./llm-agent"), exports);
-__exportStar(require("./llm-decision-agent"), exports);
-__exportStar(require("./llm-model"), exports);
-__exportStar(require("./llm-models/gemini-llm-model"), exports);
-__exportStar(require("./llm-models/openai-llm-model"), exports);
-__exportStar(require("./memorable"), exports);
-__exportStar(require("./open-api-agent"), exports);
-__exportStar(require("./pipeline-agent"), exports);
-__exportStar(require("./runnable"), exports);
-__exportStar(require("./runtime"), exports);
-__exportStar(require("./sandbox-function-agent"), exports);
-__exportStar(require("./sandbox-function-runner"), exports);
-__exportStar(require("./utils"), exports);
+__exportStar(require("./agents/agent"), exports);
+__exportStar(require("./agents/ai-agent"), exports);
+__exportStar(require("./agents/mcp-agent"), exports);
+__exportStar(require("./execution-engine"), exports);
+__exportStar(require("./execution-engine/context"), exports);
+__exportStar(require("./execution-engine/message-queue"), exports);
+__exportStar(require("./models/chat"), exports);
+__exportStar(require("./models/chat-openai"), exports);
+__exportStar(require("./prompt/prompt-builder"), exports);
+__exportStar(require("./prompt/template"), exports);

package/lib/cjs/models/chat-openai.d.ts

@@ -0,0 +1,14 @@
+import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat";
+export declare class ChatModelOpenAI extends ChatModel {
+    config?: {
+        apiKey?: string;
+        model?: string;
+    } | undefined;
+    constructor(config?: {
+        apiKey?: string;
+        model?: string;
+    } | undefined);
+    private _client?;
+    private get client();
+    process(input: ChatModelInput): Promise<ChatModelOutput>;
+}

package/lib/cjs/{llm-models/openai-llm-model.js → models/chat-openai.js}

@@ -3,25 +3,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenaiLLMModel = void 0;
+exports.ChatModelOpenAI = void 0;
 const nanoid_1 = require("nanoid");
 const openai_1 = __importDefault(require("openai"));
-const llm_model_1 = require("../llm-model");
-const is_non_nullable_1 = require("../utils/is-non-nullable");
-class OpenaiLLMModel extends llm_model_1.LLMModel {
+const type_utils_1 = require("../utils/type-utils");
+const chat_1 = require("./chat");
+const CHAT_MODEL_OPENAI_DEFAULT_MODEL = "gpt-4o-mini";
+class ChatModelOpenAI extends chat_1.ChatModel {
     config;
     constructor(config) {
         super();
         this.config = config;
-        this.client = new openai_1.default({ apiKey: this.config.apiKey });
     }
-    client;
-    setApiKey(apiKey) {
-        this.client = new openai_1.default({ apiKey });
+    _client;
+    get client() {
+        if (!this.config?.apiKey)
+            throw new Error("Api Key is required for ChatModelOpenAI");
+        this._client ??= new openai_1.default({ apiKey: this.config.apiKey });
+        return this._client;
     }
-    async *process(input) {
+    async process(input) {
         const res = await this.client.chat.completions.create({
-            model: this.config.model,
+            model: this.config?.model || CHAT_MODEL_OPENAI_DEFAULT_MODEL,
             temperature: input.modelOptions?.temperature,
             top_p: input.modelOptions?.topP,
             frequency_penalty: input.modelOptions?.frequencyPenalty,
@@ -40,31 +43,56 @@ class OpenaiLLMModel extends llm_model_1.LLMModel {
                 : undefined,
             stream: true,
         });
+        let text = "";
         const toolCalls = [];
         for await (const chunk of res) {
             const choice = chunk.choices?.[0];
             if (choice?.delta.tool_calls?.length) {
                 for (const call of choice.delta.tool_calls) {
-                    const tool = toolCalls[call.index] ?? { id: call.id || (0, nanoid_1.nanoid)() };
-                    toolCalls[call.index] = tool;
+                    toolCalls[call.index] ??= {
+                        id: call.id || (0, nanoid_1.nanoid)(),
+                        type: "function",
+                        function: { name: "", arguments: {} },
+                        args: "",
+                    };
+                    const c = toolCalls[call.index];
+                    if (!c)
+                        throw new Error("Tool call not found");
                     if (call.type)
-                        tool.type = call.type;
-                    tool.function ??= {};
-                    tool.function.name =
-                        (tool.function.name || "") + (call.function?.name || "");
-                    tool.function.arguments = (tool.function.arguments || "").concat(call.function?.arguments || "");
+                        c.type = call.type;
+                    c.function.name = c.function.name + (call.function?.name || "");
+                    c.args = c.args.concat(call.function?.arguments || "");
                 }
             }
             if (choice?.delta.content)
-                yield { $text: choice.delta.content };
+                text += choice.delta.content;
+        }
+        const result = {};
+        if (input.responseFormat?.type === "json_schema") {
+            result.json = JSON.parse(text);
+        }
+        else {
+            result.text = text;
+        }
+        if (toolCalls.length) {
+            result.toolCalls = toolCalls.map(({ args, ...c }) => ({
+                ...c,
+                function: { ...c.function, arguments: JSON.parse(args) },
+            }));
         }
-        yield { delta: { toolCalls } };
+        return result;
     }
 }
-exports.OpenaiLLMModel = OpenaiLLMModel;
+exports.ChatModelOpenAI = ChatModelOpenAI;
+const ROLE_MAP = {
+    system: "system",
+    user: "user",
+    agent: "assistant",
+    tool: "tool",
+};
 async function contentsFromInputMessages(messages) {
     return messages.map((i) => ({
-        role: i.role,
+        role: ROLE_MAP[i.role],
         content: typeof i.content === "string"
             ? i.content
             : i.content
@@ -75,12 +103,20 @@ async function contentsFromInputMessages(messages) {
                 if (c.type === "image_url") {
                     return {
                         type: "image_url",
-                        image_url: { url: c.imageUrl.url },
+                        image_url: { url: c.url },
                     };
                 }
             })
-                .filter(is_non_nullable_1.isNonNullable),
+                .filter(type_utils_1.isNonNullable),
+        tool_calls: i.toolCalls?.map((i) => ({
+            ...i,
+            function: {
+                ...i.function,
+                arguments: JSON.stringify(i.function.arguments),
+            },
+        })),
         tool_call_id: i.toolCallId,
+        name: i.name,
     }));
 }
 function toolsFromInputTools(tools) {
@@ -105,18 +141,17 @@ function jsonSchemaToOpenAIJsonSchema(schema) {
                 // NOTE: All fields must be required https://platform.openai.com/docs/guides/structured-outputs/all-fields-must-be-required
                 return [
                     key,
-                    required?.includes(key)
-                        ? valueSchema
-                        : { anyOf: [valueSchema, { type: ["null"] }] },
+                    required?.includes(key) ? valueSchema : { anyOf: [valueSchema, { type: ["null"] }] },
                 ];
             })),
             required: Object.keys(properties),
         };
     }
     if (schema?.type === "array") {
+        const { items } = schema;
         return {
             ...schema,
-            items: jsonSchemaToOpenAIJsonSchema(schema.items),
+            items: jsonSchemaToOpenAIJsonSchema(items),
         };
     }
     return schema;

package/lib/cjs/models/chat.d.ts

@@ -0,0 +1,78 @@
+import { Agent, type AgentInput, type AgentOutput } from "../agents/agent";
+export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
+    constructor();
+}
+export interface ChatModelInput extends AgentInput {
+    messages: ChatModelInputMessage[];
+    responseFormat?: ChatModelInputResponseFormat;
+    tools?: ChatModelInputTool[];
+    toolChoice?: ChatModelInputToolChoice;
+    modelOptions?: ChatModelOptions;
+}
+export type Role = "system" | "user" | "agent" | "tool";
+export interface ChatModelInputMessage {
+    role: Role;
+    content?: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image_url";
+        url: string;
+    })[];
+    toolCalls?: {
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: AgentInput;
+        };
+    }[];
+    toolCallId?: string;
+    name?: string;
+}
+export type ChatModelInputResponseFormat = {
+    type: "text";
+} | {
+    type: "json_schema";
+    jsonSchema: {
+        name: string;
+        description?: string;
+        schema: Record<string, unknown>;
+        strict?: boolean;
+    };
+};
+export interface ChatModelInputTool {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters: object;
+    };
+}
+export type ChatModelInputToolChoice = "auto" | "none" | "required" | {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+    };
+};
+export interface ChatModelOptions {
+    model?: string;
+    temperature?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+}
+export interface ChatModelOutput extends AgentOutput {
+    text?: string;
+    json?: object;
+    toolCalls?: ChatModelOutputToolCall[];
+}
+export interface ChatModelOutputToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: AgentInput;
+    };
+}

package/lib/cjs/models/chat.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatModel = void 0;
+const zod_1 = require("zod");
+const agent_1 = require("../agents/agent");
+class ChatModel extends agent_1.Agent {
+    constructor() {
+        super({
+            inputSchema: chatModelInputSchema,
+            outputSchema: chatModelOutputSchema,
+        });
+    }
+}
+exports.ChatModel = ChatModel;
+const chatModelInputMessageSchema = zod_1.z.object({
+    role: zod_1.z.union([zod_1.z.literal("system"), zod_1.z.literal("user"), zod_1.z.literal("agent"), zod_1.z.literal("tool")]),
+    content: zod_1.z
+        .union([
+        zod_1.z.string(),
+        zod_1.z.array(zod_1.z.union([
+            zod_1.z.object({ type: zod_1.z.literal("text"), text: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal("image_url"), url: zod_1.z.string() }),
+        ])),
+    ])
+        .optional(),
+    toolCalls: zod_1.z
+        .array(zod_1.z.object({
+        id: zod_1.z.string(),
+        type: zod_1.z.literal("function"),
+        function: zod_1.z.object({
+            name: zod_1.z.string(),
+            arguments: zod_1.z.record(zod_1.z.unknown()),
+        }),
+    }))
+        .optional(),
+    toolCallId: zod_1.z.string().optional(),
+    name: zod_1.z.string().optional(),
+});
+const chatModelInputResponseFormatSchema = zod_1.z.union([
+    zod_1.z.literal("text"),
+    zod_1.z.object({
+        type: zod_1.z.literal("json_schema"),
+        jsonSchema: zod_1.z.object({
+            name: zod_1.z.string(),
+            description: zod_1.z.string().optional(),
+            schema: zod_1.z.record(zod_1.z.unknown()),
+            strict: zod_1.z.boolean().optional(),
+        }),
+    }),
+]);
+const chatModelInputToolSchema = zod_1.z.object({
+    type: zod_1.z.literal("function"),
+    function: zod_1.z.object({
+        name: zod_1.z.string(),
+        description: zod_1.z.string().optional(),
+        parameters: zod_1.z.record(zod_1.z.unknown()),
+    }),
+});
+const chatModelInputToolChoiceSchema = zod_1.z.union([
+    zod_1.z.literal("auto"),
+    zod_1.z.literal("none"),
+    zod_1.z.literal("required"),
+    chatModelInputToolSchema,
+]);
+const chatModelOptionsSchema = zod_1.z.object({
+    model: zod_1.z.string().optional(),
+    temperature: zod_1.z.number().optional(),
+    topP: zod_1.z.number().optional(),
+    frequencyPenalty: zod_1.z.number().optional(),
+    presencePenalty: zod_1.z.number().optional(),
+});
+const chatModelInputSchema = zod_1.z.object({
+    messages: zod_1.z.array(chatModelInputMessageSchema),
+    responseFormat: chatModelInputResponseFormatSchema.optional(),
+    tools: zod_1.z.array(chatModelInputToolSchema).optional(),
+    toolChoice: chatModelInputToolChoiceSchema.optional(),
+    modelOptions: chatModelOptionsSchema.optional(),
+});
+const chatModelOutputToolCallSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    type: zod_1.z.literal("function"),
+    function: zod_1.z.object({
+        name: zod_1.z.string(),
+        arguments: zod_1.z.record(zod_1.z.unknown()),
+    }),
+});
+const chatModelOutputSchema = zod_1.z.object({
+    text: zod_1.z.string().optional(),
+    json: zod_1.z.unknown().optional(),
+    toolCalls: zod_1.z.array(chatModelOutputToolCallSchema).optional(),
+});

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

@@ -0,0 +1,34 @@
+import { Agent, type AgentInput } from "../agents/agent";
+import type { AIAgent } from "../agents/ai-agent";
+import type { Context } from "../execution-engine/context";
+import type { ChatModel, ChatModelInput, ChatModelInputMessage } from "../models/chat";
+export declare const USER_INPUT_MESSAGE_KEY = "$user_input_message";
+export declare function userInput(message: string | object): AgentInput;
+export declare function addMessagesToInput(input: AgentInput, messages: ChatModelInputMessage[]): AgentInput;
+export interface PromptBuilderOptions {
+    instructions?: string;
+}
+export interface PromptBuilderBuildOptions {
+    context?: Context;
+    agent?: AIAgent;
+    input?: AgentInput;
+    model?: ChatModel;
+}
+export declare class PromptBuilder {
+    static from(instructions: string): PromptBuilder;
+    static from(instructions: {
+        path: string;
+    }): Promise<PromptBuilder>;
+    static from(instructions: string | {
+        path: string;
+    }): PromptBuilder | Promise<PromptBuilder>;
+    private static fromFile;
+    constructor(options?: PromptBuilderOptions);
+    instructions?: string;
+    build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
+        toolAgents?: Agent[];
+    }>;
+    private buildMessages;
+    private buildResponseFormat;
+    private buildTools;
+}

package/lib/cjs/prompt/prompt-builder.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptBuilder = exports.USER_INPUT_MESSAGE_KEY = void 0;
+exports.userInput = userInput;
+exports.addMessagesToInput = addMessagesToInput;
+const promises_1 = require("node:fs/promises");
+const zod_1 = require("zod");
+const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
+const agent_1 = require("../agents/agent");
+const template_1 = require("./template");
+exports.USER_INPUT_MESSAGE_KEY = "$user_input_message";
+function userInput(message) {
+    return { [exports.USER_INPUT_MESSAGE_KEY]: message };
+}
+function addMessagesToInput(input, messages) {
+    const originalUserInputMessages = input[exports.USER_INPUT_MESSAGE_KEY];
+    const newMessages = [];
+    if (typeof originalUserInputMessages === "string") {
+        newMessages.push({ role: "user", content: originalUserInputMessages });
+    }
+    else {
+        const messages = (0, template_1.parseChatMessages)(originalUserInputMessages);
+        if (messages)
+            newMessages.push(...messages);
+        else
+            newMessages.push({
+                role: "user",
+                content: JSON.stringify(originalUserInputMessages),
+            });
+    }
+    newMessages.push(...messages);
+    return { ...input, [exports.USER_INPUT_MESSAGE_KEY]: newMessages };
+}
+class PromptBuilder {
+    static from(instructions) {
+        if (typeof instructions === "string") {
+            return new PromptBuilder({ instructions });
+        }
+        return PromptBuilder.fromFile(instructions.path);
+    }
+    static async fromFile(path) {
+        const text = await (0, promises_1.readFile)(path, "utf-8");
+        return PromptBuilder.from(text);
+    }
+    constructor(options) {
+        this.instructions = options?.instructions;
+    }
+    instructions;
+    async build(options) {
+        return {
+            messages: this.buildMessages(options),
+            responseFormat: this.buildResponseFormat(options),
+            ...this.buildTools(options),
+        };
+    }
+    buildMessages(options) {
+        const { input } = options;
+        const template = template_1.ChatMessagesTemplate.from([]);
+        if (this.instructions)
+            template.messages.push(template_1.SystemMessageTemplate.from(this.instructions));
+        const userInputMessage = input?.[exports.USER_INPUT_MESSAGE_KEY];
+        if (typeof userInputMessage === "string") {
+            template.messages.push(template_1.UserMessageTemplate.from(userInputMessage));
+        }
+        else if (userInputMessage) {
+            const messages = (0, template_1.parseChatMessages)(userInputMessage);
+            if (messages)
+                template.messages.push(...messages);
+            else
+                template.messages.push(template_1.UserMessageTemplate.from(JSON.stringify(userInputMessage)));
+        }
+        return template.format(input);
+    }
+    buildResponseFormat(options) {
+        const outputSchema = options.agent?.outputSchema;
+        if (!outputSchema)
+            return undefined;
+        const isJsonOutput = !isEmptyObjectType(outputSchema);
+        return isJsonOutput
+            ? {
+                type: "json_schema",
+                jsonSchema: {
+                    name: "output",
+                    schema: (0, zod_to_json_schema_1.default)(outputSchema),
+                    strict: true,
+                },
+            }
+            : undefined;
+    }
+    buildTools(options) {
+        const toolAgents = (options.context?.tools ?? [])
+            .concat(options.agent?.tools ?? [])
+            // TODO: support nested tools?
+            .flatMap((i) => (i.isCallable ? i.tools.concat(i) : i.tools));
+        const tools = toolAgents.map((i) => ({
+            type: "function",
+            function: {
+                name: i.name,
+                description: i.description,
+                parameters: !isEmptyObjectType(i.inputSchema) ? (0, zod_to_json_schema_1.default)(i.inputSchema) : {},
+            },
+        }));
+        let toolChoice;
+        // use manual choice if configured in the agent
+        const manualChoice = options.agent?.toolChoice;
+        if (manualChoice) {
+            if (manualChoice instanceof agent_1.Agent) {
+                toolChoice = {
+                    type: "function",
+                    function: {
+                        name: manualChoice.name,
+                        description: manualChoice.description,
+                    },
+                };
+            }
+            else if (manualChoice === "router") {
+                toolChoice = "required";
+            }
+            else {
+                toolChoice = manualChoice;
+            }
+        }
+        // otherwise, use auto choice if there is only one tool
+        else {
+            toolChoice = tools.length ? "auto" : undefined;
+        }
+        return {
+            toolAgents: toolAgents.length ? toolAgents : undefined,
+            tools: tools.length ? tools : undefined,
+            toolChoice,
+        };
+    }
+}
+exports.PromptBuilder = PromptBuilder;
+function isEmptyObjectType(schema) {
+    return schema instanceof zod_1.ZodObject && Object.keys(schema.shape).length === 0;
+}

package/lib/cjs/prompt/template.d.ts

@@ -0,0 +1,70 @@
+import type { ChatModelInputMessage, ChatModelOutputToolCall } from "../models/chat";
+export declare class PromptTemplate {
+    template: string;
+    static from(template: string): PromptTemplate;
+    constructor(template: string);
+    format(variables?: Record<string, unknown>): string;
+}
+export declare class ChatMessageTemplate {
+    role: "system" | "user" | "agent" | "tool";
+    content?: ChatModelInputMessage["content"];
+    name?: string | undefined;
+    constructor(role: "system" | "user" | "agent" | "tool", content?: ChatModelInputMessage["content"], name?: string | undefined);
+    format(variables?: Record<string, unknown>): ChatModelInputMessage;
+}
+export declare class SystemMessageTemplate extends ChatMessageTemplate {
+    static from(content: string, name?: string): SystemMessageTemplate;
+}
+export declare class UserMessageTemplate extends ChatMessageTemplate {
+    static from(template: NonNullable<ChatModelInputMessage["content"]>, name?: string): UserMessageTemplate;
+}
+export declare class AgentMessageTemplate extends ChatMessageTemplate {
+    toolCalls?: ChatModelOutputToolCall[] | undefined;
+    static from(template: string | ChatModelOutputToolCall[], name?: string): AgentMessageTemplate;
+    constructor(content?: string, toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
+    format(variables?: Record<string, unknown>): {
+        toolCalls: ChatModelOutputToolCall[] | undefined;
+        role: import("../models/chat").Role;
+        content?: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image_url";
+            url: string;
+        })[];
+        toolCallId?: string;
+        name?: string;
+    };
+}
+export declare class ToolMessageTemplate extends ChatMessageTemplate {
+    toolCallId: string;
+    static from(content: object | string, toolCallId: string, name?: string): ToolMessageTemplate;
+    constructor(content: object | string, toolCallId: string, name?: string);
+    format(variables?: Record<string, unknown>): {
+        toolCallId: string;
+        role: import("../models/chat").Role;
+        content?: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image_url";
+            url: string;
+        })[];
+        toolCalls?: {
+            id: string;
+            type: "function";
+            function: {
+                name: string;
+                arguments: import("..").AgentInput;
+            };
+        }[];
+        name?: string;
+    };
+}
+export declare class ChatMessagesTemplate {
+    messages: ChatMessageTemplate[];
+    static from(messages: ChatMessageTemplate[] | string): ChatMessagesTemplate;
+    constructor(messages: ChatMessageTemplate[]);
+    format(variables?: Record<string, unknown>): ChatModelInputMessage[];
+}
+export declare function parseChatMessages(messages: unknown): ChatMessageTemplate[] | undefined;