@aigne/afs-history 1.1.3 → 1.2.0-beta.10

package/lib/cjs/storage/migrate.js

@@ -4,8 +4,18 @@ exports.migrate = migrate;
 const sqlite_1 = require("@aigne/sqlite");
 const uuid_1 = require("@aigne/uuid");
 const _001_init_js_1 = require("./migrations/001-init.js");
+const _002_add_agent_id_js_1 = require("./migrations/002-add-agent-id.js");
+const _003_add_compact_table_js_1 = require("./migrations/003-add-compact-table.js");
+const _004_add_memory_table_js_1 = require("./migrations/004-add-memory-table.js");
+const _005_add_indexes_js_1 = require("./migrations/005-add-indexes.js");
 async function migrate(db, module) {
-    const migrations = [_001_init_js_1.init];
+    const migrations = [
+        _001_init_js_1.init,
+        _002_add_agent_id_js_1.addAgentId,
+        _003_add_compact_table_js_1.addCompactTable,
+        _004_add_memory_table_js_1.addMemoryTable,
+        _005_add_indexes_js_1.addIndexes,
+    ];
     const migrationsTable = "__drizzle_migrations";
     const migrationTableCreate = (0, sqlite_1.sql) `
     CREATE TABLE IF NOT EXISTS ${sqlite_1.sql.identifier(migrationsTable)} (
@@ -14,18 +24,18 @@ async function migrate(db, module) {
       "hash" TEXT NOT NULL
     )
   `;
-    await (await db).run(migrationTableCreate).execute();
-    const dbMigrations = await (await db)
+    await db.run(migrationTableCreate).execute();
+    const dbMigrations = await db
         .values((0, sqlite_1.sql) `SELECT "id", "moduleId", "hash" FROM ${sqlite_1.sql.identifier(migrationsTable)} WHERE "moduleId" = ${sqlite_1.sql.param(module.name)} ORDER BY id DESC LIMIT 1`)
         .execute();
     const lastDbMigration = dbMigrations[0];
     const queriesToRun = [];
     for (const migration of migrations) {
-        if (!lastDbMigration || lastDbMigration[1] < migration.hash) {
+        if (!lastDbMigration || lastDbMigration[2] < migration.hash) {
             queriesToRun.push(...migration.sql(module), (0, sqlite_1.sql) `INSERT INTO ${sqlite_1.sql.identifier(migrationsTable)} ("id", "moduleId", "hash") VALUES(${sqlite_1.sql.param((0, uuid_1.v7)())}, ${sqlite_1.sql.param(module.name)}, ${sqlite_1.sql.param(migration.hash)})`);
         }
     }
     for (const query of queriesToRun) {
-        await (await db).run(query).execute();
+        await db.run(query).execute();
     }
 }

package/lib/cjs/storage/migrations/002-add-agent-id.d.ts

@@ -0,0 +1,2 @@
+import type { AFSStorageMigrations } from "../type.js";
+export declare const addAgentId: AFSStorageMigrations;

package/lib/cjs/storage/migrations/002-add-agent-id.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAgentId = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const entries_js_1 = require("../models/entries.js");
+exports.addAgentId = {
+    hash: "002-add-agent-id",
+    sql: (module) => [
+        (0, sqlite_1.sql) `\
+ALTER TABLE ${sqlite_1.sql.identifier((0, entries_js_1.entriesTableName)(module))} ADD COLUMN "agentId" TEXT;
+`,
+    ],
+};

package/lib/cjs/storage/migrations/003-add-compact-table.d.ts

@@ -0,0 +1,2 @@
+import type { AFSStorageMigrations } from "../type.js";
+export declare const addCompactTable: AFSStorageMigrations;

package/lib/cjs/storage/migrations/003-add-compact-table.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCompactTable = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const compact_js_1 = require("../models/compact.js");
+exports.addCompactTable = {
+    hash: "003-add-compact-table",
+    sql: (module) => [
+        (0, sqlite_1.sql) `\
+CREATE TABLE IF NOT EXISTS ${sqlite_1.sql.identifier((0, compact_js_1.compactTableName)(module))} (
+  "id" TEXT NOT NULL PRIMARY KEY,
+  "createdAt" DATETIME NOT NULL,
+  "updatedAt" DATETIME NOT NULL,
+  "path" TEXT NOT NULL,
+  "sessionId" TEXT,
+  "userId" TEXT,
+  "agentId" TEXT,
+  "metadata" JSON,
+  "content" JSON
+)
+`,
+    ],
+};

package/lib/cjs/storage/migrations/004-add-memory-table.d.ts

@@ -0,0 +1,2 @@
+import type { AFSStorageMigrations } from "../type.js";
+export declare const addMemoryTable: AFSStorageMigrations;

package/lib/cjs/storage/migrations/004-add-memory-table.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMemoryTable = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const memory_js_1 = require("../models/memory.js");
+exports.addMemoryTable = {
+    hash: "004-add-memory-table",
+    sql: (module) => [
+        (0, sqlite_1.sql) `\
+CREATE TABLE IF NOT EXISTS ${sqlite_1.sql.identifier((0, memory_js_1.memoryTableName)(module))} (
+  "id" TEXT NOT NULL PRIMARY KEY,
+  "createdAt" DATETIME NOT NULL,
+  "updatedAt" DATETIME NOT NULL,
+  "path" TEXT NOT NULL,
+  "sessionId" TEXT,
+  "userId" TEXT,
+  "agentId" TEXT,
+  "metadata" JSON,
+  "content" JSON
+)
+`,
+    ],
+};

package/lib/cjs/storage/migrations/005-add-indexes.d.ts

@@ -0,0 +1,2 @@
+import type { AFSStorageMigrations } from "../type.js";
+export declare const addIndexes: AFSStorageMigrations;

package/lib/cjs/storage/migrations/005-add-indexes.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addIndexes = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const compact_js_1 = require("../models/compact.js");
+const entries_js_1 = require("../models/entries.js");
+const memory_js_1 = require("../models/memory.js");
+exports.addIndexes = {
+    hash: "005-add-indexes",
+    sql: (module) => {
+        const entriesTable = (0, entries_js_1.entriesTableName)(module);
+        const memoryTable = (0, memory_js_1.memoryTableName)(module);
+        const compactTable = (0, compact_js_1.compactTableName)(module);
+        return [
+            // Entries table indexes
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_entries_session_created" ON ${sqlite_1.sql.identifier(entriesTable)} ("sessionId", "createdAt" DESC)`,
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_entries_user_created" ON ${sqlite_1.sql.identifier(entriesTable)} ("userId", "createdAt" DESC)`,
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_entries_agent_created" ON ${sqlite_1.sql.identifier(entriesTable)} ("agentId", "createdAt" DESC)`,
+            // Memory table indexes
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_memory_session_created" ON ${sqlite_1.sql.identifier(memoryTable)} ("sessionId", "createdAt" DESC)`,
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_memory_user_created" ON ${sqlite_1.sql.identifier(memoryTable)} ("userId", "createdAt" DESC)`,
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_memory_agent_created" ON ${sqlite_1.sql.identifier(memoryTable)} ("agentId", "createdAt" DESC)`,
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_memory_scope" ON ${sqlite_1.sql.identifier(memoryTable)} (json_extract("metadata", '$.scope'))`,
+            // Compact table indexes
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_compact_session_created" ON ${sqlite_1.sql.identifier(compactTable)} ("sessionId", "createdAt" DESC)`,
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_compact_user_created" ON ${sqlite_1.sql.identifier(compactTable)} ("userId", "createdAt" DESC)`,
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_compact_agent_created" ON ${sqlite_1.sql.identifier(compactTable)} ("agentId", "createdAt" DESC)`,
+            (0, sqlite_1.sql) `CREATE INDEX IF NOT EXISTS "idx_compact_scope" ON ${sqlite_1.sql.identifier(compactTable)} (json_extract("metadata", '$.scope'))`,
+        ];
+    },
+};

package/lib/cjs/storage/models/compact.d.ts

@@ -0,0 +1,183 @@
+import type { AFSModule } from "@aigne/afs";
+export declare const compactTableName: (module: AFSModule) => string;
+export declare const compactTable: (module: AFSModule) => import("@aigne/sqlite").SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        id: import("@aigne/sqlite").SQLiteColumn<{
+            name: "id";
+            tableName: string;
+            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("@aigne/sqlite").SQLiteColumn<{
+            name: "createdAt";
+            tableName: string;
+            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("@aigne/sqlite").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: string;
+            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";
+        }>;
+        path: import("@aigne/sqlite").SQLiteColumn<{
+            name: "path";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "userId";
+            tableName: string;
+            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;
+        }>;
+        sessionId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "sessionId";
+            tableName: string;
+            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;
+        }>;
+        agentId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "agentId";
+            tableName: string;
+            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;
+        }>;
+        metadata: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: {
+                scope?: string;
+                latestEntryId?: string;
+            } & Record<string, unknown>;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        content: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

package/lib/cjs/storage/models/compact.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactTable = exports.compactTableName = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const uuid_1 = require("@aigne/uuid");
+const compactTableName = (module) => `Entries_${module.name}_compact`;
+exports.compactTableName = compactTableName;
+const compactTable = (module) => (0, sqlite_1.sqliteTable)((0, exports.compactTableName)(module), {
+    id: (0, sqlite_1.text)("id")
+        .notNull()
+        .primaryKey()
+        .$defaultFn(() => (0, uuid_1.v7)()),
+    createdAt: (0, sqlite_1.datetime)("createdAt")
+        .notNull()
+        .$defaultFn(() => new Date()),
+    updatedAt: (0, sqlite_1.datetime)("updatedAt")
+        .notNull()
+        .$defaultFn(() => new Date())
+        .$onUpdateFn(() => new Date()),
+    path: (0, sqlite_1.text)("path").notNull(),
+    userId: (0, sqlite_1.text)("userId"),
+    sessionId: (0, sqlite_1.text)("sessionId"),
+    agentId: (0, sqlite_1.text)("agentId"),
+    metadata: (0, sqlite_1.json)("metadata"),
+    content: (0, sqlite_1.json)("content"),
+});
+exports.compactTable = compactTable;

package/lib/cjs/storage/models/entries.d.ts

@@ -80,6 +80,25 @@ export declare const entriesTable: (module: AFSModule) => import("@aigne/sqlite"
         }, {}, {
             length: number | undefined;
         }>;
+        agentId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "agentId";
+            tableName: string;
+            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;
+        }>;
         userId: import("@aigne/sqlite").SQLiteColumn<{
             name: "userId";
             tableName: string;

package/lib/cjs/storage/models/entries.js

@@ -18,6 +18,7 @@ const entriesTable = (module) => (0, sqlite_1.sqliteTable)((0, exports.entriesTa
         .$defaultFn(() => new Date())
         .$onUpdateFn(() => new Date()),
     path: (0, sqlite_1.text)("path").notNull(),
+    agentId: (0, sqlite_1.text)("agentId"),
     userId: (0, sqlite_1.text)("userId"),
     sessionId: (0, sqlite_1.text)("sessionId"),
     summary: (0, sqlite_1.text)("summary"),

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

@@ -0,0 +1,182 @@
+import type { AFSModule } from "@aigne/afs";
+export declare const memoryTableName: (module: AFSModule) => string;
+export declare const memoryTable: (module: AFSModule) => import("@aigne/sqlite").SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        id: import("@aigne/sqlite").SQLiteColumn<{
+            name: "id";
+            tableName: string;
+            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("@aigne/sqlite").SQLiteColumn<{
+            name: "createdAt";
+            tableName: string;
+            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("@aigne/sqlite").SQLiteColumn<{
+            name: "updatedAt";
+            tableName: string;
+            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";
+        }>;
+        path: import("@aigne/sqlite").SQLiteColumn<{
+            name: "path";
+            tableName: string;
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "userId";
+            tableName: string;
+            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;
+        }>;
+        sessionId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "sessionId";
+            tableName: string;
+            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;
+        }>;
+        agentId: import("@aigne/sqlite").SQLiteColumn<{
+            name: "agentId";
+            tableName: string;
+            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;
+        }>;
+        metadata: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: {
+                scope?: string;
+            } & Record<string, unknown>;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+        content: import("@aigne/sqlite").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
+        }>;
+    };
+    dialect: "sqlite";
+}>;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryTable = exports.memoryTableName = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const uuid_1 = require("@aigne/uuid");
+const memoryTableName = (module) => `Entries_${module.name}_memory`;
+exports.memoryTableName = memoryTableName;
+const memoryTable = (module) => (0, sqlite_1.sqliteTable)((0, exports.memoryTableName)(module), {
+    id: (0, sqlite_1.text)("id")
+        .notNull()
+        .primaryKey()
+        .$defaultFn(() => (0, uuid_1.v7)()),
+    createdAt: (0, sqlite_1.datetime)("createdAt")
+        .notNull()
+        .$defaultFn(() => new Date()),
+    updatedAt: (0, sqlite_1.datetime)("updatedAt")
+        .notNull()
+        .$defaultFn(() => new Date())
+        .$onUpdateFn(() => new Date()),
+    path: (0, sqlite_1.text)("path").notNull(),
+    userId: (0, sqlite_1.text)("userId"),
+    sessionId: (0, sqlite_1.text)("sessionId"),
+    agentId: (0, sqlite_1.text)("agentId"),
+    metadata: (0, sqlite_1.json)("metadata"),
+    content: (0, sqlite_1.json)("content"),
+});
+exports.memoryTable = memoryTable;

package/lib/cjs/storage/type.d.ts

@@ -1,21 +1,49 @@
 import type { AFSEntry, AFSModule } from "@aigne/afs";
 import type { SQL } from "@aigne/sqlite";
-export interface AFSStorageCreatePayload extends Omit<AFSEntry, "id"> {
+export interface AFSStorageCreatePayload extends AFSEntry {
 }
-export interface AFSStorageListOptions {
+export interface AFSStorageTypeOptions {
+    type?: EntryType;
+    scope?: Scope;
+}
+export interface AFSStorageListOptions extends AFSStorageTypeOptions {
     filter?: {
+        agentId?: string;
         userId?: string;
         sessionId?: string;
+        before?: Date | string;
+        after?: Date | string;
     };
     limit?: number;
     orderBy?: [string, "asc" | "desc"][];
 }
+export interface AFSStorageReadOptions extends AFSStorageTypeOptions {
+    filter?: {
+        agentId?: string;
+        userId?: string;
+        sessionId?: string;
+    };
+}
+export interface AFSStorageDeleteOptions extends AFSStorageTypeOptions {
+    filter?: {
+        agentId?: string;
+        userId?: string;
+        sessionId?: string;
+    };
+}
+export type EntryType = "history" | "compact" | "memory";
+export type Scope = "session" | "user" | "agent";
+export interface AFSStorageCreateOptions extends AFSStorageTypeOptions {
+}
 export interface AFSStorage {
-    create(entry: AFSStorageCreatePayload): Promise<AFSEntry>;
+    create(entry: AFSStorageCreatePayload, options?: AFSStorageCreateOptions): Promise<AFSEntry>;
     list(options?: AFSStorageListOptions): Promise<{
-        list: AFSEntry[];
+        data: AFSEntry[];
+    }>;
+    read(id: string, options?: AFSStorageReadOptions): Promise<AFSEntry | undefined>;
+    delete(id: string, options?: AFSStorageDeleteOptions): Promise<{
+        deletedCount: number;
     }>;
-    read(path: string): Promise<AFSEntry | undefined>;
 }
 export type AFSStorageMigrations = {
     hash: string;