@aigne/core 1.16.0 → 1.17.0

package/lib/esm/memory/default-memory/default-memory-storage/index.js

@@ -0,0 +1,64 @@
+import "sqlite3";
+import { Sequelize } from "sequelize";
+import { logger } from "../../../utils/logger.js";
+import { MemoryStorage } from "../storage.js";
+import { migrate } from "./migrate.js";
+import { initMemoryModel } from "./models/memory.js";
+const DEFAULT_MAX_MEMORY_COUNT = 10;
+export class DefaultMemoryStorage extends MemoryStorage {
+    options;
+    memories = {};
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    _models;
+    get models() {
+        this._models ??= (async () => {
+            const sequelize = initSequelize(this.options?.path);
+            await migrate(sequelize);
+            return {
+                Memory: initMemoryModel(sequelize),
+            };
+        })();
+        return this._models;
+    }
+    convertMemory(m) {
+        return {
+            id: m.id,
+            sessionId: m.sessionId,
+            content: m.content,
+            createdAt: m.createdAt.toISOString(),
+        };
+    }
+    async search(query, { context }) {
+        const { limit = DEFAULT_MAX_MEMORY_COUNT } = query;
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const { Memory } = await this.models;
+        const memories = await Memory.findAll({
+            where: { sessionId },
+            order: [["id", "DESC"]],
+            limit,
+        });
+        return {
+            result: memories.reverse().map(this.convertMemory),
+        };
+    }
+    async create(memory, { context }) {
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const { Memory } = await this.models;
+        const m = await Memory.create({
+            ...memory,
+            sessionId,
+        });
+        return { result: this.convertMemory(m) };
+    }
+}
+export function initSequelize(path) {
+    const sequelize = new Sequelize({
+        logging: (sql) => logger.debug(sql),
+        storage: path,
+        dialect: "sqlite",
+    });
+    return sequelize;
+}

package/lib/esm/memory/default-memory/default-memory-storage/migrate.d.ts

@@ -0,0 +1,7 @@
+import type { Sequelize } from "sequelize";
+import { type MigrateDownOptions, type MigrateUpOptions } from "umzug";
+export declare const migrate: (sequelize: Sequelize, { type, upOptions, downOptions, }?: {
+    type?: "up" | "down";
+    upOptions?: MigrateUpOptions;
+    downOptions?: MigrateDownOptions;
+}) => Promise<void>;

package/lib/esm/memory/default-memory/default-memory-storage/migrate.js

@@ -0,0 +1,16 @@
+import { SequelizeStorage, Umzug } from "umzug";
+import * as init from "./migrations/20250523165801-init.js";
+export const migrate = async (sequelize, { type = "up", upOptions, downOptions, } = {}) => {
+    const umzug = new Umzug({
+        migrations: [{ ...init, name: "20241224202701-init" }],
+        context: sequelize.getQueryInterface(),
+        storage: new SequelizeStorage({ sequelize }),
+        logger: console,
+    });
+    if (type === "down") {
+        await umzug.down(downOptions);
+    }
+    else {
+        await umzug.up(upOptions);
+    }
+};

package/lib/esm/memory/default-memory/default-memory-storage/migrations/20250523165801-init.d.ts

@@ -0,0 +1,7 @@
+import { type QueryInterface } from "sequelize";
+export declare const up: ({ context: queryInterface }: {
+    context: QueryInterface;
+}) => Promise<void>;
+export declare const down: ({ context: queryInterface }: {
+    context: QueryInterface;
+}) => Promise<void>;

package/lib/esm/memory/default-memory/default-memory-storage/migrations/20250523165801-init.js

@@ -0,0 +1,28 @@
+import { DataTypes } from "sequelize";
+export const up = async ({ context: queryInterface }) => {
+    await queryInterface.createTable("Memories", {
+        id: {
+            type: DataTypes.STRING,
+            primaryKey: true,
+            allowNull: false,
+        },
+        createdAt: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        updatedAt: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        sessionId: {
+            type: DataTypes.STRING,
+        },
+        content: {
+            type: DataTypes.JSON,
+            allowNull: false,
+        },
+    });
+};
+export const down = async ({ context: queryInterface }) => {
+    await queryInterface.dropTable("Memories");
+};

package/lib/esm/memory/default-memory/default-memory-storage/models/memory.d.ts

@@ -0,0 +1,10 @@
+import { type CreationOptional, type InferAttributes, type InferCreationAttributes, Model } from "sequelize";
+import type { ModelStatic, Sequelize } from "sequelize";
+export interface Memory extends Model<InferAttributes<Memory>, InferCreationAttributes<Memory>> {
+    id: CreationOptional<string>;
+    createdAt: CreationOptional<Date>;
+    updatedAt: CreationOptional<Date>;
+    sessionId?: string | null;
+    content: unknown;
+}
+export declare function initMemoryModel(sequelize: Sequelize): ModelStatic<Memory>;

package/lib/esm/memory/default-memory/default-memory-storage/models/memory.js

@@ -0,0 +1,29 @@
+import { DataTypes, Model, } from "sequelize";
+import { v7 } from "uuid";
+const nextId = () => v7();
+export function initMemoryModel(sequelize) {
+    return class Memory extends Model {
+    }.init({
+        id: {
+            type: DataTypes.STRING,
+            primaryKey: true,
+            allowNull: false,
+            defaultValue: nextId,
+        },
+        createdAt: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        updatedAt: {
+            type: DataTypes.DATE,
+            allowNull: false,
+        },
+        sessionId: {
+            type: DataTypes.STRING,
+        },
+        content: {
+            type: DataTypes.JSON,
+            allowNull: false,
+        },
+    }, { sequelize });
+}

package/lib/esm/memory/default-memory/index.d.ts

@@ -0,0 +1,10 @@
+import { MemoryAgent, type MemoryAgentOptions } from "../memory.js";
+import { type DefaultMemoryStorageOptions } from "./default-memory-storage/index.js";
+import { MemoryStorage } from "./storage.js";
+export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions> {
+    storage?: MemoryStorage | DefaultMemoryStorageOptions;
+}
+export declare class DefaultMemory extends MemoryAgent {
+    constructor(options?: DefaultMemoryOptions);
+    storage: MemoryStorage;
+}

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/prompt/prompt-builder.d.ts

@@ -6,7 +6,13 @@ import type { Context } from "../aigne/context.js";
 import type { MemoryAgent } from "../memory/memory.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;

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/utils/type-utils.d.ts

@@ -1,4 +1,4 @@
-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;
@@ -20,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.16.0",
+  "version": "1.17.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
@@ -76,7 +76,10 @@
     "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",

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

@@ -1,16 +0,0 @@
-import { type Memory, MemoryAgent, type MemoryAgentOptions } from "./memory.js";
-export declare const DEFAULT_MAX_MEMORY_COUNT = 10;
-export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions> {
-}
-export declare class DefaultMemory extends MemoryAgent {
-    constructor(options?: DefaultMemoryOptions);
-    storage: Memory[];
-    search(options?: {
-        limit?: number;
-    }): Promise<{
-        result: Memory[];
-    }>;
-    create(memory: Pick<Memory, "content">): Promise<{
-        result: Memory;
-    }>;
-}

package/lib/dts/memory/default-memory.d.ts

@@ -1,16 +0,0 @@
-import { type Memory, MemoryAgent, type MemoryAgentOptions } from "./memory.js";
-export declare const DEFAULT_MAX_MEMORY_COUNT = 10;
-export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions> {
-}
-export declare class DefaultMemory extends MemoryAgent {
-    constructor(options?: DefaultMemoryOptions);
-    storage: Memory[];
-    search(options?: {
-        limit?: number;
-    }): Promise<{
-        result: Memory[];
-    }>;
-    create(memory: Pick<Memory, "content">): Promise<{
-        result: Memory;
-    }>;
-}

package/lib/esm/memory/default-memory.d.ts

@@ -1,16 +0,0 @@
-import { type Memory, MemoryAgent, type MemoryAgentOptions } from "./memory.js";
-export declare const DEFAULT_MAX_MEMORY_COUNT = 10;
-export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions> {
-}
-export declare class DefaultMemory extends MemoryAgent {
-    constructor(options?: DefaultMemoryOptions);
-    storage: Memory[];
-    search(options?: {
-        limit?: number;
-    }): Promise<{
-        result: Memory[];
-    }>;
-    create(memory: Pick<Memory, "content">): Promise<{
-        result: Memory;
-    }>;
-}