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

package/CHANGELOG.md

@@ -6,6 +6,141 @@
   * dependencies
     * @aigne/afs bumped to 1.2.0
 
+## [1.2.0-beta.10](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta.9...afs-history-v1.2.0-beta.10) (2026-01-14)
+
+
+### Features
+
+* **afs:** add module access control and schema validation support ([#904](https://github.com/AIGNE-io/aigne-framework/issues/904)) ([d0b279a](https://github.com/AIGNE-io/aigne-framework/commit/d0b279aac07ebe2bcc1fd4148498fc3f6bbcd561))
+
+
+### Bug Fixes
+
+* improve test coverage tracking and reporting ([#903](https://github.com/AIGNE-io/aigne-framework/issues/903)) ([031144e](https://github.com/AIGNE-io/aigne-framework/commit/031144e74f29e882cffe52ffda8f7a18c76ace7f))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.9
+    * @aigne/sqlite bumped to 0.4.9-beta.2
+
+## [1.2.0-beta.9](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta.8...afs-history-v1.2.0-beta.9) (2026-01-12)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.8
+
+## [1.2.0-beta.8](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta.7...afs-history-v1.2.0-beta.8) (2026-01-08)
+
+
+### Bug Fixes
+
+* bump version ([696560f](https://github.com/AIGNE-io/aigne-framework/commit/696560fa2673eddcb4d00ac0523fbbbde7273cb3))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.7
+    * @aigne/sqlite bumped to 0.4.9-beta.1
+
+## [1.2.0-beta.7](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta.6...afs-history-v1.2.0-beta.7) (2026-01-06)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.6
+
+## [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)
+
+
+### Features
+
+* add session compact support for AIAgent ([#863](https://github.com/AIGNE-io/aigne-framework/issues/863)) ([9010918](https://github.com/AIGNE-io/aigne-framework/commit/9010918cd3f18b02b5c60ddc9ed5c34b568d0b28))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.5
+
+## [1.2.0-beta.4](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta.3...afs-history-v1.2.0-beta.4) (2025-12-26)
+
+
+### Features
+
+* **core:** add session history support ([#858](https://github.com/AIGNE-io/aigne-framework/issues/858)) ([28a070e](https://github.com/AIGNE-io/aigne-framework/commit/28a070ed33b821d1fd344b899706d817ca992b9f))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.4
+
+## [1.2.0-beta.3](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta.2...afs-history-v1.2.0-beta.3) (2025-12-24)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.3
+
+## [1.2.0-beta.2](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta.1...afs-history-v1.2.0-beta.2) (2025-12-19)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.2
+
+## [1.2.0-beta.1](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.2.0-beta...afs-history-v1.2.0-beta.1) (2025-12-17)
+
+
+### Bug Fixes
+
+* bump version ([70d217c](https://github.com/AIGNE-io/aigne-framework/commit/70d217c8360dd0dda7f5f17011c4e92ec836e801))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.1
+    * @aigne/sqlite bumped to 0.4.9-beta
+
+## [1.2.0-beta](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.1.3...afs-history-v1.2.0-beta) (2025-12-17)
+
+
+### Features
+
+* **afs:** support expand context into prompt template by call `$afs.xxx` ([#830](https://github.com/AIGNE-io/aigne-framework/issues/830)) ([5616acd](https://github.com/AIGNE-io/aigne-framework/commit/5616acd6ea257c91aa0b766608f45c5ce17f0345))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta
+
 ## [1.1.3](https://github.com/AIGNE-io/aigne-framework/compare/afs-history-v1.1.3-beta.3...afs-history-v1.1.3) (2025-12-12)
 
 

package/lib/cjs/index.d.ts

@@ -1,23 +1,48 @@
-import type { AFSEntry, AFSListOptions, AFSModule, AFSRoot, AFSWriteEntryPayload } from "@aigne/afs";
+import { type AFSAccessMode, type AFSDeleteOptions, type AFSDeleteResult, type AFSListOptions, type AFSListResult, type AFSModule, type AFSModuleLoadParams, type AFSReadOptions, type AFSReadResult, type AFSRoot, type AFSWriteEntryPayload, type AFSWriteOptions, type AFSWriteResult } from "@aigne/afs";
+import { z } from "zod";
 import { SharedAFSStorage, type SharedAFSStorageOptions } from "./storage/index.js";
 export * from "./storage/index.js";
 export interface AFSHistoryOptions {
     storage?: SharedAFSStorage | SharedAFSStorageOptions;
+    /**
+     * Access mode for this module.
+     * @default "readwrite"
+     */
+    accessMode?: AFSAccessMode;
 }
 export declare class AFSHistory implements AFSModule {
+    static schema(): z.ZodObject<{
+        storage: z.ZodOptional<z.ZodObject<{
+            url: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            url?: string | undefined;
+        }, {
+            url?: string | undefined;
+        }>>;
+        accessMode: z.ZodOptional<z.ZodEnum<["readonly", "readwrite"]>>;
+    }, "strip", z.ZodTypeAny, {
+        storage?: {
+            url?: string | undefined;
+        } | undefined;
+        accessMode?: "readonly" | "readwrite" | undefined;
+    }, {
+        storage?: {
+            url?: string | undefined;
+        } | undefined;
+        accessMode?: "readonly" | "readwrite" | undefined;
+    }>;
+    static load({ parsed }: AFSModuleLoadParams): Promise<AFSHistory>;
     constructor(options?: AFSHistoryOptions);
-    private storage;
     readonly name: string;
+    readonly accessMode: AFSAccessMode;
+    private storage;
+    private afs?;
+    private router;
+    private rootEntries;
     onMount(afs: AFSRoot): void;
-    list(path: string, options?: AFSListOptions): Promise<{
-        list: AFSEntry[];
-    }>;
-    read(path: string): Promise<{
-        result: AFSEntry | undefined;
-        message?: string;
-    }>;
-    write(path: string, content: AFSWriteEntryPayload): Promise<{
-        result: AFSEntry;
-        message?: string;
-    }>;
+    list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+    read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+    write(path: string, content: AFSWriteEntryPayload, options: AFSWriteOptions): Promise<AFSWriteResult>;
+    delete(path: string, _options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+    private normalizePath;
 }

package/lib/cjs/index.js

@@ -15,46 +15,267 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AFSHistory = void 0;
+const afs_1 = require("@aigne/afs");
 const uuid_1 = require("@aigne/uuid");
+const radix3_1 = require("radix3");
 const ufo_1 = require("ufo");
+const zod_1 = require("zod");
 const index_js_1 = require("./storage/index.js");
 __exportStar(require("./storage/index.js"), exports);
+const sharedAFSStorageOptionsSchema = zod_1.z.object({
+    url: zod_1.z.string().describe("Database URL for storage").optional(),
+});
+const afsHistoryOptionsSchema = preprocessSchema((v) => {
+    if (!v || typeof v !== "object") {
+        return v;
+    }
+    return { ...v, accessMode: v.accessMode || v.access_mode };
+}, zod_1.z.object({
+    storage: sharedAFSStorageOptionsSchema.optional(),
+    accessMode: afs_1.accessModeSchema,
+}));
 class AFSHistory {
+    static schema() {
+        return afsHistoryOptionsSchema;
+    }
+    static async load({ parsed }) {
+        const valid = await AFSHistory.schema().parseAsync(parsed);
+        return new AFSHistory(valid);
+    }
     constructor(options) {
         this.storage =
             options?.storage instanceof index_js_1.SharedAFSStorage
                 ? options.storage.withModule(this)
                 : new index_js_1.SharedAFSStorage(options?.storage).withModule(this);
+        this.accessMode = options?.accessMode ?? "readwrite";
     }
-    storage;
     name = "history";
+    accessMode;
+    storage;
+    afs;
+    router = (0, radix3_1.createRouter)({
+        routes: {
+            "/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": {
+                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-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: "by-session",
+            path: "/by-session",
+            description: "Retrieve history entries by session ID.",
+        },
+        {
+            id: "by-user",
+            path: "/by-user",
+            description: "Retrieve history entries by user ID.",
+        },
+        {
+            id: "by-agent",
+            path: "/by-agent",
+            description: "Retrieve history entries by agent ID.",
+        },
+    ];
     onMount(afs) {
-        afs.on("agentSucceed", ({ input, output }) => {
-            this.storage
-                .create({
-                path: (0, ufo_1.joinURL)("/", (0, uuid_1.v7)()),
-                content: { input, output },
-            })
-                .then((entry) => {
-                afs.emit("historyCreated", { entry });
-            })
-                .catch((error) => {
-                console.error("Failed to store history entry", error);
-            });
-        });
+        this.afs = afs;
     }
     async list(path, options) {
-        if (path !== "/")
-            return { list: [] };
-        return await this.storage.list(options);
+        if (path === "/")
+            return { data: this.rootEntries };
+        const match = this.router.lookup(path);
+        if (!match || match.action !== "list") {
+            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) {
+        const match = this.router.lookup(path);
+        if (!match || match.action !== "read")
+            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 read(path) {
-        const result = await this.storage.read(path);
-        return { result };
+    async write(path, content, options) {
+        const id = (0, uuid_1.v7)();
+        const match = this.router.lookup(path);
+        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");
+        }
+        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.`);
+        }
+        const entry = await this.storage.create({
+            ...match.params,
+            ...content,
+            id,
+            path: (0, ufo_1.joinURL)("/", type, id),
+        }, { type, scope });
+        // Emit event for history entries
+        if (type === "history") {
+            this.afs?.emit("historyCreated", { entry }, options);
+        }
+        return {
+            data: {
+                ...entry,
+                path: this.normalizePath(entry, scope, type),
+            },
+        };
     }
-    async write(path, content) {
-        const result = await this.storage.create({ ...content, path });
-        return { result };
+    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`,
+        };
+    }
+    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);
     }
 }
 exports.AFSHistory = AFSHistory;
+const _typeCheck = AFSHistory;
+function preprocessSchema(fn, schema) {
+    return zod_1.z.preprocess(fn, schema);
+}

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

@@ -1,7 +1,6 @@
 import type { AFSEntry, AFSModule } from "@aigne/afs";
 import { initDatabase } from "@aigne/sqlite";
-import { entriesTable } from "./models/entries.js";
-import type { AFSStorage, AFSStorageCreatePayload, AFSStorageListOptions } from "./type.js";
+import type { AFSStorage, AFSStorageCreateOptions, AFSStorageCreatePayload, AFSStorageDeleteOptions, AFSStorageListOptions, AFSStorageReadOptions } from "./type.js";
 export * from "./type.js";
 export interface SharedAFSStorageOptions {
     url?: string;
@@ -15,11 +14,16 @@ export declare class SharedAFSStorage {
 }
 export declare class AFSStorageWithModule implements AFSStorage {
     private db;
-    private table;
-    constructor(db: ReturnType<typeof initDatabase>, table: Promise<ReturnType<typeof entriesTable>>);
+    private module;
+    constructor(db: ReturnType<typeof initDatabase>, module: AFSModule);
+    private _tables?;
+    private get tables();
     list(options?: AFSStorageListOptions): Promise<{
-        list: AFSEntry[];
+        data: AFSEntry[];
+    }>;
+    read(id: string, options?: AFSStorageReadOptions): Promise<AFSEntry | undefined>;
+    create(entry: AFSStorageCreatePayload, options?: AFSStorageCreateOptions): Promise<AFSEntry>;
+    delete(id: string, options?: AFSStorageDeleteOptions): Promise<{
+        deletedCount: number;
     }>;
-    read(path: string): Promise<AFSEntry | undefined>;
-    create(entry: AFSStorageCreatePayload): Promise<AFSEntry>;
 }

package/lib/cjs/storage/index.js

@@ -17,7 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AFSStorageWithModule = exports.SharedAFSStorage = void 0;
 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 {
@@ -31,57 +33,101 @@ class SharedAFSStorage {
         return this._db;
     }
     withModule(module) {
-        return new AFSStorageWithModule(this.db, (0, migrate_js_1.migrate)(this.db, module).then(() => (0, entries_js_1.entriesTable)(module)));
+        return new AFSStorageWithModule(this.db, module);
     }
 }
 exports.SharedAFSStorage = SharedAFSStorage;
 class AFSStorageWithModule {
     db;
-    table;
-    constructor(db, table) {
+    module;
+    constructor(db, module) {
         this.db = db;
-        this.table = table;
+        this.module = module;
+    }
+    _tables;
+    get tables() {
+        if (!this._tables) {
+            this._tables = this.db.then((db) => (0, migrate_js_1.migrate)(db, this.module).then(() => ({
+                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 = await this.db;
-        const table = await this.table;
-        const list = await db
+        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(table)
-            .where((0, sqlite_1.and)(filter?.userId ? (0, sqlite_1.eq)(table.userId, filter.userId) : undefined, filter?.sessionId ? (0, sqlite_1.eq)(table.sessionId, filter.sessionId) : undefined))
-            .orderBy(...(options.orderBy ?? []).map((item) => (item[1] === "asc" ? sqlite_1.asc : sqlite_1.desc)(sqlite_1.sql.identifier(item[0]))))
+            .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 { list };
+        return { data };
     }
-    async read(path) {
-        const db = await this.db;
-        const table = await this.table;
+    async read(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;
         return db
             .select()
             .from(table)
-            .where((0, sqlite_1.eq)(table.path, path))
+            .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 = await this.db;
-        const table = await this.table;
+    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(table)
-            .set(entry)
-            .where((0, sqlite_1.eq)(table.path, entry.path))
+            .set(entryData)
+            .where((0, sqlite_1.eq)(table.id, entry.id))
             .returning()
             .execute();
         if (!result.length) {
-            result = await db.insert(table).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 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
+            .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();
+        return { deletedCount: result.length };
+    }
 }
 exports.AFSStorageWithModule = AFSStorageWithModule;

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

@@ -1,3 +1,3 @@
 import type { AFSModule } from "@aigne/afs";
 import { type initDatabase } from "@aigne/sqlite";
-export declare function migrate(db: ReturnType<typeof initDatabase>, module: AFSModule): Promise<void>;
+export declare function migrate(db: Awaited<ReturnType<typeof initDatabase>>, module: AFSModule): Promise<void>;