@aigne/afs-history 1.3.0-beta → 1.74.0-beta

package/dist/index.cjs

@@ -0,0 +1,285 @@
+const require_type = require('./storage/type.cjs');
+const require_storage_index = require('./storage/index.cjs');
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_utils_zod = require("@aigne/afs/utils/zod");
+let _aigne_uuid = require("@aigne/uuid");
+let radix3 = require("radix3");
+let ufo = require("ufo");
+let zod = require("zod");
+
+//#region src/index.ts
+const afsStorageOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({ url: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("Database URL for storage")) }));
+const afsHistoryOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
+	storage: (0, _aigne_afs_utils_zod.optionalize)(zod.z.union([zod.z.custom((v) => require_type.isAFSStorage(v)), afsStorageOptionsSchema])),
+	accessMode: _aigne_afs.accessModeSchema
+}));
+var AFSHistory = class AFSHistory {
+	static schema() {
+		return afsHistoryOptionsSchema;
+	}
+	static async load({ parsed }) {
+		return new AFSHistory(await AFSHistory.schema().parseAsync(parsed));
+	}
+	constructor(options) {
+		(0, _aigne_afs_utils_zod.zodParse)((0, _aigne_afs_utils_zod.optionalize)(afsHistoryOptionsSchema), options);
+		this.storage = require_type.isAFSStorage(options?.storage) ? options.storage : new require_storage_index.AFSStorageSQLite(this, options?.storage);
+		this.accessMode = options?.accessMode ?? "readwrite";
+	}
+	name = "history";
+	accessMode;
+	storage;
+	afs;
+	router = (0, radix3.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) {
+		this.afs = afs;
+	}
+	async list(path, 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
+		});
+		return { data: data && {
+			...data,
+			path: this.normalizePath(data, scope, type)
+		} };
+	}
+	async write(path, content, options) {
+		const id = (0, _aigne_uuid.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;
+		const scopeIdField = `${scope}Id`;
+		if (!match.params?.[scopeIdField]) 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.joinURL)("/", type, id)
+		}, {
+			type,
+			scope
+		});
+		if (type === "history") this.afs?.emit("historyCreated", { entry }, options);
+		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` };
+	}
+	normalizePath(entry, scope, entryType) {
+		const scopeId = {
+			session: entry.sessionId,
+			user: entry.userId,
+			agent: entry.agentId
+		}[scope];
+		if (!scopeId) throw new Error(`Cannot reset path for entry without ${scope} info.`);
+		const prefix = `by-${scope}`;
+		if (entryType === "compact") return (0, ufo.joinURL)("/", prefix, scopeId, "@metadata/compact", entry.id);
+		if (entryType === "memory") return (0, ufo.joinURL)("/", prefix, scopeId, "@metadata/memory", entry.id);
+		return (0, ufo.joinURL)("/", prefix, scopeId, entry.id);
+	}
+};
+
+//#endregion
+exports.AFSHistory = AFSHistory;
+exports.AFSStorageSQLite = require_storage_index.AFSStorageSQLite;
+exports.isAFSStorage = require_type.isAFSStorage;

package/dist/index.d.cts

@@ -0,0 +1,48 @@
+import { AFSStorage, AFSStorageCreateOptions, AFSStorageCreatePayload, AFSStorageDeleteOptions, AFSStorageListOptions, AFSStorageMigrations, AFSStorageReadOptions, AFSStorageTypeOptions, EntryType, Scope, isAFSStorage } from "./storage/type.cjs";
+import { AFSStorageSQLite, AFSStorageSQLiteOptions } from "./storage/index.cjs";
+import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSModule, AFSModuleLoadParams, AFSReadOptions, AFSReadResult, AFSRoot, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+import { z } from "zod";
+
+//#region src/index.d.ts
+interface AFSHistoryOptions {
+  storage?: AFSStorage | AFSStorageSQLiteOptions;
+  /**
+       * Access mode for this module.
+       * @default "readwrite"
+       */
+  accessMode?: AFSAccessMode;
+}
+declare class AFSHistory implements AFSModule {
+  static schema(): z.ZodEffects<z.ZodObject<{
+    storage: z.ZodType<any, z.ZodTypeDef, any>;
+    accessMode: z.ZodOptional<z.ZodEnum<["readonly", "readwrite"]>>;
+  }, "strip", z.ZodTypeAny, {
+    storage?: any;
+    accessMode?: "readonly" | "readwrite" | undefined;
+  }, {
+    storage?: any;
+    accessMode?: "readonly" | "readwrite" | undefined;
+  }>, {
+    storage?: any;
+    accessMode?: "readonly" | "readwrite" | undefined;
+  }, any>;
+  static load({
+    parsed
+  }: AFSModuleLoadParams): Promise<AFSHistory>;
+  constructor(options?: AFSHistoryOptions);
+  readonly name: string;
+  readonly accessMode: AFSAccessMode;
+  private storage;
+  private afs?;
+  private router;
+  private rootEntries;
+  onMount(afs: AFSRoot): void;
+  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;
+}
+//#endregion
+export { AFSHistory, AFSHistoryOptions, AFSStorage, AFSStorageCreateOptions, AFSStorageCreatePayload, AFSStorageDeleteOptions, AFSStorageListOptions, AFSStorageMigrations, AFSStorageReadOptions, AFSStorageSQLite, AFSStorageSQLiteOptions, AFSStorageTypeOptions, EntryType, Scope, isAFSStorage };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;UAkCiB,iBAAA;EAAA,OAAA,GACL,UAAA,GAAa,uBAAA;EAAA;;;AAqBzB;EArByB,UAAA,GAKV,aAAA;AAAA;AAAA,cAgBF,UAAA,YAAsB,SAAA;EAAA,OAAA,OAAA,GACpB,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,OAAA;;;;;;;;;;;;;;KAIiB,mBAAA,GAAmB,OAAA,CAAA,UAAA;EAAA,YAAA,OAAA,GAK3B,iBAAA;EAAA,SAAA,IAAA;EAAA,SAAA,UAAA,EAWD,aAAA;EAAA,QAAA,OAAA;EAAA,QAAA,GAAA;EAAA,QAAA,MAAA;EAAA,QAAA,WAAA;EAAA,QAAA,GAAA,EAwGR,OAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GAIsB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GA8BzB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,OAAA,EA+BjD,oBAAA,EAAA,OAAA,EACA,eAAA,GACR,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,QAAA,GA0C2B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,QAAA,aAAA;AAAA"}

package/dist/index.d.mts

@@ -0,0 +1,48 @@
+import { AFSStorage, AFSStorageCreateOptions, AFSStorageCreatePayload, AFSStorageDeleteOptions, AFSStorageListOptions, AFSStorageMigrations, AFSStorageReadOptions, AFSStorageTypeOptions, EntryType, Scope, isAFSStorage } from "./storage/type.mjs";
+import { AFSStorageSQLite, AFSStorageSQLiteOptions } from "./storage/index.mjs";
+import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSListOptions, AFSListResult, AFSModule, AFSModuleLoadParams, AFSReadOptions, AFSReadResult, AFSRoot, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+import { z } from "zod";
+
+//#region src/index.d.ts
+interface AFSHistoryOptions {
+  storage?: AFSStorage | AFSStorageSQLiteOptions;
+  /**
+       * Access mode for this module.
+       * @default "readwrite"
+       */
+  accessMode?: AFSAccessMode;
+}
+declare class AFSHistory implements AFSModule {
+  static schema(): z.ZodEffects<z.ZodObject<{
+    storage: z.ZodType<any, z.ZodTypeDef, any>;
+    accessMode: z.ZodOptional<z.ZodEnum<["readonly", "readwrite"]>>;
+  }, "strip", z.ZodTypeAny, {
+    storage?: any;
+    accessMode?: "readonly" | "readwrite" | undefined;
+  }, {
+    storage?: any;
+    accessMode?: "readonly" | "readwrite" | undefined;
+  }>, {
+    storage?: any;
+    accessMode?: "readonly" | "readwrite" | undefined;
+  }, any>;
+  static load({
+    parsed
+  }: AFSModuleLoadParams): Promise<AFSHistory>;
+  constructor(options?: AFSHistoryOptions);
+  readonly name: string;
+  readonly accessMode: AFSAccessMode;
+  private storage;
+  private afs?;
+  private router;
+  private rootEntries;
+  onMount(afs: AFSRoot): void;
+  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;
+}
+//#endregion
+export { AFSHistory, AFSHistoryOptions, AFSStorage, AFSStorageCreateOptions, AFSStorageCreatePayload, AFSStorageDeleteOptions, AFSStorageListOptions, AFSStorageMigrations, AFSStorageReadOptions, AFSStorageSQLite, AFSStorageSQLiteOptions, AFSStorageTypeOptions, EntryType, Scope, isAFSStorage };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;UAkCiB,iBAAA;EAAA,OAAA,GACL,UAAA,GAAa,uBAAA;EAAA;;;AAqBzB;EArByB,UAAA,GAKV,aAAA;AAAA;AAAA,cAgBF,UAAA,YAAsB,SAAA;EAAA,OAAA,OAAA,GACpB,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;IAAA,OAAA;;;;;;;;;;;;;;KAIiB,mBAAA,GAAmB,OAAA,CAAA,UAAA;EAAA,YAAA,OAAA,GAK3B,iBAAA;EAAA,SAAA,IAAA;EAAA,SAAA,UAAA,EAWD,aAAA;EAAA,QAAA,OAAA;EAAA,QAAA,GAAA;EAAA,QAAA,MAAA;EAAA,QAAA,WAAA;EAAA,QAAA,GAAA,EAwGR,OAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GAIsB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GA8BzB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,OAAA,EA+BjD,oBAAA,EAAA,OAAA,EACA,eAAA,GACR,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,QAAA,GA0C2B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,QAAA,aAAA;AAAA"}

package/dist/index.mjs

@@ -0,0 +1,284 @@
+import { isAFSStorage } from "./storage/type.mjs";
+import { AFSStorageSQLite } from "./storage/index.mjs";
+import { accessModeSchema } from "@aigne/afs";
+import { camelize, optionalize, zodParse } from "@aigne/afs/utils/zod";
+import { v7 } from "@aigne/uuid";
+import { createRouter } from "radix3";
+import { joinURL } from "ufo";
+import { z } from "zod";
+
+//#region src/index.ts
+const afsStorageOptionsSchema = camelize(z.object({ url: optionalize(z.string().describe("Database URL for storage")) }));
+const afsHistoryOptionsSchema = camelize(z.object({
+	storage: optionalize(z.union([z.custom((v) => isAFSStorage(v)), afsStorageOptionsSchema])),
+	accessMode: accessModeSchema
+}));
+var AFSHistory = class AFSHistory {
+	static schema() {
+		return afsHistoryOptionsSchema;
+	}
+	static async load({ parsed }) {
+		return new AFSHistory(await AFSHistory.schema().parseAsync(parsed));
+	}
+	constructor(options) {
+		zodParse(optionalize(afsHistoryOptionsSchema), options);
+		this.storage = isAFSStorage(options?.storage) ? options.storage : new AFSStorageSQLite(this, options?.storage);
+		this.accessMode = options?.accessMode ?? "readwrite";
+	}
+	name = "history";
+	accessMode;
+	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) {
+		this.afs = afs;
+	}
+	async list(path, 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
+		});
+		return { data: data && {
+			...data,
+			path: this.normalizePath(data, scope, type)
+		} };
+	}
+	async write(path, content, options) {
+		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;
+		const scopeIdField = `${scope}Id`;
+		if (!match.params?.[scopeIdField]) 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
+		});
+		if (type === "history") this.afs?.emit("historyCreated", { entry }, options);
+		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` };
+	}
+	normalizePath(entry, scope, entryType) {
+		const scopeId = {
+			session: entry.sessionId,
+			user: entry.userId,
+			agent: entry.agentId
+		}[scope];
+		if (!scopeId) throw new Error(`Cannot reset path for entry without ${scope} info.`);
+		const prefix = `by-${scope}`;
+		if (entryType === "compact") return joinURL("/", prefix, scopeId, "@metadata/compact", entry.id);
+		if (entryType === "memory") return joinURL("/", prefix, scopeId, "@metadata/memory", entry.id);
+		return joinURL("/", prefix, scopeId, entry.id);
+	}
+};
+
+//#endregion
+export { AFSHistory, AFSStorageSQLite, isAFSStorage };
+//# sourceMappingURL=index.mjs.map