@aigne/core 1.15.0 → 1.17.0

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

@@ -1,34 +1,25 @@
 import equal from "fast-deep-equal";
-import { MemoryAgent, newMemoryId } from "./memory.js";
-import { MemoryRecorder } from "./recorder.js";
-import { MemoryRetriever, } from "./retriever.js";
-export const DEFAULT_MAX_MEMORY_COUNT = 10;
+import { MemoryAgent } from "../memory.js";
+import { MemoryRecorder, } from "../recorder.js";
+import { MemoryRetriever, } from "../retriever.js";
+import { DefaultMemoryStorage, } from "./default-memory-storage/index.js";
+import { MemoryStorage } from "./storage.js";
 export class DefaultMemory extends MemoryAgent {
     constructor(options = {}) {
         super({
             ...options,
             autoUpdate: options.autoUpdate ?? true,
         });
+        this.storage =
+            options.storage instanceof MemoryStorage
+                ? options.storage
+                : new 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 = 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: newMemoryId(),
-            createdAt: new Date().toISOString(),
-        };
-        this.storage.push(m);
-        return { result: m };
-    }
+    storage;
 }
 class DefaultMemoryRetriever extends MemoryRetriever {
     memory;
@@ -36,8 +27,8 @@ class DefaultMemoryRetriever extends 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 };
     }
 }
@@ -47,12 +38,12 @@ class DefaultMemoryRecorder extends 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 (!equal(last?.content, content)) {
-                const { result } = await this.memory.create({ content });
+                const { result } = await this.memory.storage.create({ content }, options);
                 newMemories.push(result);
             }
         }

package/lib/esm/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/esm/memory/default-memory/storage.js

@@ -0,0 +1,2 @@
+export class MemoryStorage {
+}

package/lib/esm/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/esm/memory/memory.js

@@ -1,6 +1,6 @@
 import { v7 } from "uuid";
 import { z } from "zod";
-import { Agent } from "../agents/agent.js";
+import { Agent, } from "../agents/agent.js";
 import { checkArguments, remove } from "../utils/type-utils.js";
 export const newMemoryId = () => v7();
 /**
@@ -81,7 +81,7 @@ export 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.
      */
-    async process(_input, _context) {
+    async process(_input, _options) {
         throw new Error("Method not implemented.");
     }
     /**

package/lib/esm/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/esm/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/esm/prompt/prompt-builder.js

@@ -7,10 +7,10 @@ import { isNil, orArrayToArray, unique } from "../utils/type-utils.js";
 import { MEMORY_MESSAGE_TEMPLATE } from "./prompts/memory-message-template.js";
 import { AgentMessageTemplate, ChatMessagesTemplate, PromptTemplate, SystemMessageTemplate, UserMessageTemplate, } from "./template.js";
 export const MESSAGE_KEY = "$message";
-export function createMessage(message) {
-    return typeof message === "string"
-        ? { [MESSAGE_KEY]: message }
-        : { ...message };
+export function createMessage(message, variables) {
+    return (typeof message === "string"
+        ? { [MESSAGE_KEY]: message, ...variables }
+        : { ...message, ...variables });
 }
 export function getMessage(input) {
     const userInputMessage = input[MESSAGE_KEY];

package/lib/esm/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/esm/utils/json-schema.js

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

package/lib/esm/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/esm/utils/logger.js

@@ -1,6 +1,63 @@
+import { isatty } from "node:tty";
 import debug from "debug";
-const base = debug("aigne");
-export const logger = Object.assign(debug, {
-    core: base.extend("core"),
-    mcp: base.extend("mcp"),
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["ERROR"] = "error";
+    LogLevel["WARN"] = "warn";
+    LogLevel["INFO"] = "info";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (LogLevel = {}));
+const levels = Object.values(LogLevel);
+export class Logger {
+    constructor(options) {
+        this.level = options.level;
+        this.debugLogger = debug(`${options.ns}:debug`);
+        this.infoLogger = debug(`${options.ns}:info`);
+        this.warnLogger = debug(`${options.ns}:warn`);
+        this.errorLogger = debug(`${options.ns}:error`);
+        for (const logger of [this.debugLogger, this.infoLogger, this.warnLogger]) {
+            // @ts-ignore
+            logger.useColors = 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 = 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);
+    }
+}
+export const logger = new Logger({
+    ns: "aigne:core",
+    level: LogLevel.INFO,
 });

package/lib/esm/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/esm/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/esm/utils/stream-utils.js

@@ -98,7 +98,7 @@ export function onAgentResponseStreamEnd(stream, callback, options) {
                 }
             }
             catch (error) {
-                controller.error(options?.errorCallback?.(error) ?? error);
+                controller.error((await options?.errorCallback?.(error)) ?? error);
             }
         },
     });
@@ -151,3 +151,31 @@ export function stringToAgentResponseStream(str, key = "text") {
     const segments = segmenter.segment(str);
     return arrayToReadableStream(Array.from(segments).map((segment) => ({ delta: { text: { [key]: segment.segment } } })));
 }
+export 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);
+        },
+    });
+}
+export async function readAllString(stream) {
+    return (await readableStreamToArray((stream instanceof ReadableStream ? stream : toReadableStream(stream)).pipeThrough(new TextDecoderStream()))).join("");
+}

package/lib/esm/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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.15.0",
+  "version": "1.17.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -50,9 +50,6 @@
       "loader/*": [
         "./lib/dts/loader/*"
       ],
-      "models/*": [
-        "./lib/dts/models/*"
-      ],
       "memory/*": [
         "./lib/dts/memory/*"
       ],
@@ -61,12 +58,6 @@
       ],
       "utils/*": [
         "./lib/dts/utils/*"
-      ],
-      "client/*": [
-        "./lib/dts/client/*"
-      ],
-      "server/*": [
-        "./lib/dts/server/*"
       ]
     }
   },
@@ -85,21 +76,16 @@
     "nanoid": "^5.1.5",
     "p-retry": "^6.2.1",
     "raw-body": "^3.0.0",
+    "sequelize": "^6.37.7",
+    "sqlite3": "^5.1.7",
     "ufo": "^1.6.1",
+    "umzug": "^3.8.2",
     "uuid": "^11.1.0",
     "yaml": "^2.7.1",
     "zod": "^3.24.4",
     "zod-to-json-schema": "^3.24.5"
   },
-  "peerDependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
-    "@aws-sdk/client-bedrock-runtime": "^3.796.0",
-    "@google/generative-ai": "^0.24.0",
-    "openai": "^4.87.3"
-  },
   "devDependencies": {
-    "@anthropic-ai/sdk": "^0.41.0",
-    "@google/generative-ai": "^0.24.1",
     "@types/bun": "^1.2.12",
     "@types/compression": "^1.7.5",
     "@types/content-type": "^1.1.8",
@@ -109,9 +95,7 @@
     "compression": "^1.8.0",
     "detect-port": "^2.1.0",
     "express": "^5.1.0",
-    "hono": "^4.7.8",
     "npm-run-all": "^4.1.5",
-    "openai": "^4.97.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3"
   },

package/lib/cjs/client/client.d.ts

@@ -1,97 +0,0 @@
-/**
- * Client module used to interact with the AIGNE framework.
- */
-import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "../agents/agent.js";
-/**
- * Configuration options for the AIGNEClient.
- */
-export interface AIGNEClientOptions {
-    /**
-     * The URL of the AIGNE server to connect to.
-     * This should point to the base endpoint where the AIGNEServer is hosted.
-     */
-    url: string;
-}
-/**
- * Options for invoking an agent through the AIGNEClient.
- * Extends the standard AgentInvokeOptions with client-specific options.
- */
-export interface AIGNEClientInvokeOptions extends AgentInvokeOptions {
-    /**
-     * Additional fetch API options to customize the HTTP request.
-     * These options will be merged with the default options used by the client.
-     */
-    fetchOptions?: Partial<RequestInit>;
-}
-/**
- * Client for interacting with a remote AIGNE server.
- * AIGNEClient provides a client-side interface that matches the AIGNE API,
- * allowing applications to invoke agents and receive responses from a remote AIGNE instance.
- *
- * @example
- * Here's a simple example of how to use AIGNEClient:
- * {@includeCode ../../test/client/client.test.ts#example-aigne-client-simple}
- *
- * @example
- * Here's an example of how to use AIGNEClient with streaming response:
- * {@includeCode ../../test/client/client.test.ts#example-aigne-client-streaming}
- */
-export declare class AIGNEClient {
-    options: AIGNEClientOptions;
-    /**
-     * Creates a new AIGNEClient instance.
-     *
-     * @param options - Configuration options for connecting to the AIGNE server
-     */
-    constructor(options: AIGNEClientOptions);
-    /**
-     * Invokes an agent in non-streaming mode and returns the complete response.
-     *
-     * @param agent - Name of the agent to invoke
-     * @param input - Input message for the agent
-     * @param options - Options with streaming mode explicitly set to false or omitted
-     * @returns The complete agent response
-     *
-     * @example
-     * Here's a simple example of how to use AIGNEClient:
-     * {@includeCode ../../test/client/client.test.ts#example-aigne-client-simple}
-     */
-    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions & {
-        streaming?: false;
-    }): Promise<O>;
-    /**
-     * Invokes an agent with streaming mode enabled and returns a stream of response chunks.
-     *
-     * @param agent - Name of the agent to invoke
-     * @param input - Input message for the agent
-     * @param options - Options with streaming mode explicitly set to true
-     * @returns A stream of agent response chunks
-     *
-     * @example
-     * Here's an example of how to use AIGNEClient with streaming response:
-     * {@includeCode ../../test/client/client.test.ts#example-aigne-client-streaming}
-     */
-    invoke<I extends Message, O extends Message>(agent: string, input: I, options: AIGNEClientInvokeOptions & {
-        streaming: true;
-    }): Promise<AgentResponseStream<O>>;
-    /**
-     * Invokes an agent with the given input and options.
-     *
-     * @param agent - Name of the agent to invoke
-     * @param input - Input message for the agent
-     * @param options - Options for the invocation
-     * @returns Either a complete response or a response stream depending on the streaming option
-     */
-    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions): Promise<AgentResponse<O>>;
-    /**
-     * Enhanced fetch method that handles error responses from the AIGNE server.
-     * This method wraps the standard fetch API to provide better error handling and reporting.
-     *
-     * @param args - Standard fetch API arguments (url and options)
-     * @returns A Response object if the request was successful
-     * @throws Error with detailed information if the request failed
-     *
-     * @private
-     */
-    fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
-}