@aigne/agent-library 1.11.0 → 1.12.1

package/CHANGELOG.md

@@ -5,6 +5,32 @@
 
 * add schema transform ([#35](https://github.com/AIGNE-io/aigne-framework/issues/35)) ([c7d9a2c](https://github.com/AIGNE-io/aigne-framework/commit/c7d9a2c9fcab8d384d4198db5ff6ba4603846cdf))
 
+## [1.12.1](https://github.com/AIGNE-io/aigne-framework/compare/agent-library-v1.12.0...agent-library-v1.12.1) (2025-05-30)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.18.1
+    * @aigne/openai bumped to 0.2.2
+
+## [1.12.0](https://github.com/AIGNE-io/aigne-framework/compare/agent-library-v1.11.0...agent-library-v1.12.0) (2025-05-29)
+
+
+### Features
+
+* add memory agents support for client agent ([#139](https://github.com/AIGNE-io/aigne-framework/issues/139)) ([57044fa](https://github.com/AIGNE-io/aigne-framework/commit/57044fa87b8abcba395cd05f941d6d312ab65764))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/core bumped to 1.18.0
+    * @aigne/openai bumped to 0.2.1
+    * @aigne/sqlite bumped to 0.1.0
+
 ## [1.10.0](https://github.com/AIGNE-io/aigne-framework/compare/agent-library-v1.9.0...agent-library-v1.10.0) (2025-05-25)
 
 

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

@@ -0,0 +1,23 @@
+import type { AgentInvokeOptions, Context, Memory } from "@aigne/core";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import { MemoryStorage } from "../storage.js";
+export interface DefaultMemoryStorageOptions {
+    url?: string;
+    getSessionId?: (context: Context) => PromiseOrValue<string>;
+}
+export declare class DefaultMemoryStorage extends MemoryStorage {
+    options?: DefaultMemoryStorageOptions | undefined;
+    constructor(options?: DefaultMemoryStorageOptions | undefined);
+    private _db;
+    private initSqlite;
+    get db(): Promise<import("drizzle-orm/libsql/driver-core.js").LibSQLDatabase<Record<string, never>> | import("drizzle-orm/sqlite-proxy/driver.js").SqliteRemoteDatabase<Record<string, never>>>;
+    private convertMemory;
+    search(query: {
+        limit?: number;
+    }, { context }: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">, { context }: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+}

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMemoryStorage = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const drizzle_orm_1 = require("drizzle-orm");
+const storage_js_1 = require("../storage.js");
+const migrate_js_1 = require("./migrate.js");
+const memory_js_1 = require("./models/memory.js");
+const DEFAULT_MAX_MEMORY_COUNT = 10;
+class DefaultMemoryStorage extends storage_js_1.MemoryStorage {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    _db;
+    async initSqlite() {
+        const db = await (0, sqlite_1.initDatabase)({ url: this.options?.url });
+        await (0, migrate_js_1.migrate)(db);
+        return db;
+    }
+    get db() {
+        this._db ??= this.initSqlite();
+        return this._db;
+    }
+    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 db = await this.db;
+        const memories = await db
+            .select()
+            .from(memory_js_1.Memories)
+            .where(sessionId ? (0, drizzle_orm_1.eq)(memory_js_1.Memories.sessionId, sessionId) : (0, drizzle_orm_1.isNull)(memory_js_1.Memories.sessionId))
+            .orderBy((0, drizzle_orm_1.desc)(memory_js_1.Memories.id))
+            .limit(limit)
+            .execute();
+        return {
+            result: memories.reverse().map(this.convertMemory),
+        };
+    }
+    async create(memory, { context }) {
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const db = await this.db;
+        const [result] = await db
+            .insert(memory_js_1.Memories)
+            .values({
+            ...memory,
+            sessionId,
+        })
+            .returning()
+            .execute();
+        if (!result)
+            throw new Error("Failed to create memory");
+        return { result: this.convertMemory(result) };
+    }
+}
+exports.DefaultMemoryStorage = DefaultMemoryStorage;

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

@@ -0,0 +1,3 @@
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { SqliteRemoteDatabase } from "drizzle-orm/sqlite-proxy";
+export declare function migrate(db: LibSQLDatabase | SqliteRemoteDatabase): Promise<void>;

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

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = migrate;
+const sql_1 = require("drizzle-orm/sql");
+const _001_init_js_1 = __importDefault(require("./migrations/001-init.js"));
+async function migrate(db) {
+    const migrations = [_001_init_js_1.default];
+    const migrationsTable = "__drizzle_migrations";
+    const migrationTableCreate = (0, sql_1.sql) `
+    CREATE TABLE IF NOT EXISTS ${sql_1.sql.identifier(migrationsTable)} (
+      id SERIAL PRIMARY KEY,
+      hash text NOT NULL
+    )
+  `;
+    await db.run(migrationTableCreate).execute();
+    const dbMigrations = await db
+        .values((0, sql_1.sql) `SELECT id, hash FROM ${sql_1.sql.identifier(migrationsTable)} ORDER BY id DESC LIMIT 1`)
+        .execute();
+    const lastDbMigration = dbMigrations[0];
+    const queriesToRun = [];
+    for (const migration of migrations) {
+        if (!lastDbMigration || lastDbMigration[1] < migration.hash) {
+            queriesToRun.push(...migration.sql, `INSERT INTO \`${migrationsTable}\` ("hash") VALUES('${migration.hash}')`);
+        }
+    }
+    for (const query of queriesToRun) {
+        await db.run(query).execute();
+    }
+}

package/lib/cjs/default-memory/default-memory-storage/migrations/001-init.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    hash: string;
+    sql: string[];
+};
+export default _default;

package/lib/cjs/default-memory/default-memory-storage/migrations/001-init.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    hash: "001-init",
+    sql: [
+        `\
+CREATE TABLE "Memories" (
+  "id" TEXT NOT NULL PRIMARY KEY,
+  "createdAt" DATETIME NOT NULL,
+  "updatedAt" DATETIME NOT NULL,
+  "sessionId" TEXT,
+  "content" JSON NOT NULL
+)
+`,
+    ],
+};

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

@@ -0,0 +1,102 @@
+export declare const Memories: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "Memories";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "createdAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        sessionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "sessionId";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memories = void 0;
+const type_js_1 = require("@aigne/sqlite/type.js");
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+const uuid_1 = require("uuid");
+exports.Memories = (0, sqlite_core_1.sqliteTable)("Memories", {
+    id: (0, sqlite_core_1.text)("id")
+        .notNull()
+        .primaryKey()
+        .$defaultFn(() => (0, uuid_1.v7)()),
+    createdAt: (0, type_js_1.datetime)("createdAt")
+        .notNull()
+        .$defaultFn(() => new Date()),
+    updatedAt: (0, type_js_1.datetime)("updatedAt")
+        .notNull()
+        .$defaultFn(() => new Date())
+        .$onUpdateFn(() => new Date()),
+    sessionId: (0, sqlite_core_1.text)("sessionId"),
+    content: (0, type_js_1.json)("content").notNull(),
+});

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

@@ -0,0 +1,10 @@
+import { MemoryAgent, type MemoryAgentOptions } from "@aigne/core";
+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/cjs/default-memory/index.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMemory = void 0;
+const core_1 = require("@aigne/core");
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const index_js_1 = require("./default-memory-storage/index.js");
+const storage_js_1 = require("./storage.js");
+const DEFAULT_RETRIEVE_MEMORY_COUNT = 10;
+class DefaultMemory extends core_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;
+}
+exports.DefaultMemory = DefaultMemory;
+class DefaultMemoryRetriever extends core_1.MemoryRetriever {
+    memory;
+    constructor(memory) {
+        super({});
+        this.memory = memory;
+    }
+    async process(input, options) {
+        const { result } = await this.memory.storage.search({ ...input, limit: input.limit ?? DEFAULT_RETRIEVE_MEMORY_COUNT }, options);
+        return { memories: result };
+    }
+}
+class DefaultMemoryRecorder extends core_1.MemoryRecorder {
+    memory;
+    constructor(memory) {
+        super({});
+        this.memory = memory;
+    }
+    async process(input, options) {
+        const newMemories = [];
+        for (const content of input.content) {
+            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.storage.create({ content }, options);
+                newMemories.push(result);
+            }
+        }
+        return {
+            memories: newMemories,
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { AgentInvokeOptions, Memory } from "@aigne/core";
+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/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/fs-memory/index.js

@@ -5,9 +5,9 @@ const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const core_1 = require("@aigne/core");
 const index_js_1 = require("@aigne/core/memory/index.js");
-const fs_js_1 = require("@aigne/core/utils/fs.js");
 const yaml_1 = require("yaml");
 const zod_1 = require("zod");
+const fs_js_1 = require("../utils/fs.js");
 exports.MEMORY_FILE_NAME = "memory.yaml";
 /**
  * A memory implementation that stores and retrieves memories using the file system.

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

@@ -0,0 +1,2 @@
+export declare function exists(path: string): Promise<boolean>;
+export declare function expandHome(filepath: string): string;

package/lib/cjs/utils/fs.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exists = exists;
+exports.expandHome = expandHome;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+async function exists(path) {
+    try {
+        await (0, promises_1.stat)(path);
+        return true;
+    }
+    catch (e) {
+        if (e.code === "ENOENT") {
+            return false;
+        }
+        throw e;
+    }
+}
+function expandHome(filepath) {
+    if (filepath.startsWith("~/") || filepath === "~") {
+        return (0, node_path_1.join)((0, node_os_1.homedir)(), filepath.slice(1));
+    }
+    return filepath;
+}

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

@@ -0,0 +1,23 @@
+import type { AgentInvokeOptions, Context, Memory } from "@aigne/core";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import { MemoryStorage } from "../storage.js";
+export interface DefaultMemoryStorageOptions {
+    url?: string;
+    getSessionId?: (context: Context) => PromiseOrValue<string>;
+}
+export declare class DefaultMemoryStorage extends MemoryStorage {
+    options?: DefaultMemoryStorageOptions | undefined;
+    constructor(options?: DefaultMemoryStorageOptions | undefined);
+    private _db;
+    private initSqlite;
+    get db(): Promise<import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>>;
+    private convertMemory;
+    search(query: {
+        limit?: number;
+    }, { context }: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">, { context }: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+}

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

@@ -0,0 +1,3 @@
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { SqliteRemoteDatabase } from "drizzle-orm/sqlite-proxy";
+export declare function migrate(db: LibSQLDatabase | SqliteRemoteDatabase): Promise<void>;

package/lib/dts/default-memory/default-memory-storage/migrations/001-init.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    hash: string;
+    sql: string[];
+};
+export default _default;

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

@@ -0,0 +1,102 @@
+export declare const Memories: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "Memories";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "createdAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        sessionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "sessionId";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

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

@@ -0,0 +1,10 @@
+import { MemoryAgent, type MemoryAgentOptions } from "@aigne/core";
+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/dts/default-memory/storage.d.ts

@@ -0,0 +1,12 @@
+import type { AgentInvokeOptions, Memory } from "@aigne/core";
+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/dts/utils/fs.d.ts

@@ -0,0 +1,2 @@
+export declare function exists(path: string): Promise<boolean>;
+export declare function expandHome(filepath: string): string;

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

@@ -0,0 +1,23 @@
+import type { AgentInvokeOptions, Context, Memory } from "@aigne/core";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import { MemoryStorage } from "../storage.js";
+export interface DefaultMemoryStorageOptions {
+    url?: string;
+    getSessionId?: (context: Context) => PromiseOrValue<string>;
+}
+export declare class DefaultMemoryStorage extends MemoryStorage {
+    options?: DefaultMemoryStorageOptions | undefined;
+    constructor(options?: DefaultMemoryStorageOptions | undefined);
+    private _db;
+    private initSqlite;
+    get db(): Promise<import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>>;
+    private convertMemory;
+    search(query: {
+        limit?: number;
+    }, { context }: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">, { context }: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+}

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

@@ -0,0 +1,61 @@
+import { initDatabase } from "@aigne/sqlite";
+import { desc, eq, isNull } from "drizzle-orm";
+import { MemoryStorage } from "../storage.js";
+import { migrate } from "./migrate.js";
+import { Memories } from "./models/memory.js";
+const DEFAULT_MAX_MEMORY_COUNT = 10;
+export class DefaultMemoryStorage extends MemoryStorage {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    _db;
+    async initSqlite() {
+        const db = await initDatabase({ url: this.options?.url });
+        await migrate(db);
+        return db;
+    }
+    get db() {
+        this._db ??= this.initSqlite();
+        return this._db;
+    }
+    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 db = await this.db;
+        const memories = await db
+            .select()
+            .from(Memories)
+            .where(sessionId ? eq(Memories.sessionId, sessionId) : isNull(Memories.sessionId))
+            .orderBy(desc(Memories.id))
+            .limit(limit)
+            .execute();
+        return {
+            result: memories.reverse().map(this.convertMemory),
+        };
+    }
+    async create(memory, { context }) {
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const db = await this.db;
+        const [result] = await db
+            .insert(Memories)
+            .values({
+            ...memory,
+            sessionId,
+        })
+            .returning()
+            .execute();
+        if (!result)
+            throw new Error("Failed to create memory");
+        return { result: this.convertMemory(result) };
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { SqliteRemoteDatabase } from "drizzle-orm/sqlite-proxy";
+export declare function migrate(db: LibSQLDatabase | SqliteRemoteDatabase): Promise<void>;

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

@@ -0,0 +1,26 @@
+import { sql } from "drizzle-orm/sql";
+import init from "./migrations/001-init.js";
+export async function migrate(db) {
+    const migrations = [init];
+    const migrationsTable = "__drizzle_migrations";
+    const migrationTableCreate = sql `
+    CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+      id SERIAL PRIMARY KEY,
+      hash text NOT NULL
+    )
+  `;
+    await db.run(migrationTableCreate).execute();
+    const dbMigrations = await db
+        .values(sql `SELECT id, hash FROM ${sql.identifier(migrationsTable)} ORDER BY id DESC LIMIT 1`)
+        .execute();
+    const lastDbMigration = dbMigrations[0];
+    const queriesToRun = [];
+    for (const migration of migrations) {
+        if (!lastDbMigration || lastDbMigration[1] < migration.hash) {
+            queriesToRun.push(...migration.sql, `INSERT INTO \`${migrationsTable}\` ("hash") VALUES('${migration.hash}')`);
+        }
+    }
+    for (const query of queriesToRun) {
+        await db.run(query).execute();
+    }
+}

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

@@ -0,0 +1,5 @@
+declare const _default: {
+    hash: string;
+    sql: string[];
+};
+export default _default;

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

@@ -0,0 +1,14 @@
+export default {
+    hash: "001-init",
+    sql: [
+        `\
+CREATE TABLE "Memories" (
+  "id" TEXT NOT NULL PRIMARY KEY,
+  "createdAt" DATETIME NOT NULL,
+  "updatedAt" DATETIME NOT NULL,
+  "sessionId" TEXT,
+  "content" JSON NOT NULL
+)
+`,
+    ],
+};

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

@@ -0,0 +1,102 @@
+export declare const Memories: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "Memories";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "createdAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        sessionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "sessionId";
+            tableName: "Memories";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "Memories";
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

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

@@ -0,0 +1,18 @@
+import { datetime, json } from "@aigne/sqlite/type.js";
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { v7 } from "uuid";
+export const Memories = sqliteTable("Memories", {
+    id: text("id")
+        .notNull()
+        .primaryKey()
+        .$defaultFn(() => v7()),
+    createdAt: datetime("createdAt")
+        .notNull()
+        .$defaultFn(() => new Date()),
+    updatedAt: datetime("updatedAt")
+        .notNull()
+        .$defaultFn(() => new Date())
+        .$onUpdateFn(() => new Date()),
+    sessionId: text("sessionId"),
+    content: json("content").notNull(),
+});

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

@@ -0,0 +1,10 @@
+import { MemoryAgent, type MemoryAgentOptions } from "@aigne/core";
+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/default-memory/index.js

@@ -0,0 +1,53 @@
+import { MemoryAgent, MemoryRecorder, MemoryRetriever, } from "@aigne/core";
+import equal from "fast-deep-equal";
+import { DefaultMemoryStorage, } from "./default-memory-storage/index.js";
+import { MemoryStorage } from "./storage.js";
+const DEFAULT_RETRIEVE_MEMORY_COUNT = 10;
+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;
+}
+class DefaultMemoryRetriever extends MemoryRetriever {
+    memory;
+    constructor(memory) {
+        super({});
+        this.memory = memory;
+    }
+    async process(input, options) {
+        const { result } = await this.memory.storage.search({ ...input, limit: input.limit ?? DEFAULT_RETRIEVE_MEMORY_COUNT }, options);
+        return { memories: result };
+    }
+}
+class DefaultMemoryRecorder extends MemoryRecorder {
+    memory;
+    constructor(memory) {
+        super({});
+        this.memory = memory;
+    }
+    async process(input, options) {
+        const newMemories = [];
+        for (const content of input.content) {
+            const { result: [last], } = await this.memory.storage.search({ limit: 1 }, options);
+            if (!equal(last?.content, content)) {
+                const { result } = await this.memory.storage.create({ content }, options);
+                newMemories.push(result);
+            }
+        }
+        return {
+            memories: newMemories,
+        };
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { AgentInvokeOptions, Memory } from "@aigne/core";
+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/default-memory/storage.js

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

package/lib/esm/fs-memory/index.js

@@ -2,9 +2,9 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
 import { AIAgent } from "@aigne/core";
 import { MemoryAgent, MemoryRecorder, MemoryRetriever, newMemoryId, } from "@aigne/core/memory/index.js";
-import { exists, expandHome } from "@aigne/core/utils/fs.js";
 import { stringify } from "yaml";
 import { z } from "zod";
+import { exists, expandHome } from "../utils/fs.js";
 export const MEMORY_FILE_NAME = "memory.yaml";
 /**
  * A memory implementation that stores and retrieves memories using the file system.

package/lib/esm/utils/fs.d.ts

@@ -0,0 +1,2 @@
+export declare function exists(path: string): Promise<boolean>;
+export declare function expandHome(filepath: string): string;

package/lib/esm/utils/fs.js

@@ -0,0 +1,21 @@
+import { stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (e) {
+        if (e.code === "ENOENT") {
+            return false;
+        }
+        throw e;
+    }
+}
+export function expandHome(filepath) {
+    if (filepath.startsWith("~/") || filepath === "~") {
+        return join(homedir(), filepath.slice(1));
+    }
+    return filepath;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/agent-library",
-  "version": "1.11.0",
+  "version": "1.12.1",
   "description": "Collection of agent libraries for AIGNE framework",
   "publishConfig": {
     "access": "public"
@@ -39,18 +39,21 @@
     }
   },
   "dependencies": {
+    "drizzle-orm": "^0.43.1",
+    "fastq": "^1.19.1",
     "jsonata": "^2.0.6",
     "jsonschema": "^1.5.0",
     "to-json-schema": "^0.2.5",
-    "fastq": "^1.19.1",
+    "uuid": "^11.1.0",
     "yaml": "^2.7.1",
     "zod": "^3.24.4",
-    "@aigne/core": "^1.17.0",
-    "@aigne/openai": "^0.2.0"
+    "@aigne/core": "^1.18.1",
+    "@aigne/sqlite": "^0.1.0",
+    "@aigne/openai": "^0.2.2"
   },
   "devDependencies": {
-    "@types/to-json-schema": "^0.2.4",
     "@types/bun": "^1.2.12",
+    "@types/to-json-schema": "^0.2.4",
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3"