@aigne/core 1.15.0 → 1.17.0

package/lib/cjs/memory/{default-memory.js → default-memory/index.js}

@@ -3,38 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultMemory = exports.DEFAULT_MAX_MEMORY_COUNT = void 0;
+exports.DefaultMemory = void 0;
 const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
-const memory_js_1 = require("./memory.js");
-const recorder_js_1 = require("./recorder.js");
-const retriever_js_1 = require("./retriever.js");
-exports.DEFAULT_MAX_MEMORY_COUNT = 10;
+const memory_js_1 = require("../memory.js");
+const recorder_js_1 = require("../recorder.js");
+const retriever_js_1 = require("../retriever.js");
+const index_js_1 = require("./default-memory-storage/index.js");
+const storage_js_1 = require("./storage.js");
 class DefaultMemory extends memory_js_1.MemoryAgent {
     constructor(options = {}) {
         super({
             ...options,
             autoUpdate: options.autoUpdate ?? true,
         });
+        this.storage =
+            options.storage instanceof storage_js_1.MemoryStorage
+                ? options.storage
+                : new index_js_1.DefaultMemoryStorage(options.storage);
         if (!this.recorder)
             this.recorder = new DefaultMemoryRecorder(this);
         if (!this.retriever)
             this.retriever = new DefaultMemoryRetriever(this);
     }
-    storage = [];
-    async search(options = {}) {
-        const { limit = exports.DEFAULT_MAX_MEMORY_COUNT } = options;
-        const result = limit < 0 ? this.storage.slice(limit) : this.storage.slice(0, limit);
-        return { result };
-    }
-    async create(memory) {
-        const m = {
-            ...memory,
-            id: (0, memory_js_1.newMemoryId)(),
-            createdAt: new Date().toISOString(),
-        };
-        this.storage.push(m);
-        return { result: m };
-    }
+    storage;
 }
 exports.DefaultMemory = DefaultMemory;
 class DefaultMemoryRetriever extends retriever_js_1.MemoryRetriever {
@@ -43,8 +34,8 @@ class DefaultMemoryRetriever extends retriever_js_1.MemoryRetriever {
         super({});
         this.memory = memory;
     }
-    async process(input) {
-        const { result } = await this.memory.search(input);
+    async process(input, options) {
+        const { result } = await this.memory.storage.search(input, options);
         return { memories: result };
     }
 }
@@ -54,12 +45,12 @@ class DefaultMemoryRecorder extends recorder_js_1.MemoryRecorder {
         super({});
         this.memory = memory;
     }
-    async process(input) {
+    async process(input, options) {
         const newMemories = [];
         for (const content of input.content) {
-            const { result: [last], } = await this.memory.search({ limit: -1 });
+            const { result: [last], } = await this.memory.storage.search({ limit: 1 }, options);
             if (!(0, fast_deep_equal_1.default)(last?.content, content)) {
-                const { result } = await this.memory.create({ content });
+                const { result } = await this.memory.storage.create({ content }, options);
                 newMemories.push(result);
             }
         }

package/lib/cjs/memory/default-memory/storage.d.ts

@@ -0,0 +1,13 @@
+import type { AgentInvokeOptions } from "../../agents/agent.js";
+import type { Memory } from "../memory.js";
+export declare abstract class MemoryStorage {
+    abstract create(memory: Pick<Memory, "content">, options: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+    abstract search(query: {
+        search?: string;
+        limit?: number;
+    }, options: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+}

package/lib/cjs/memory/default-memory/storage.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStorage = void 0;
+class MemoryStorage {
+}
+exports.MemoryStorage = MemoryStorage;

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

@@ -1,10 +1,11 @@
-import { Agent, type AgentOptions, type Message } from "../agents/agent.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../agents/agent.js";
 import type { Context } from "../aigne/context.js";
 import type { MessagePayload } from "../aigne/message-queue.js";
 import type { MemoryRecorder, MemoryRecorderInput, MemoryRecorderOutput } from "./recorder.js";
 import type { MemoryRetriever, MemoryRetrieverInput, MemoryRetrieverOutput } from "./retriever.js";
 export interface Memory {
     id: string;
+    sessionId?: string | null;
     content: unknown;
     createdAt: string;
 }
@@ -62,7 +63,7 @@ export declare class MemoryAgent extends Agent {
      * MemoryAgent doesn't directly process messages like other agents, so this method
      * throws an error when called. Use the specialized retrieve() and record() methods instead.
      */
-    process(_input: Message, _context: Context): Promise<Message>;
+    process(_input: Message, _options: AgentInvokeOptions): Promise<Message>;
     /**
      * Retrieves memories based on the provided input criteria.
      *

package/lib/cjs/memory/memory.js

@@ -85,7 +85,7 @@ class MemoryAgent extends agent_js_1.Agent {
      * MemoryAgent doesn't directly process messages like other agents, so this method
      * throws an error when called. Use the specialized retrieve() and record() methods instead.
      */
-    async process(_input, _context) {
+    async process(_input, _options) {
         throw new Error("Method not implemented.");
     }
     /**

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

@@ -39,11 +39,11 @@ export declare const memoryRetrieverInputSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     search: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    limit?: number | undefined;
     search?: string | undefined;
-}, {
     limit?: number | undefined;
+}, {
     search?: string | undefined;
+    limit?: number | undefined;
 }>;
 /**
  * @hidden

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

@@ -1,17 +1,23 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
 import { Agent, type Message } from "../agents/agent.js";
 import type { AIAgent } from "../agents/ai-agent.js";
+import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
 import type { Context } from "../aigne/context.js";
 import type { MemoryAgent } from "../memory/memory.js";
-import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
-export declare function createMessage<I extends Message>(message: string | I): I;
+export declare function createMessage<V extends Message>(message: string, variables?: V): {
+    [MESSAGE_KEY]: string;
+} & typeof variables;
+export declare function createMessage<I extends Message, V extends Message>(message: I, variables?: V): I & typeof variables;
+export declare function createMessage<I extends Message, V extends Message>(message: string | I, variables?: V): ({
+    [MESSAGE_KEY]: string;
+} | I) & typeof variables;
 export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
-export interface PromptBuilderBuildOptions {
+export interface PromptBuildOptions {
     memory?: MemoryAgent | MemoryAgent[];
     context: Context;
     agent?: AIAgent;
@@ -32,7 +38,7 @@ export declare class PromptBuilder {
     private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
     instructions?: string | ChatMessagesTemplate;
-    build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
+    build(options: PromptBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;
     private buildMessages;

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

@@ -12,10 +12,10 @@ const type_utils_js_1 = require("../utils/type-utils.js");
 const memory_message_template_js_1 = require("./prompts/memory-message-template.js");
 const template_js_1 = require("./template.js");
 exports.MESSAGE_KEY = "$message";
-function createMessage(message) {
-    return typeof message === "string"
-        ? { [exports.MESSAGE_KEY]: message }
-        : { ...message };
+function createMessage(message, variables) {
+    return (typeof message === "string"
+        ? { [exports.MESSAGE_KEY]: message, ...variables }
+        : { ...message, ...variables });
 }
 function getMessage(input) {
     const userInputMessage = input[exports.MESSAGE_KEY];

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

@@ -1,4 +1,4 @@
-import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../models/chat-model.js";
+import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../agents/chat-model.js";
 export declare class PromptTemplate {
     template: string;
     static from(template: string): PromptTemplate;
@@ -24,7 +24,7 @@ export declare class AgentMessageTemplate extends ChatMessageTemplate {
     constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCalls: ChatModelOutputToolCall[] | undefined;
-        role: import("../models/chat-model.js").Role;
+        role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
         toolCallId?: string;
         name?: string;
@@ -36,7 +36,7 @@ export declare class ToolMessageTemplate extends ChatMessageTemplate {
     constructor(content: object | string, toolCallId: string, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCallId: string;
-        role: import("../models/chat-model.js").Role;
+        role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
         toolCalls?: {
             id: string;

package/lib/cjs/utils/json-schema.js

@@ -28,7 +28,7 @@ function parseJSON(json) {
         return JSON.parse(json);
     }
     catch (error) {
-        logger_js_1.logger.core("Failed to parse JSON", { json, error });
+        logger_js_1.logger.error("Failed to parse JSON", { json, error });
         throw error;
     }
 }

package/lib/cjs/utils/logger.d.ts

@@ -1,8 +1,33 @@
-import debug from "debug";
-export declare const logger: debug.Debug & {
-    debug: debug.Debug;
-    default: debug.Debug;
-} & {
-    core: debug.Debugger;
-    mcp: debug.Debugger;
-};
+export declare enum LogLevel {
+    ERROR = "error",
+    WARN = "warn",
+    INFO = "info",
+    DEBUG = "debug"
+}
+export declare class Logger {
+    constructor(options: {
+        level: LogLevel;
+        ns: string;
+    });
+    level: LogLevel;
+    private debugLogger;
+    private infoLogger;
+    private warnLogger;
+    private errorLogger;
+    logMessage: {
+        (...data: any[]): void;
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    logError: {
+        (...data: any[]): void;
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    enabled(level: LogLevel): boolean;
+}
+export declare const logger: Logger;

package/lib/cjs/utils/logger.js

@@ -3,10 +3,68 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+const node_tty_1 = require("node:tty");
 const debug_1 = __importDefault(require("debug"));
-const base = (0, debug_1.default)("aigne");
-exports.logger = Object.assign(debug_1.default, {
-    core: base.extend("core"),
-    mcp: base.extend("mcp"),
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["ERROR"] = "error";
+    LogLevel["WARN"] = "warn";
+    LogLevel["INFO"] = "info";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+const levels = Object.values(LogLevel);
+class Logger {
+    constructor(options) {
+        this.level = options.level;
+        this.debugLogger = (0, debug_1.default)(`${options.ns}:debug`);
+        this.infoLogger = (0, debug_1.default)(`${options.ns}:info`);
+        this.warnLogger = (0, debug_1.default)(`${options.ns}:warn`);
+        this.errorLogger = (0, debug_1.default)(`${options.ns}:error`);
+        for (const logger of [this.debugLogger, this.infoLogger, this.warnLogger]) {
+            // @ts-ignore
+            logger.useColors = (0, node_tty_1.isatty)(process.stdout.fd);
+            logger.enabled = true;
+            logger.log = (...args) => this.logMessage(...args);
+        }
+        this.errorLogger.log = (...args) => this.logError(...args);
+        // @ts-ignore
+        this.errorLogger.useColors = (0, node_tty_1.isatty)(process.stderr.fd);
+        this.errorLogger.enabled = true;
+    }
+    level;
+    debugLogger;
+    infoLogger;
+    warnLogger;
+    errorLogger;
+    logMessage = console.log;
+    logError = console.error;
+    debug(message, ...args) {
+        if (this.enabled(LogLevel.DEBUG)) {
+            this.debugLogger(message, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.enabled(LogLevel.INFO)) {
+            this.infoLogger(message, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.enabled(LogLevel.WARN)) {
+            this.warnLogger(message, ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.enabled(LogLevel.ERROR)) {
+            this.errorLogger(message, ...args);
+        }
+    }
+    enabled(level) {
+        return levels.indexOf(this.level) >= levels.indexOf(level);
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger({
+    ns: "aigne:core",
+    level: LogLevel.INFO,
 });

package/lib/cjs/utils/model-utils.d.ts

@@ -1,3 +1,3 @@
-import type { ChatModelOutputUsage } from "../models/chat-model.js";
+import type { ChatModelOutputUsage } from "../agents/chat-model.js";
 import type { Nullish } from "./type-utils.js";
 export declare function mergeUsage(...usages: Nullish<ChatModelOutputUsage>[]): ChatModelOutputUsage;

package/lib/cjs/utils/stream-utils.d.ts

@@ -6,7 +6,7 @@ export declare function mergeAgentResponseChunk<T extends Message>(output: T, ch
 export declare function agentResponseStreamToObject<T extends Message>(stream: AgentResponseStream<T> | AgentProcessAsyncGenerator<T>): Promise<T>;
 export declare function asyncGeneratorToReadableStream<T extends Message>(generator: AgentProcessAsyncGenerator<T>): AgentResponseStream<T>;
 export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, callback: (result: T) => PromiseOrValue<Partial<T> | void>, options?: {
-    errorCallback?: (error: Error) => Error;
+    errorCallback?: (error: Error) => PromiseOrValue<Error>;
     processChunk?: (chunk: AgentResponseChunk<T>) => AgentResponseChunk<T>;
 }): ReadableStream<any>;
 export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
@@ -19,3 +19,5 @@ export declare function readableStreamToArray<T>(stream: ReadableStream<T>, opti
     catchError?: false;
 }): Promise<T[]>;
 export declare function stringToAgentResponseStream(str: string, key?: "text" | typeof MESSAGE_KEY | string): AgentResponseStream<Message>;
+export declare function toReadableStream(stream: NodeJS.ReadStream): ReadableStream<Uint8Array<ArrayBufferLike>>;
+export declare function readAllString(stream: NodeJS.ReadStream | ReadableStream): Promise<string>;

package/lib/cjs/utils/stream-utils.js

@@ -13,6 +13,8 @@ exports.arrayToAgentProcessAsyncGenerator = arrayToAgentProcessAsyncGenerator;
 exports.arrayToReadableStream = arrayToReadableStream;
 exports.readableStreamToArray = readableStreamToArray;
 exports.stringToAgentResponseStream = stringToAgentResponseStream;
+exports.toReadableStream = toReadableStream;
+exports.readAllString = readAllString;
 const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
 const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("./type-utils.js");
@@ -113,7 +115,7 @@ function onAgentResponseStreamEnd(stream, callback, options) {
                 }
             }
             catch (error) {
-                controller.error(options?.errorCallback?.(error) ?? error);
+                controller.error((await options?.errorCallback?.(error)) ?? error);
             }
         },
     });
@@ -166,3 +168,31 @@ function stringToAgentResponseStream(str, key = "text") {
     const segments = segmenter.segment(str);
     return arrayToReadableStream(Array.from(segments).map((segment) => ({ delta: { text: { [key]: segment.segment } } })));
 }
+function toReadableStream(stream) {
+    return new ReadableStream({
+        start(controller) {
+            const onData = (chunk) => {
+                controller.enqueue(new Uint8Array(chunk));
+            };
+            const onEnd = () => {
+                cleanup();
+                controller.close();
+            };
+            const onError = (err) => {
+                cleanup();
+                controller.error(err);
+            };
+            function cleanup() {
+                stream.off("data", onData);
+                stream.off("end", onEnd);
+                stream.off("error", onError);
+            }
+            stream.on("data", onData);
+            stream.on("end", onEnd);
+            stream.on("error", onError);
+        },
+    });
+}
+async function readAllString(stream) {
+    return (await readableStreamToArray((stream instanceof ReadableStream ? stream : toReadableStream(stream)).pipeThrough(new TextDecoderStream()))).join("");
+}

package/lib/cjs/utils/type-utils.d.ts

@@ -1,7 +1,12 @@
-import { type ZodType } from "zod";
+import { type ZodType, z } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 export type Nullish<T> = T | null | undefined | void;
 export type OmitPropertiesFromArrayFirstElement<T extends unknown[], K extends string | number | symbol> = T extends [infer U, ...infer Rest] ? [Omit<U, K>, ...Rest] : never;
+export type XOr<T, K extends keyof T, O extends keyof T> = (Omit<T, O> & {
+    [key in O]?: undefined;
+}) | (Omit<T, K> & {
+    [key in K]?: undefined;
+});
 export declare function isNil(value: unknown): value is null | undefined;
 export declare function isRecord<T>(value: unknown): value is Record<string, T>;
 export declare function isEmpty(obj: unknown): boolean;
@@ -15,6 +20,6 @@ export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };
-export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T | unknown): T;
+export declare function checkArguments<T extends ZodType>(prefix: string, schema: T, args: unknown): z.infer<T>;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error?: Nullish<string | Error | ((error: Error) => Nullish<Error>)>): P | undefined;