@aigne/afs-history 1.2.0-beta.5 → 1.2.0-beta.6

package/CHANGELOG.md

@@ -6,6 +6,13 @@
   * dependencies
     * @aigne/afs bumped to 1.2.0
 
+## [1.2.0-beta.6](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta.5...afs-history-v1.2.0-beta.6) (2026-01-06)
+
+
+### Features
+
+* **core:** add cross session user memory support ([#873](https://github.com/AIGNE-io/aigne-framework/issues/873)) ([f377aa1](https://github.com/AIGNE-io/aigne-framework/commit/f377aa17f2cf8004fd3225ade4a37fd90af1292f))
+
 ## [1.2.0-beta.5](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta.4...afs-history-v1.2.0-beta.5) (2025-12-31)
 
 

package/lib/cjs/index.d.ts

@@ -1,4 +1,4 @@
-import type { AFSListOptions, AFSListResult, AFSModule, AFSReadOptions, AFSReadResult, AFSRoot, AFSWriteEntryPayload, AFSWriteResult } from "@aigne/afs";
+import type { AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSModule, AFSReadOptions, AFSReadResult, AFSRoot, AFSWriteEntryPayload, AFSWriteResult } from "@aigne/afs";
 import { SharedAFSStorage, type SharedAFSStorageOptions } from "./storage/index.js";
 export * from "./storage/index.js";
 export interface AFSHistoryOptions {
@@ -15,6 +15,6 @@ export declare class AFSHistory implements AFSModule {
     list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
     read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
     write(path: string, content: AFSWriteEntryPayload): Promise<AFSWriteResult>;
-    private getCompactType;
+    delete(path: string, _options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
     private normalizePath;
 }

package/lib/cjs/index.js

@@ -32,36 +32,80 @@ class AFSHistory {
     afs;
     router = (0, radix3_1.createRouter)({
         routes: {
-            "/new": { type: "root", id: "new-history" },
-            "/by-session": { type: "root", id: "by-session" },
-            "/by-session/:sessionId": { type: "list", id: "by-session" },
-            "/by-session/:sessionId/@metadata/compact": { type: "compact-list", id: "by-session" },
-            "/by-session/:sessionId/@metadata/compact/new": { type: "compact-new", id: "by-session" },
+            "/by-session": { action: "list", type: "history", scope: "session" },
+            "/by-session/:sessionId": { action: "list", type: "history", scope: "session" },
+            "/by-session/:sessionId/new": { action: "create", type: "history", scope: "session" },
+            "/by-session/:sessionId/@metadata/compact": {
+                action: "list",
+                type: "compact",
+                scope: "session",
+            },
+            "/by-session/:sessionId/@metadata/compact/new": {
+                action: "create",
+                type: "compact",
+                scope: "session",
+            },
             "/by-session/:sessionId/@metadata/compact/:compactId": {
-                type: "compact-detail",
-                id: "by-session",
+                action: "read",
+                type: "compact",
+                scope: "session",
+            },
+            "/by-session/:sessionId/@metadata/memory": {
+                action: "list",
+                type: "memory",
+                scope: "session",
+            },
+            "/by-session/:sessionId/@metadata/memory/new": {
+                action: "create",
+                type: "memory",
+                scope: "session",
+            },
+            "/by-session/:sessionId/@metadata/memory/:memoryId": {
+                action: "read",
+                type: "memory",
+                scope: "session",
+            },
+            "/by-session/:sessionId/:entryId": { action: "read", type: "history", scope: "session" },
+            "/by-user": { action: "list", type: "history", scope: "user" },
+            "/by-user/:userId": { action: "list", type: "history", scope: "user" },
+            "/by-user/:userId/new": { action: "create", type: "history", scope: "user" },
+            "/by-user/:userId/@metadata/compact": { action: "list", type: "compact", scope: "user" },
+            "/by-user/:userId/@metadata/compact/new": {
+                action: "create",
+                type: "compact",
+                scope: "user",
+            },
+            "/by-user/:userId/@metadata/compact/:compactId": {
+                action: "read",
+                type: "compact",
+                scope: "user",
             },
-            "/by-session/:sessionId/:entryId": { type: "detail", id: "by-session" },
-            "/by-user": { type: "root", id: "by-user" },
-            "/by-user/:userId": { type: "list", id: "by-user" },
-            "/by-user/:userId/@metadata/compact": { type: "compact-list", id: "by-user" },
-            "/by-user/:userId/@metadata/compact/new": { type: "compact-new", id: "by-user" },
-            "/by-user/:userId/@metadata/compact/:compactId": { type: "compact-detail", id: "by-user" },
-            "/by-user/:userId/:entryId": { type: "detail", id: "by-user" },
-            "/by-agent": { type: "root", id: "by-agent" },
-            "/by-agent/:agentId": { type: "list", id: "by-agent" },
-            "/by-agent/:agentId/@metadata/compact": { type: "compact-list", id: "by-agent" },
-            "/by-agent/:agentId/@metadata/compact/new": { type: "compact-new", id: "by-agent" },
-            "/by-agent/:agentId/@metadata/compact/:compactId": { type: "compact-detail", id: "by-agent" },
-            "/by-agent/:agentId/:entryId": { type: "detail", id: "by-agent" },
+            "/by-user/:userId/@metadata/memory": { action: "list", type: "memory", scope: "user" },
+            "/by-user/:userId/@metadata/memory/new": { action: "create", type: "memory", scope: "user" },
+            "/by-user/:userId/@metadata/memory/:memoryId": {
+                action: "read",
+                type: "memory",
+                scope: "user",
+            },
+            "/by-user/:userId/:entryId": { action: "read", type: "history", scope: "user" },
+            "/by-agent": { action: "list", type: "history", scope: "agent" },
+            "/by-agent/:agentId": { action: "list", type: "history", scope: "agent" },
+            "/by-agent/:agentId/new": { action: "create", type: "history", scope: "agent" },
+            "/by-agent/:agentId/@metadata/compact": { action: "list", type: "compact", scope: "agent" },
+            "/by-agent/:agentId/@metadata/compact/new": {
+                action: "create",
+                type: "compact",
+                scope: "agent",
+            },
+            "/by-agent/:agentId/@metadata/compact/:compactId": {
+                action: "read",
+                type: "compact",
+                scope: "agent",
+            },
+            "/by-agent/:agentId/:entryId": { action: "read", type: "history", scope: "agent" },
         },
     });
     rootEntries = [
-        {
-            id: "new-history",
-            path: "/new",
-            description: "Write to this path to create a new history entry, generating a UUID-based path.",
-        },
         {
             id: "by-session",
             path: "/by-session",
@@ -84,148 +128,126 @@ class AFSHistory {
     async list(path, options) {
         if (path === "/")
             return { data: this.rootEntries };
-        // Parse virtual path and extract filter conditions
         const match = this.router.lookup(path);
-        // If path doesn't match any virtual path pattern, return empty
-        if (!match) {
+        if (!match || match.action !== "list") {
             return { data: [] };
         }
-        const rootEntry = this.rootEntries.find((entry) => entry.path === `/${match.id}`);
-        if (!rootEntry)
-            return { data: [] };
-        if (match.type === "root") {
-            return { data: [rootEntry] };
-        }
-        const matchId = match.id;
-        if (match.type === "list" &&
-            (matchId === "by-session" || matchId === "by-user" || matchId === "by-agent")) {
-            // Merge virtual path filter with explicit filter options
-            const mergedFilter = {
-                ...options?.filter,
-                ...match.params,
-            };
-            const result = await this.storage.list({
-                ...options,
-                filter: mergedFilter,
-            });
-            // Add virtual path prefix to each entry's path
-            return {
-                ...result,
-                data: result.data.map((entry) => ({
-                    ...entry,
-                    path: this.normalizePath(entry, matchId),
-                })),
-            };
-        }
-        if (match.type === "compact-list" &&
-            (matchId === "by-session" || matchId === "by-user" || matchId === "by-agent")) {
-            const compactType = this.getCompactType(matchId);
-            const mergedFilter = {
-                ...options?.filter,
-                ...match.params,
-            };
-            const result = await this.storage.listCompact(compactType, {
-                ...options,
-                filter: mergedFilter,
-            });
-            return { data: result.data };
-        }
-        return { data: [] };
+        const { type, scope } = match;
+        const mergedFilter = {
+            ...options?.filter,
+            ...match.params,
+        };
+        const result = await this.storage.list({
+            ...options,
+            type,
+            scope,
+            filter: mergedFilter,
+        });
+        return {
+            ...result,
+            data: result.data.map((entry) => ({
+                ...entry,
+                path: this.normalizePath(entry, scope, type),
+            })),
+        };
     }
     async read(path, options) {
-        // Parse virtual path and extract filter conditions
         const match = this.router.lookup(path);
-        if (!match)
+        if (!match || match.action !== "read")
             return {};
-        const rootEntry = this.rootEntries.find((entry) => entry.path === `/${match.id}`);
-        if (!rootEntry)
-            return {};
-        if (match.type === "root") {
-            return { data: rootEntry };
-        }
-        if (match.type === "detail" &&
-            (match.id === "by-session" || match.id === "by-user" || match.id === "by-agent")) {
-            const entryId = match.params?.entryId;
-            if (!entryId)
-                throw new Error("Entry ID is required in the path to read detail.");
-            const data = await this.storage.read(entryId, {
-                filter: match.params,
-            });
-            return {
-                data: data && {
-                    ...data,
-                    path: this.normalizePath(data, match.id),
-                },
-            };
-        }
-        if (match.type === "compact-detail" &&
-            (match.id === "by-session" || match.id === "by-user" || match.id === "by-agent")) {
-            const compactId = match.params?.compactId;
-            if (!compactId)
-                throw new Error("Compact ID is required in the path to read compact detail.");
-            const compactType = this.getCompactType(match.id);
-            const mergedFilter = {
-                ...options?.filter,
-                ...match.params,
-            };
-            const data = await this.storage.readCompact(compactType, compactId, {
-                filter: mergedFilter,
-            });
-            return { data };
-        }
-        return {};
+        const { type, scope } = match;
+        const entryId = match.params?.entryId ?? match.params?.compactId ?? match.params?.memoryId;
+        if (!entryId)
+            throw new Error(`Entry ID is required in the path to read ${type}.`);
+        const mergedFilter = {
+            ...options?.filter,
+            ...match.params,
+        };
+        const data = await this.storage.read(entryId, {
+            type,
+            scope,
+            filter: mergedFilter,
+        });
+        // Add virtual path prefix for entries
+        return {
+            data: data && {
+                ...data,
+                path: this.normalizePath(data, scope, type),
+            },
+        };
     }
     async write(path, content) {
         const id = (0, uuid_1.v7)();
         const match = this.router.lookup(path);
-        if (match?.type === "compact-new") {
-            const compactType = this.getCompactType(match.id);
-            const entry = await this.storage.createCompact(compactType, {
-                ...match.params,
-                ...content,
-                id,
-                path: (0, ufo_1.joinURL)("/", compactType, id),
-            });
-            return { data: entry };
+        if (!match || match.action !== "create") {
+            throw new Error("Can only write to paths with 'new' suffix: /by-{scope}/{scopeId}/new or /by-{scope}/{scopeId}/@metadata/{type}/new");
         }
-        if (match?.id !== "new-history") {
-            throw new Error("Can only write to /new or @metadata/compact/new paths.");
+        const { type, scope } = match;
+        // Validate that scope ID is provided in path params
+        const scopeIdField = `${scope}Id`;
+        const scopeIdValue = match.params?.[scopeIdField];
+        if (!scopeIdValue) {
+            throw new Error(`${scopeIdField} is required in the path to create ${type} entry.`);
         }
-        if (!content.sessionId)
-            throw new Error("sessionId is required to create a history entry.");
         const entry = await this.storage.create({
+            ...match.params,
             ...content,
             id,
-            path: (0, ufo_1.joinURL)("/", id),
-        });
-        this.afs?.emit("historyCreated", { entry });
+            path: (0, ufo_1.joinURL)("/", type, id),
+        }, { type, scope });
+        // Emit event for history entries
+        if (type === "history") {
+            this.afs?.emit("historyCreated", { entry });
+        }
         return {
             data: {
                 ...entry,
-                path: this.normalizePath(entry, "by-session"),
+                path: this.normalizePath(entry, scope, type),
             },
         };
     }
-    getCompactType(id) {
-        const mapping = {
-            "by-session": "session",
-            "by-user": "user",
-            "by-agent": "agent",
+    async delete(path, _options) {
+        const match = this.router.lookup(path);
+        if (!match || match.action !== "read") {
+            throw new Error(`Cannot delete: path not found or not a valid entry path`);
+        }
+        const { type, scope } = match;
+        const entryId = match.params?.entryId ?? match.params?.compactId ?? match.params?.memoryId;
+        if (!entryId)
+            throw new Error(`Entry ID is required in the path to delete ${type}.`);
+        const result = await this.storage.delete(entryId, {
+            type,
+            scope,
+            filter: match.params,
+        });
+        if (result.deletedCount === 0) {
+            return {
+                message: `No ${type} entry found with id ${entryId}`,
+            };
+        }
+        return {
+            message: `Deleted ${result.deletedCount} ${type} entry`,
         };
-        const type = mapping[id];
-        if (!type)
-            throw new Error(`Invalid compact type for id: ${id}`);
-        return type;
     }
-    normalizePath(entry, type) {
-        const [prefix, scopeId] = {
-            "by-session": ["by-session", entry.sessionId],
-            "by-user": ["by-user", entry.userId],
-            "by-agent": ["by-agent", entry.agentId],
-        }[type] || [];
-        if (!prefix || !scopeId) {
-            throw new Error(`Cannot reset path for entry without ${type} info.`);
+    normalizePath(entry, scope, entryType) {
+        const scopeIdMap = {
+            session: entry.sessionId,
+            user: entry.userId,
+            agent: entry.agentId,
+        };
+        const scopeId = scopeIdMap[scope];
+        if (!scopeId) {
+            throw new Error(`Cannot reset path for entry without ${scope} info.`);
+        }
+        const prefix = `by-${scope}`;
+        // Build path based on entry type
+        if (entryType === "compact") {
+            return (0, ufo_1.joinURL)("/", prefix, scopeId, "@metadata/compact", entry.id);
+        }
+        if (entryType === "memory") {
+            return (0, ufo_1.joinURL)("/", prefix, scopeId, "@metadata/memory", entry.id);
         }
+        // Default: history entry
         return (0, ufo_1.joinURL)("/", prefix, scopeId, entry.id);
     }
 }

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

@@ -1,6 +1,6 @@
 import type { AFSEntry, AFSModule } from "@aigne/afs";
 import { initDatabase } from "@aigne/sqlite";
-import type { AFSStorage, AFSStorageCreatePayload, AFSStorageListOptions, AFSStorageReadOptions, CompactType } from "./type.js";
+import type { AFSStorage, AFSStorageCreateOptions, AFSStorageCreatePayload, AFSStorageDeleteOptions, AFSStorageListOptions, AFSStorageReadOptions } from "./type.js";
 export * from "./type.js";
 export interface SharedAFSStorageOptions {
     url?: string;
@@ -22,10 +22,8 @@ export declare class AFSStorageWithModule implements AFSStorage {
         data: AFSEntry[];
     }>;
     read(id: string, options?: AFSStorageReadOptions): Promise<AFSEntry | undefined>;
-    create(entry: AFSStorageCreatePayload): Promise<AFSEntry>;
-    createCompact(type: CompactType, entry: AFSStorageCreatePayload): Promise<AFSEntry>;
-    listCompact(type: CompactType, options?: AFSStorageListOptions): Promise<{
-        data: AFSEntry[];
+    create(entry: AFSStorageCreatePayload, options?: AFSStorageCreateOptions): Promise<AFSEntry>;
+    delete(id: string, options?: AFSStorageDeleteOptions): Promise<{
+        deletedCount: number;
     }>;
-    readCompact(type: CompactType, id: string, options?: AFSStorageReadOptions): Promise<AFSEntry | undefined>;
 }

package/lib/cjs/storage/index.js

@@ -19,6 +19,7 @@ const sqlite_1 = require("@aigne/sqlite");
 const migrate_js_1 = require("./migrate.js");
 const compact_js_1 = require("./models/compact.js");
 const entries_js_1 = require("./models/entries.js");
+const memory_js_1 = require("./models/memory.js");
 __exportStar(require("./type.js"), exports);
 const DEFAULT_AFS_STORAGE_LIST_LIMIT = 10;
 class SharedAFSStorage {
@@ -50,87 +51,83 @@ class AFSStorageWithModule {
                 db,
                 entries: (0, entries_js_1.entriesTable)(this.module),
                 compact: (0, compact_js_1.compactTable)(this.module),
+                memory: (0, memory_js_1.memoryTable)(this.module),
             })));
         }
         return this._tables;
     }
     async list(options = {}) {
-        const { filter, limit = DEFAULT_AFS_STORAGE_LIST_LIMIT } = options;
-        const { db, entries } = await this.tables;
+        const { type = "history", scope, filter, limit = DEFAULT_AFS_STORAGE_LIST_LIMIT } = options;
+        const { db, entries, compact, memory } = await this.tables;
+        // Select table based on type
+        const table = type === "compact" ? compact : type === "memory" ? memory : entries;
         const data = await db
             .select()
-            .from(entries)
-            .where((0, sqlite_1.and)(filter?.agentId ? (0, sqlite_1.eq)(entries.agentId, filter.agentId) : undefined, filter?.userId ? (0, sqlite_1.eq)(entries.userId, filter.userId) : undefined, filter?.sessionId ? (0, sqlite_1.eq)(entries.sessionId, filter.sessionId) : undefined, filter?.before ? (0, sqlite_1.lt)(entries.createdAt, new Date(filter.before)) : undefined, filter?.after ? (0, sqlite_1.gt)(entries.createdAt, new Date(filter.after)) : undefined))
-            .orderBy(...(options.orderBy ?? []).map((item) => (item[1] === "asc" ? sqlite_1.asc : sqlite_1.desc)(sqlite_1.sql.identifier(item[0]))))
+            .from(table)
+            .where((0, sqlite_1.and)(
+        // Add scope filter for compact/memory tables
+        scope && type !== "history"
+            ? (0, sqlite_1.eq)((0, sqlite_1.sql) `json_extract(${table.metadata}, '$.scope')`, scope)
+            : undefined, filter?.agentId ? (0, sqlite_1.eq)(table.agentId, filter.agentId) : undefined, filter?.userId ? (0, sqlite_1.eq)(table.userId, filter.userId) : undefined, filter?.sessionId ? (0, sqlite_1.eq)(table.sessionId, filter.sessionId) : undefined, filter?.before ? (0, sqlite_1.lt)(table.createdAt, new Date(filter.before)) : undefined, filter?.after ? (0, sqlite_1.gt)(table.createdAt, new Date(filter.after)) : undefined))
+            .orderBy(...(options.orderBy ?? [["createdAt", "desc"]]).map((item) => (item[1] === "asc" ? sqlite_1.asc : sqlite_1.desc)(sqlite_1.sql.identifier(item[0]))))
             .limit(limit)
             .execute();
         return { data };
     }
     async read(id, options) {
-        const { db, entries } = await this.tables;
+        const { type = "history", scope, filter } = options ?? {};
+        const { db, entries, compact, memory } = await this.tables;
+        // Select table based on type
+        const table = type === "compact" ? compact : type === "memory" ? memory : entries;
         return db
             .select()
-            .from(entries)
-            .where((0, sqlite_1.and)((0, sqlite_1.eq)(entries.id, id), options?.filter?.agentId ? (0, sqlite_1.eq)(entries.agentId, options.filter.agentId) : undefined, options?.filter?.userId ? (0, sqlite_1.eq)(entries.userId, options.filter.userId) : undefined, options?.filter?.sessionId ? (0, sqlite_1.eq)(entries.sessionId, options.filter.sessionId) : undefined))
+            .from(table)
+            .where((0, sqlite_1.and)((0, sqlite_1.eq)(table.id, id), 
+        // Add scope filter for compact/memory tables
+        scope && type !== "history"
+            ? (0, sqlite_1.eq)((0, sqlite_1.sql) `json_extract(${table.metadata}, '$.scope')`, scope)
+            : undefined, filter?.agentId ? (0, sqlite_1.eq)(table.agentId, filter.agentId) : undefined, filter?.userId ? (0, sqlite_1.eq)(table.userId, filter.userId) : undefined, filter?.sessionId ? (0, sqlite_1.eq)(table.sessionId, filter.sessionId) : undefined))
             .limit(1)
             .execute()
-            .then((memory) => memory.at(0));
+            .then((rows) => rows.at(0));
     }
-    async create(entry) {
-        const { db, entries } = await this.tables;
+    async create(entry, options) {
+        const { type = "history", scope } = options ?? {};
+        const { db, entries, compact, memory } = await this.tables;
+        // Select table based on type
+        const table = type === "compact" ? compact : type === "memory" ? memory : entries;
+        // Prepare entry data - only add scope to metadata for compact/memory types
+        const entryData = { ...entry, metadata: { ...entry.metadata, scope } };
+        // Try update first, then insert if not found (upsert)
         let result = await db
-            .update(entries)
-            .set(entry)
-            .where((0, sqlite_1.eq)(entries.id, entry.id))
+            .update(table)
+            .set(entryData)
+            .where((0, sqlite_1.eq)(table.id, entry.id))
             .returning()
             .execute();
         if (!result.length) {
-            result = await db.insert(entries).values(entry).returning().execute();
+            result = await db.insert(table).values(entryData).returning().execute();
         }
         const [res] = result;
         if (!res)
-            throw new Error("Failed to create AFS entry, no result");
+            throw new Error(`Failed to create ${type} entry, no result`);
         return res;
     }
-    async createCompact(type, entry) {
-        const { db, compact } = await this.tables;
+    async delete(id, options) {
+        const { type = "history", scope, filter } = options ?? {};
+        const { db, entries, compact, memory } = await this.tables;
+        // Select table based on type
+        const table = type === "compact" ? compact : type === "memory" ? memory : entries;
         const result = await db
-            .insert(compact)
-            .values({
-            ...entry,
-            metadata: {
-                ...entry.metadata,
-                type,
-            },
-        })
+            .delete(table)
+            .where((0, sqlite_1.and)((0, sqlite_1.eq)(table.id, id), 
+        // Add scope filter for compact/memory tables
+        scope && type !== "history"
+            ? (0, sqlite_1.eq)((0, sqlite_1.sql) `json_extract(${table.metadata}, '$.scope')`, scope)
+            : undefined, filter?.agentId ? (0, sqlite_1.eq)(table.agentId, filter.agentId) : undefined, filter?.userId ? (0, sqlite_1.eq)(table.userId, filter.userId) : undefined, filter?.sessionId ? (0, sqlite_1.eq)(table.sessionId, filter.sessionId) : undefined))
             .returning()
             .execute();
-        const [res] = result;
-        if (!res)
-            throw new Error(`Failed to create ${type} compact entry, no result`);
-        return res;
-    }
-    async listCompact(type, options = {}) {
-        const { db, compact } = await this.tables;
-        const { filter, limit = DEFAULT_AFS_STORAGE_LIST_LIMIT } = options;
-        const data = await db
-            .select()
-            .from(compact)
-            .where((0, sqlite_1.and)((0, sqlite_1.eq)((0, sqlite_1.sql) `json_extract(${compact.metadata}, '$.type')`, type), filter?.agentId ? (0, sqlite_1.eq)(compact.agentId, filter.agentId) : undefined, filter?.userId ? (0, sqlite_1.eq)(compact.userId, filter.userId) : undefined, filter?.sessionId ? (0, sqlite_1.eq)(compact.sessionId, filter.sessionId) : undefined, filter?.before ? (0, sqlite_1.lt)(compact.createdAt, new Date(filter.before)) : undefined, filter?.after ? (0, sqlite_1.gt)(compact.createdAt, new Date(filter.after)) : undefined))
-            .orderBy(...(options.orderBy ?? []).map((item) => (item[1] === "asc" ? sqlite_1.asc : sqlite_1.desc)(sqlite_1.sql.identifier(item[0]))))
-            .limit(limit)
-            .execute();
-        return { data };
-    }
-    async readCompact(type, id, options) {
-        const { db, compact } = await this.tables;
-        return db
-            .select()
-            .from(compact)
-            .where((0, sqlite_1.and)((0, sqlite_1.eq)((0, sqlite_1.sql) `json_extract(${compact.metadata}, '$.type')`, type), (0, sqlite_1.eq)(compact.id, id), options?.filter?.agentId ? (0, sqlite_1.eq)(compact.agentId, options.filter.agentId) : undefined, options?.filter?.userId ? (0, sqlite_1.eq)(compact.userId, options.filter.userId) : undefined, options?.filter?.sessionId ? (0, sqlite_1.eq)(compact.sessionId, options.filter.sessionId) : undefined))
-            .limit(1)
-            .execute()
-            .then((rows) => rows.at(0));
+        return { deletedCount: result.length };
     }
 }
 exports.AFSStorageWithModule = AFSStorageWithModule;

package/lib/cjs/storage/migrate.js

@@ -6,8 +6,16 @@ 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, _002_add_agent_id_js_1.addAgentId, _003_add_compact_table_js_1.addCompactTable];
+    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)} (

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'))`,
+        ];
+    },
+};