@aigne/default-memory 1.0.0

package/lib/cjs/memory.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMemoryRecorder = exports.DefaultMemoryRetriever = exports.DefaultMemory = void 0;
+const core_1 = require("@aigne/core");
+const type_utils_js_1 = require("@aigne/core/utils/type-utils.js");
+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 = {}) {
+        const storage = options.storage instanceof storage_js_1.MemoryStorage
+            ? options.storage
+            : new index_js_1.DefaultMemoryStorage(options.storage);
+        super({
+            ...options,
+            recorder: options.recorder ?? new DefaultMemoryRecorder({ ...options, storage }),
+            retriever: options.retriever ??
+                new DefaultMemoryRetriever({
+                    ...options,
+                    retrieveRecentMemoryCount: options.retrieveRecentMemoryCount ??
+                        Math.ceil(options.retrieveMemoryCount ?? DEFAULT_RETRIEVE_MEMORY_COUNT) / 2,
+                    storage,
+                }),
+            autoUpdate: options.autoUpdate ?? true,
+        });
+        this.storage = storage;
+    }
+    storage;
+}
+exports.DefaultMemory = DefaultMemory;
+class DefaultMemoryRetriever extends core_1.MemoryRetriever {
+    constructor(options) {
+        super(options);
+        this.storage = options.storage;
+        this.retrieveMemoryCount = options.retrieveMemoryCount;
+        this.retrieveRecentMemoryCount = options.retrieveRecentMemoryCount;
+        this.inputKey = (0, type_utils_js_1.flat)(options.inputKey);
+        this.outputKey = (0, type_utils_js_1.flat)(options.outputKey);
+        if (options.getSearchPattern)
+            this.getSearchPattern = options.getSearchPattern;
+        if (options.formatMessage)
+            this.formatMessage = options.formatMessage;
+        if (options.formatMemory)
+            this.formatMemory = options.formatMemory;
+    }
+    storage;
+    retrieveMemoryCount;
+    retrieveRecentMemoryCount;
+    inputKey;
+    outputKey;
+    getSearchPattern = (search) => {
+        if (!search || typeof search === "string")
+            return search;
+        const obj = search && this.inputKey ? (0, type_utils_js_1.pick)(search, this.inputKey) : search;
+        return Object.values(obj)
+            .map((v) => (typeof v === "string" ? v : undefined))
+            .join("\n");
+    };
+    formatMessage = (content, key) => {
+        if (!(0, type_utils_js_1.isRecord)(content))
+            return content;
+        const obj = !key?.length ? content : (0, type_utils_js_1.pick)(content, key);
+        return Object.values(obj)
+            .map((v) => (typeof v === "string" ? v : undefined))
+            .join("\n");
+    };
+    formatMemory = (content) => {
+        if ((0, type_utils_js_1.isRecord)(content) && "input" in content && "output" in content) {
+            return {
+                input: this.formatMessage(content.input, this.inputKey),
+                output: this.formatMessage(content.output, this.outputKey),
+                source: content.source,
+            };
+        }
+        return content;
+    };
+    async process(input, options) {
+        const limit = input.limit ?? this.retrieveMemoryCount ?? DEFAULT_RETRIEVE_MEMORY_COUNT;
+        const search = this.getSearchPattern(input.search);
+        const recentLimit = this.retrieveRecentMemoryCount;
+        const [recent, related] = await Promise.all([
+            // Query latest messages
+            !recentLimit
+                ? []
+                : this.storage
+                    .search({ limit: recentLimit, orderBy: ["createdAt", "desc"] }, options)
+                    .then(({ result }) => result.reverse()),
+            // Query related messages
+            !input.search
+                ? []
+                : this.storage.search({ ...input, search, limit }, options).then(({ result }) => result),
+        ]);
+        const recentSet = new Set(recent.map((i) => i.id));
+        const memories = related
+            // Filter out recent memories from related results
+            .filter((i) => !recentSet.has(i.id))
+            .concat(recent)
+            .slice(-limit);
+        return {
+            memories: memories.map((i) => ({
+                ...i,
+                content: this.formatMemory(i.content),
+            })),
+        };
+    }
+}
+exports.DefaultMemoryRetriever = DefaultMemoryRetriever;
+class DefaultMemoryRecorder extends core_1.MemoryRecorder {
+    constructor(options) {
+        super(options);
+        this.storage = options.storage;
+        this.inputKey = (0, type_utils_js_1.flat)(options.inputKey);
+        this.outputKey = (0, type_utils_js_1.flat)(options.outputKey);
+    }
+    storage;
+    inputKey;
+    outputKey;
+    async process(input, options) {
+        const newMemories = [];
+        for (const item of input.content) {
+            const { result } = await this.storage.create({
+                content: {
+                    input: item.input && this.inputKey?.length ? (0, type_utils_js_1.pick)(item.input, this.inputKey) : item.input,
+                    output: item.output && this.outputKey?.length
+                        ? (0, type_utils_js_1.pick)(item.output, this.outputKey)
+                        : item.output,
+                    source: item.source,
+                },
+            }, options);
+            newMemories.push(result);
+        }
+        return {
+            memories: newMemories,
+        };
+    }
+}
+exports.DefaultMemoryRecorder = DefaultMemoryRecorder;

package/lib/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/lib/cjs/storage.d.ts

@@ -0,0 +1,13 @@
+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;
+        orderBy?: [string, "asc" | "desc"];
+    }, options: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+}

package/lib/cjs/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/dts/default-memory-storage/index.d.ts

@@ -0,0 +1,29 @@
+import type { AgentInvokeOptions, Context, Memory } from "@aigne/core";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import type { SqliteRemoteDatabase } from "drizzle-orm/sqlite-proxy";
+import { MemoryStorage } from "../storage.js";
+import { Memories } from "./models/memory.js";
+export interface DefaultMemoryStorageOptions {
+    url?: string;
+    getSessionId?: (context: Context) => PromiseOrValue<string>;
+    enableFTS?: boolean;
+}
+export declare class DefaultMemoryStorage extends MemoryStorage {
+    options?: DefaultMemoryStorageOptions | undefined;
+    constructor(options?: DefaultMemoryStorageOptions | undefined);
+    private _db;
+    private initSqlite;
+    get db(): Promise<SqliteRemoteDatabase<Record<string, never>>>;
+    private convertMemory;
+    search(query: {
+        search?: string;
+        limit?: number;
+        orderBy?: [keyof typeof Memories.$inferSelect, "asc" | "desc"];
+    }, { context }: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">, { context }: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+    protected segment(str: string): string[];
+}

package/lib/dts/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-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-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/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./default-memory-storage/index.js";
+export * from "./memory.js";
+export * from "./storage.js";

package/lib/dts/memory.d.ts

@@ -0,0 +1,44 @@
+import { type AgentInvokeOptions, type AgentOptions, MemoryAgent, type MemoryAgentOptions, MemoryRecorder, type MemoryRecorderInput, type MemoryRecorderOutput, MemoryRetriever, type MemoryRetrieverInput, type MemoryRetrieverOutput } from "@aigne/core";
+import { type DefaultMemoryStorageOptions } from "./default-memory-storage/index.js";
+import { MemoryStorage } from "./storage.js";
+export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions>, Omit<DefaultMemoryRecorderOptions, "storage" | keyof AgentOptions>, Omit<DefaultMemoryRetrieverOptions, "storage" | keyof AgentOptions> {
+    storage?: MemoryStorage | DefaultMemoryStorageOptions;
+}
+export declare class DefaultMemory extends MemoryAgent {
+    constructor(options?: DefaultMemoryOptions);
+    storage: MemoryStorage;
+}
+export interface DefaultMemoryRetrieverOptions extends AgentOptions<MemoryRetrieverInput, MemoryRetrieverOutput> {
+    storage: MemoryStorage;
+    retrieveMemoryCount?: number;
+    retrieveRecentMemoryCount?: number;
+    inputKey?: string | string[];
+    outputKey?: string | string[];
+    getSearchPattern?: DefaultMemoryRetriever["getSearchPattern"];
+    formatMessage?: DefaultMemoryRetriever["formatMessage"];
+    formatMemory?: DefaultMemoryRetriever["formatMemory"];
+}
+export declare class DefaultMemoryRetriever extends MemoryRetriever {
+    constructor(options: DefaultMemoryRetrieverOptions);
+    private storage;
+    private retrieveMemoryCount?;
+    private retrieveRecentMemoryCount?;
+    private inputKey?;
+    private outputKey?;
+    private getSearchPattern;
+    private formatMessage;
+    private formatMemory;
+    process(input: MemoryRetrieverInput, options: AgentInvokeOptions): Promise<MemoryRetrieverOutput>;
+}
+export interface DefaultMemoryRecorderOptions extends AgentOptions<MemoryRecorderInput, MemoryRecorderOutput> {
+    storage: MemoryStorage;
+    inputKey?: string | string[];
+    outputKey?: string | string[];
+}
+export declare class DefaultMemoryRecorder extends MemoryRecorder {
+    constructor(options: DefaultMemoryRecorderOptions);
+    private storage;
+    private inputKey?;
+    private outputKey?;
+    process(input: MemoryRecorderInput, options: AgentInvokeOptions): Promise<MemoryRecorderOutput>;
+}

package/lib/dts/storage.d.ts

@@ -0,0 +1,13 @@
+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;
+        orderBy?: [string, "asc" | "desc"];
+    }, options: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+}

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

@@ -0,0 +1,29 @@
+import type { AgentInvokeOptions, Context, Memory } from "@aigne/core";
+import type { PromiseOrValue } from "@aigne/core/utils/type-utils.js";
+import type { SqliteRemoteDatabase } from "drizzle-orm/sqlite-proxy";
+import { MemoryStorage } from "../storage.js";
+import { Memories } from "./models/memory.js";
+export interface DefaultMemoryStorageOptions {
+    url?: string;
+    getSessionId?: (context: Context) => PromiseOrValue<string>;
+    enableFTS?: boolean;
+}
+export declare class DefaultMemoryStorage extends MemoryStorage {
+    options?: DefaultMemoryStorageOptions | undefined;
+    constructor(options?: DefaultMemoryStorageOptions | undefined);
+    private _db;
+    private initSqlite;
+    get db(): Promise<SqliteRemoteDatabase<Record<string, never>>>;
+    private convertMemory;
+    search(query: {
+        search?: string;
+        limit?: number;
+        orderBy?: [keyof typeof Memories.$inferSelect, "asc" | "desc"];
+    }, { context }: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">, { context }: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+    protected segment(str: string): string[];
+}

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

@@ -0,0 +1,91 @@
+import { initDatabase } from "@aigne/sqlite";
+import { asc, desc, eq, isNull, sql } from "drizzle-orm";
+import { v7 } from "uuid";
+import { stringify } from "yaml";
+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 = this.options?.enableFTS && query.search
+            ? await db
+                .select()
+                .from(Memories)
+                .innerJoin(sql `Memories_fts`, sql `Memories_fts.id = ${Memories.id}`)
+                .where(sql `Memories_fts MATCH ${sql.param(this.segment(query.search).join(" OR "))}`)
+                .orderBy(sql `bm25(Memories_fts)`)
+                .limit(limit)
+                .execute()
+                .then((rows) => rows.map((row) => row.Memories))
+            : await db
+                .select()
+                .from(Memories)
+                .where(sessionId ? eq(Memories.sessionId, sessionId) : isNull(Memories.sessionId))
+                .orderBy(query.orderBy
+                ? (query.orderBy[1] === "asc" ? asc : desc)(sql.identifier(query.orderBy[0]))
+                : desc(Memories.id))
+                .limit(limit)
+                .execute();
+        return {
+            result: memories.map(this.convertMemory),
+        };
+    }
+    async create(memory, { context }) {
+        const sessionId = (await this.options?.getSessionId?.(context)) ?? null;
+        const db = await this.db;
+        const id = v7();
+        const [[result]] = await Promise.all([
+            db
+                .insert(Memories)
+                .values({
+                ...memory,
+                id,
+                content: memory.content,
+                sessionId,
+            })
+                .returning()
+                .execute(),
+            this.options?.enableFTS &&
+                db.run(sql `\
+          insert into Memories_fts (id, content)
+          values (${sql.param(id)}, ${sql.param(this.segment(stringify(memory.content)).join(" "))})`),
+        ]);
+        if (!result)
+            throw new Error("Failed to create memory");
+        return { result: this.convertMemory(result) };
+    }
+    segment(str) {
+        return (Array.from(new Intl.Segmenter(undefined, { granularity: "word" }).segment(str))
+            .map((i) => i.segment)
+            // Remove non-alphanumeric characters and trim whitespace
+            .map((i) => i.replace(/[^\p{L}\p{N}\s]/gu, "").trim())
+            .filter(Boolean));
+    }
+}

package/lib/esm/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-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-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-storage/migrations/001-init.js

@@ -0,0 +1,20 @@
+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
+)
+`,
+        `\
+CREATE VIRTUAL TABLE "Memories_fts" USING fts5(
+  id UNINDEXED,
+  content
+)
+`,
+    ],
+};

package/lib/esm/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-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(),
+});