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

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

@@ -1,22 +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<{
         data: AFSEntry[];
     }>;
-    read(path: string): Promise<AFSEntry | undefined>;
+    read(id: string, options?: AFSStorageReadOptions): Promise<AFSEntry | undefined>;
+    delete(id: string, options?: AFSStorageDeleteOptions): Promise<{
+        deletedCount: number;
+    }>;
 }
 export type AFSStorageMigrations = {
     hash: string;

package/lib/esm/index.d.ts

@@ -1,4 +1,4 @@
-import type { AFSListOptions, AFSListResult, AFSModule, AFSReadResult, AFSRoot } 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 {
@@ -6,9 +6,15 @@ export interface AFSHistoryOptions {
 }
 export declare class AFSHistory implements AFSModule {
     constructor(options?: AFSHistoryOptions);
-    private storage;
     readonly name: string;
+    private storage;
+    private afs?;
+    private router;
+    private rootEntries;
     onMount(afs: AFSRoot): void;
     list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
-    read(path: string): Promise<AFSReadResult>;
+    read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+    write(path: string, content: AFSWriteEntryPayload): Promise<AFSWriteResult>;
+    delete(path: string, _options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+    private normalizePath;
 }

package/lib/esm/index.js

@@ -1,4 +1,5 @@
 import { v7 } from "@aigne/uuid";
+import { createRouter } from "radix3";
 import { joinURL } from "ufo";
 import { SharedAFSStorage, } from "./storage/index.js";
 export * from "./storage/index.js";
@@ -9,33 +10,227 @@ export class AFSHistory {
                 ? options.storage.withModule(this)
                 : new SharedAFSStorage(options?.storage).withModule(this);
     }
-    storage;
     name = "history";
+    storage;
+    afs;
+    router = 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", ({ agentId, userId, sessionId, input, output, messages }) => {
-            this.storage
-                .create({
-                path: joinURL("/", v7()),
-                agentId,
-                userId,
-                sessionId,
-                content: { input, output, messages },
-            })
-                .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 !== "/")
+        if (path === "/")
+            return { data: this.rootEntries };
+        const match = this.router.lookup(path);
+        if (!match || match.action !== "list") {
             return { data: [] };
-        return await this.storage.list(options);
+        }
+        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 write(path, content) {
+        const id = 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: 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, scope, type),
+            },
+        };
+    }
+    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`,
+        };
     }
-    async read(path) {
-        const data = await this.storage.read(path);
-        return { data };
+    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 joinURL("/", prefix, scopeId, "@metadata/compact", entry.id);
+        }
+        if (entryType === "memory") {
+            return joinURL("/", prefix, scopeId, "@metadata/memory", entry.id);
+        }
+        // Default: history entry
+        return joinURL("/", prefix, scopeId, entry.id);
     }
 }