openclaw-cloudflare-vectorize-memory 0.1.0

package/dist/index.js

@@ -0,0 +1,1459 @@
+import { definePluginEntry as e } from "openclaw/plugin-sdk/plugin-entry";
+import { createHash as t, randomUUID as n } from "node:crypto";
+import { access as r, glob as i, mkdir as a, readFile as o, rm as s, stat as c, writeFile as l } from "node:fs/promises";
+import { basename as u, dirname as d, extname as f, isAbsolute as p, join as m, relative as ee, resolve as h } from "node:path";
+import { listMemoryFiles as g } from "openclaw/plugin-sdk/memory-core";
+import { resolveAgentIdFromSessionKey as te } from "openclaw/plugin-sdk/routing";
+import { resolveConfiguredSecretInputWithFallback as ne } from "openclaw/plugin-sdk/config-runtime";
+import { z as _ } from "zod";
+import { Buffer as re } from "node:buffer";
+import { Type as v } from "@sinclair/typebox";
+//#region src/namespace.ts
+function ie(e) {
+	return e.trim().toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+}
+function y(e) {
+	return ie(e) || "main";
+}
+function ae(e) {
+	if (e.fixedNamespace) return y(e.fixedNamespace);
+	let t = e.sessionKey ? te(e.sessionKey) : e.agentId;
+	return t ? y(`agent-${t}`) : e.workspaceDir ? y(`workspace-${u(e.workspaceDir)}`) : "main";
+}
+//#endregion
+//#region src/migration.ts
+var oe = new Set([".md", ".markdown"]), se = new Set([
+	"id",
+	"namespace",
+	"source",
+	"title"
+]);
+function b(e) {
+	return e.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function x(e) {
+	return b(e).replace(/^\/+/, "") || u(e);
+}
+function S(e) {
+	return oe.has(f(e).toLowerCase());
+}
+function ce(e) {
+	return /[*?[\]{}]/.test(e);
+}
+function C(e) {
+	let t = b(e).toLowerCase();
+	return t.includes("/node_modules/") || t.includes("/.git/");
+}
+async function w(e) {
+	try {
+		return await c(e);
+	} catch {
+		return null;
+	}
+}
+async function le(e) {
+	let t = [];
+	for await (let n of i("**/*.{md,markdown}", { cwd: e })) {
+		let r = h(e, n);
+		C(r) || t.push(r);
+	}
+	return t;
+}
+async function ue(e, t) {
+	let n = [], r = b(e), a = p(e) ? i(r) : i(r, { cwd: t });
+	for await (let e of a) {
+		let r = p(e) ? e : h(t, e);
+		C(r) || !S(r) || (await w(r))?.isFile() && n.push(r);
+	}
+	return n;
+}
+async function de(e) {
+	let t = h(e.workspaceDir), n = /* @__PURE__ */ new Map();
+	if (e.sourceMode === "default-provider") for (let e of await g(t)) {
+		let r = x(e), i = h(t, r);
+		C(i) || !S(r) || (await w(i))?.isFile() && n.set(i.toLowerCase(), {
+			absolutePath: i,
+			relativePath: r
+		});
+	}
+	for (let r of e.sourcePaths ?? []) {
+		let e = h(t, r), i = await w(e), a = [];
+		i?.isDirectory() ? a = await le(e) : i?.isFile() ? a = S(e) ? [e] : [] : ce(r) && (a = await ue(r, t));
+		for (let e of a) {
+			let r = x(ee(t, e));
+			n.set(e.toLowerCase(), {
+				absolutePath: e,
+				relativePath: r
+			});
+		}
+	}
+	return [...n.values()].sort((e, t) => e.relativePath.localeCompare(t.relativePath));
+}
+function fe(e) {
+	let t = e.trim();
+	if (!t) return "";
+	if (/^"(.*)"$/.test(t) || /^'(.*)'$/.test(t)) return t.slice(1, -1);
+	if (t === "true") return !0;
+	if (t === "false") return !1;
+	let n = Number(t);
+	if (!Number.isNaN(n) && t !== "") return n;
+	if (!(t.startsWith("[") || t.startsWith("{"))) return t;
+}
+function pe(e) {
+	let t = e.replace(/\r\n/g, "\n");
+	if (!t.startsWith("---\n")) return {
+		body: t,
+		attributes: {}
+	};
+	let n = t.split("\n"), r = n.findIndex((e, t) => t > 0 && e.trim() === "---");
+	if (r === -1) return {
+		body: t,
+		attributes: {}
+	};
+	let i = {};
+	for (let e of n.slice(1, r)) {
+		let t = e.indexOf(":");
+		if (t === -1) continue;
+		let n = e.slice(0, t).trim();
+		if (!n) continue;
+		let r = fe(e.slice(t + 1));
+		r !== void 0 && (i[n] = r);
+	}
+	return {
+		body: n.slice(r + 1).join("\n"),
+		attributes: i
+	};
+}
+function me(e) {
+	let t = e.split("\n"), n = t.findIndex((e) => e.trim().length > 0);
+	if (n === -1) return { text: "" };
+	let r = /^#\s+(.+?)\s*$/.exec(t[n]?.trim() ?? "");
+	if (!r) return { text: e.trim() };
+	let i = [...t];
+	i.splice(n, 1), (i[n] ?? "").trim() === "" && i.splice(n, 1);
+	let a = i.join("\n").trim();
+	return {
+		title: r[1].trim(),
+		text: a || e.trim()
+	};
+}
+function he(e) {
+	let n = e.replace(/\.(md|markdown)$/i, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").slice(0, 80), r = t("sha1").update(e).digest("hex").slice(0, 10);
+	return `${n || "memory"}-${r}`;
+}
+function ge(e, t, n) {
+	return typeof t == "string" && t.trim().length > 0 ? t.trim() : n || u(e, f(e)).trim() || void 0;
+}
+function _e(e, t, n) {
+	return e.resolveNamespace({
+		namespace: t.namespace,
+		workspaceDir: n
+	});
+}
+function ve(e) {
+	if (e.namespaceStrategy === "single-target") return e.targetNamespace;
+	if (typeof e.frontmatterNamespace == "string" && e.frontmatterNamespace.trim().length > 0) return y(e.frontmatterNamespace);
+	let t = x(e.relativePath).split("/")[0];
+	return !t || t === "." || t === ".." ? e.targetNamespace : y(t);
+}
+async function ye(e) {
+	let { body: t, attributes: n } = pe(await o(e.file.absolutePath, "utf8")), { title: r, text: i } = me(t), a = ge(e.file.relativePath, n.title, r), s = i.trim() || a || "";
+	if (!s) return null;
+	let c = {
+		legacySourceMode: e.sourceMode,
+		legacySourcePath: e.file.relativePath.startsWith("..") ? e.file.absolutePath : e.file.relativePath
+	};
+	for (let [e, t] of Object.entries(n)) se.has(e) || (c[e] = t);
+	let l = typeof n.id == "string" && n.id.trim().length > 0 ? n.id.trim() : he(e.file.relativePath), u = ve({
+		relativePath: e.file.relativePath,
+		frontmatterNamespace: n.namespace,
+		targetNamespace: e.targetNamespace,
+		namespaceStrategy: e.namespaceStrategy
+	}), d = typeof n.source == "string" && n.source.trim().length > 0 ? n.source.trim() : e.sourceMode === "default-provider" ? "openclaw-default-memory" : "markdown-import";
+	return {
+		sourcePath: e.file.absolutePath,
+		relativePath: e.file.relativePath,
+		input: {
+			id: l,
+			namespace: u,
+			title: a,
+			text: s,
+			source: d,
+			metadata: c
+		}
+	};
+}
+function be(e) {
+	return e.checks.filter((e) => e.status === "fail").map((e) => `${e.name}: ${e.message}`).join(" | ");
+}
+async function xe(e) {
+	let t = e.options ?? {}, n = h(t.workspaceDir ?? process.cwd()), r = (t.sourcePaths?.length ?? 0) > 0 ? "paths" : "default-provider", i = t.namespaceStrategy ?? "single-target", a = t.duplicateStrategy ?? "overwrite", o = t.dryRun ?? !1, s = _e(e.service, t, n), c = await e.service.doctor({ createIndexIfMissing: t.createIndexIfMissing ?? !1 });
+	if (!c.ok) throw Error(`Migration validation failed. ${be(c)}`);
+	let l = await de({
+		workspaceDir: n,
+		sourceMode: r,
+		sourcePaths: t.sourcePaths
+	});
+	if (l.length === 0) throw Error(r === "default-provider" ? `No default OpenClaw markdown memory files were found under ${n}.` : "No markdown files matched the provided migration sources.");
+	let u = [], d = 0, f = 0, p = 0, m = 0;
+	for (let t of l) try {
+		let n = await ye({
+			file: t,
+			sourceMode: r,
+			targetNamespace: s,
+			namespaceStrategy: i
+		});
+		if (!n) {
+			p += 1, u.push({
+				action: "skipped",
+				sourcePath: t.absolutePath,
+				relativePath: t.relativePath,
+				reason: "File did not contain any importable markdown content."
+			});
+			continue;
+		}
+		d += 1;
+		let c = n.input.id, l = n.input.namespace;
+		if (!c || !l) throw Error("Parsed migration record is missing a logical id or namespace.");
+		if (a !== "overwrite" && await e.service.get({
+			id: c,
+			namespace: l
+		})) {
+			if (a === "skip") {
+				p += 1, u.push({
+					action: "skipped",
+					sourcePath: n.sourcePath,
+					relativePath: n.relativePath,
+					logicalId: c,
+					namespace: l,
+					title: n.input.title,
+					reason: "A record with the same logical id already exists."
+				});
+				continue;
+			}
+			throw Error(`A record with logical id ${c} already exists in namespace ${l}.`);
+		}
+		if (o) {
+			u.push({
+				action: "would-import",
+				sourcePath: n.sourcePath,
+				relativePath: n.relativePath,
+				logicalId: c,
+				namespace: l,
+				title: n.input.title
+			});
+			continue;
+		}
+		await e.service.upsert({ input: n.input }), f += 1, u.push({
+			action: "imported",
+			sourcePath: n.sourcePath,
+			relativePath: n.relativePath,
+			logicalId: c,
+			namespace: l,
+			title: n.input.title
+		});
+	} catch (e) {
+		m += 1, u.push({
+			action: "failed",
+			sourcePath: t.absolutePath,
+			relativePath: t.relativePath,
+			error: e instanceof Error ? e.message : "Unknown migration failure."
+		});
+	}
+	return {
+		dryRun: o,
+		sourceMode: r,
+		workspaceDir: n,
+		namespaceStrategy: i,
+		targetNamespace: i === "single-target" ? s : void 0,
+		discoveredFiles: l.length,
+		preparedRecords: d,
+		imported: f,
+		skipped: p,
+		failed: m,
+		doctor: c,
+		results: u
+	};
+}
+function Se(e) {
+	let t = [
+		`${e.dryRun ? "Dry-run" : "Migration"} ${e.failed > 0 ? "completed with failures" : "completed"}.`,
+		`Source mode: ${e.sourceMode}`,
+		`Workspace: ${e.workspaceDir}`,
+		`Files scanned: ${e.discoveredFiles}`,
+		`Records prepared: ${e.preparedRecords}`,
+		`Imported: ${e.imported}`,
+		`Skipped: ${e.skipped}`,
+		`Failed: ${e.failed}`
+	];
+	e.targetNamespace && t.splice(3, 0, `Target namespace: ${e.targetNamespace}`);
+	let n = e.results.filter((e) => e.action === "failed").slice(0, 10);
+	if (n.length > 0) {
+		t.push("", "Failures:");
+		for (let e of n) t.push(`- ${e.relativePath}: ${e.error}`);
+	}
+	return t.join("\n");
+}
+//#endregion
+//#region src/constants.ts
+var T = "memory-cloudflare-vectorize", Ce = "Cloudflare Vectorize Memory", we = "OpenClaw memory plugin backed by Cloudflare Vectorize and Workers AI embeddings.", E = "CLOUDFLARE_ACCOUNT_ID", D = "CLOUDFLARE_API_TOKEN", O = "CLOUDFLARE_VECTORIZE_INDEX_NAME", k = "CLOUDFLARE_VECTORIZE_NAMESPACE", A = "CLOUDFLARE_WORKERS_AI_EMBEDDING_MODEL", j = "CLOUDFLARE_VECTORIZE_TOP_K", M = "OPENCLAW_CF_MEMORY_STORAGE_MODE", Te = "OPENCLAW_CF_MEMORY_COMPANION_PATH", N = "@cf/baai/bge-base-en-v1.5", Ee = "vectorize-inline", P = "https://api.cloudflare.com/client/v4", F = {
+	logicalId: "oc_record_id",
+	title: "oc_title",
+	text: "oc_text",
+	storageMode: "oc_storage_mode",
+	pointer: "oc_pointer",
+	source: "oc_source",
+	createdAt: "oc_created_at",
+	updatedAt: "oc_updated_at"
+}, I = class extends Error {
+	constructor(e) {
+		super(e), this.name = "ConfigurationError";
+	}
+}, L = class extends Error {
+	constructor(e, t, n) {
+		super(e), this.status = t, this.details = n, this.name = "CloudflareApiError";
+	}
+}, De = class extends Error {
+	constructor(e) {
+		super(e), this.name = "RecordSizeError";
+	}
+}, Oe = _.object({
+	source: _.enum([
+		"env",
+		"file",
+		"exec"
+	]),
+	provider: _.string().min(1),
+	id: _.string().min(1)
+}).strict(), ke = _.union([_.string().min(1), Oe]), Ae = _.object({
+	description: _.string().min(1).optional(),
+	dimensions: _.number().int().min(1).max(1536).optional(),
+	metric: _.enum([
+		"cosine",
+		"euclidean",
+		"dot-product"
+	]).optional()
+}).strict(), R = _.object({
+	cloudflare: _.object({
+		accountId: _.string().min(1).optional(),
+		apiToken: ke.optional(),
+		apiBaseUrl: _.string().url().optional(),
+		workersAiBaseUrl: _.string().url().optional(),
+		vectorizeBaseUrl: _.string().url().optional()
+	}).strict().optional(),
+	vectorize: _.object({
+		indexName: _.string().min(1).optional(),
+		namespace: _.string().min(1).optional(),
+		topK: _.number().int().min(1).max(50).optional(),
+		minScore: _.number().min(0).max(1).optional(),
+		metric: _.enum([
+			"cosine",
+			"euclidean",
+			"dot-product"
+		]).optional(),
+		createIndex: Ae.optional(),
+		metadataIndexedFields: _.array(_.string().min(1)).default([])
+	}).strict().optional(),
+	embeddings: _.object({ model: _.string().min(1).optional() }).strict().optional(),
+	storage: _.object({
+		mode: _.enum(["vectorize-inline", "companion-store"]).optional(),
+		companionStorePath: _.string().min(1).optional(),
+		inlineTextMaxBytes: _.number().int().min(256).max(1e4).optional()
+	}).strict().optional()
+}).strict(), z = {
+	parse(e) {
+		return R.parse(e ?? {});
+	},
+	safeParse(e) {
+		let t = R.safeParse(e ?? {});
+		return t.success ? {
+			success: !0,
+			data: t.data
+		} : {
+			success: !1,
+			error: { issues: t.error.issues.map((e) => ({
+				path: e.path.filter((e) => typeof e == "string" || typeof e == "number"),
+				message: e.message
+			})) }
+		};
+	},
+	jsonSchema: {
+		type: "object",
+		additionalProperties: !1,
+		properties: {
+			cloudflare: {
+				type: "object",
+				additionalProperties: !1,
+				properties: {
+					accountId: { type: "string" },
+					apiToken: { anyOf: [{ type: "string" }, {
+						type: "object",
+						additionalProperties: !1,
+						properties: {
+							source: {
+								type: "string",
+								enum: [
+									"env",
+									"file",
+									"exec"
+								]
+							},
+							provider: { type: "string" },
+							id: { type: "string" }
+						},
+						required: [
+							"source",
+							"provider",
+							"id"
+						]
+					}] },
+					apiBaseUrl: {
+						type: "string",
+						format: "uri"
+					},
+					workersAiBaseUrl: {
+						type: "string",
+						format: "uri"
+					},
+					vectorizeBaseUrl: {
+						type: "string",
+						format: "uri"
+					}
+				}
+			},
+			vectorize: {
+				type: "object",
+				additionalProperties: !1,
+				properties: {
+					indexName: { type: "string" },
+					namespace: { type: "string" },
+					topK: {
+						type: "integer",
+						minimum: 1,
+						maximum: 50
+					},
+					minScore: {
+						type: "number",
+						minimum: 0,
+						maximum: 1
+					},
+					metric: {
+						type: "string",
+						enum: [
+							"cosine",
+							"euclidean",
+							"dot-product"
+						]
+					},
+					createIndex: {
+						type: "object",
+						additionalProperties: !1,
+						properties: {
+							description: { type: "string" },
+							dimensions: {
+								type: "integer",
+								minimum: 1,
+								maximum: 1536
+							},
+							metric: {
+								type: "string",
+								enum: [
+									"cosine",
+									"euclidean",
+									"dot-product"
+								]
+							}
+						}
+					},
+					metadataIndexedFields: {
+						type: "array",
+						items: { type: "string" }
+					}
+				}
+			},
+			embeddings: {
+				type: "object",
+				additionalProperties: !1,
+				properties: { model: { type: "string" } }
+			},
+			storage: {
+				type: "object",
+				additionalProperties: !1,
+				properties: {
+					mode: {
+						type: "string",
+						enum: ["vectorize-inline", "companion-store"]
+					},
+					companionStorePath: { type: "string" },
+					inlineTextMaxBytes: {
+						type: "integer",
+						minimum: 256,
+						maximum: 1e4
+					}
+				}
+			}
+		}
+	},
+	uiHints: {
+		"cloudflare.accountId": {
+			label: "Cloudflare account ID",
+			help: `Defaults to \${${E}}.`
+		},
+		"cloudflare.apiToken": {
+			label: "Cloudflare API token",
+			sensitive: !0,
+			help: `Defaults to \${${D}}.`
+		},
+		"vectorize.indexName": {
+			label: "Vectorize index name",
+			help: `Defaults to \${${O}}.`
+		},
+		"vectorize.namespace": {
+			label: "Fixed namespace override",
+			help: `Defaults to \${${k}} or derives from the agent/session context.`
+		},
+		"vectorize.topK": {
+			label: "Top-K results",
+			help: `Defaults to \${${j}} or 5.`
+		},
+		"embeddings.model": {
+			label: "Workers AI embedding model",
+			help: `Defaults to \${${A}} or ${N}.`
+		},
+		"storage.mode": {
+			label: "Storage mode",
+			help: `Defaults to \${${M}} or ${Ee}.`
+		},
+		"storage.companionStorePath": {
+			label: "Companion store path",
+			help: `Defaults to \${${Te}} or the OpenClaw state directory.`
+		}
+	}
+};
+function B(...e) {
+	return e.find((e) => e !== void 0);
+}
+function V(...e) {
+	for (let t of e) if (t && t.trim().length > 0) return t.trim();
+}
+function H(...e) {
+	return e.find((e) => typeof e == "number" && Number.isFinite(e));
+}
+function je(e) {
+	return [...new Set((e ?? []).map((e) => e.trim()).filter(Boolean))];
+}
+function Me(e) {
+	return e ?? "cosine";
+}
+function Ne(e) {
+	return e ?? "vectorize-inline";
+}
+function U(e) {
+	return R.parse(e ?? {});
+}
+function Pe(e) {
+	let t = e.plugins?.entries?.[T];
+	return U(t ?? {});
+}
+async function W(e) {
+	let t = U(e.pluginConfig), n = e.env ?? process.env, r = `plugins.entries.${T}`, i = V(t.cloudflare?.accountId, n[E]);
+	if (!i) throw new I(`Missing Cloudflare account id. Set ${E} or ${r}.cloudflare.accountId.`);
+	let a = await ne({
+		config: e.openClawConfig,
+		env: n,
+		value: t.cloudflare?.apiToken,
+		path: `${r}.cloudflare.apiToken`,
+		unresolvedReasonStyle: "detailed",
+		readFallback: () => n[D]
+	});
+	if (!a.value) throw new I(`Missing Cloudflare API token. Set ${D} or ${r}.cloudflare.apiToken.${a.unresolvedRefReason ? ` ${a.unresolvedRefReason}` : ""}`.trim());
+	let o = V(t.vectorize?.indexName, n[O]);
+	if (!o) throw new I(`Missing Vectorize index name. Set ${O} or ${r}.vectorize.indexName.`);
+	let s = V(t.cloudflare?.apiBaseUrl, P);
+	if (!s) throw new I(`Invalid Cloudflare API base URL. Set ${r}.cloudflare.apiBaseUrl or ensure ${P} is a valid URL.`);
+	let c = V(t.vectorize?.namespace, n[k]), l = H(t.vectorize?.topK, n.CLOUDFLARE_VECTORIZE_TOP_K ? Number(n[j]) : void 0), u = Ne(B(t.storage?.mode, n[M])), d = V(t.storage?.companionStorePath, n.OPENCLAW_CF_MEMORY_COMPANION_PATH) ?? m(".openclaw", "memory-cloudflare-vectorize", "companion-store.json"), f = e.resolvePath ?? ((e) => e), p = V(t.embeddings?.model, n[A], N);
+	if (!p) throw new I(`Missing Workers AI embedding model. Set ${A} or ${r}.embeddings.model.`);
+	let ee = H(t.storage?.inlineTextMaxBytes) ?? 6e3, h = H(t.vectorize?.minScore) ?? 0, g = Me(B(t.vectorize?.metric, t.vectorize?.createIndex?.metric));
+	return {
+		accountId: i,
+		apiToken: a.value,
+		apiBaseUrl: s,
+		workersAiBaseUrl: V(t.cloudflare?.workersAiBaseUrl) ?? `${s}/accounts/${i}/ai/v1`,
+		vectorizeBaseUrl: V(t.cloudflare?.vectorizeBaseUrl) ?? `${s}/accounts/${i}/vectorize/v2/indexes/${o}`,
+		indexName: o,
+		fixedNamespace: c,
+		topK: l ?? 5,
+		minScore: h,
+		metric: g,
+		model: p,
+		storageMode: u,
+		companionStorePath: f(d),
+		inlineTextMaxBytes: ee,
+		metadataIndexedFields: je(t.vectorize?.metadataIndexedFields),
+		createIndex: {
+			description: t.vectorize?.createIndex?.description ?? "OpenClaw memory index backed by Cloudflare Vectorize.",
+			dimensions: t.vectorize?.createIndex?.dimensions,
+			metric: g
+		}
+	};
+}
+//#endregion
+//#region src/cloudflare-api.ts
+function G(e, t) {
+	return e?.errors?.map((e) => e.message).filter(Boolean).join("; ") || t;
+}
+function Fe(e) {
+	return e instanceof L && e.status === 404;
+}
+async function K(e) {
+	let t = new Headers(e.headers);
+	t.set("Authorization", `Bearer ${e.apiToken}`), !t.has("Content-Type") && e.body && t.set("Content-Type", "application/json");
+	let n = await fetch(e.url, {
+		method: e.method ?? (e.body ? "POST" : "GET"),
+		headers: t,
+		body: e.body
+	}), r = await n.text(), i = r ? JSON.parse(r) : void 0;
+	if (!n.ok) throw new L(G(i, `Cloudflare request failed with ${n.status}.`), n.status, i);
+	if (!i?.success) throw new L(G(i, "Cloudflare request failed."), n.status, i);
+	return i.result;
+}
+//#endregion
+//#region src/companion-store.ts
+function q(e, t) {
+	return `${e}::${t}`;
+}
+async function J(e) {
+	try {
+		let t = await o(e, "utf8");
+		return JSON.parse(t);
+	} catch {
+		return {
+			version: 1,
+			records: {}
+		};
+	}
+}
+var Ie = class {
+	constructor(e) {
+		this.path = e;
+	}
+	get filePath() {
+		return this.path;
+	}
+	async upsert(e) {
+		let t = await J(this.path);
+		t.records[q(e.namespace, e.id)] = e, await a(d(this.path), { recursive: !0 }), await l(this.path, JSON.stringify(t, null, 2), "utf8");
+	}
+	async get(e, t) {
+		return (await J(this.path)).records[q(e, t)] ?? null;
+	}
+	async delete(e, t) {
+		let n = await J(this.path);
+		delete n.records[q(e, t)], await a(d(this.path), { recursive: !0 }), await l(this.path, JSON.stringify(n, null, 2), "utf8");
+	}
+	async clear() {
+		await s(this.path, { force: !0 });
+	}
+};
+//#endregion
+//#region src/doctor.ts
+async function Le(e) {
+	let t = [];
+	t.push({
+		name: "credentials",
+		status: "pass",
+		message: `Using Cloudflare account ${e.service.config.accountId} and Vectorize index ${e.service.config.indexName}.`
+	});
+	let n = await e.service.ensureIndexExists(e.createIndexIfMissing);
+	t.push({
+		name: "vectorize-index",
+		status: "pass",
+		message: n.created ? `Created Vectorize index "${e.service.config.indexName}" with ${n.dimensions} dimensions.` : `Vectorize index "${e.service.config.indexName}" is reachable.`
+	});
+	let r = await e.service.embeddings.probeDimensions();
+	return t.push({
+		name: "workers-ai-embeddings",
+		status: "pass",
+		message: `Workers AI model ${e.service.config.model} returned ${r} dimensions.`
+	}), r === n.dimensions ? t.push({
+		name: "dimension-match",
+		status: "pass",
+		message: "Embedding dimensions match the Vectorize index."
+	}) : t.push({
+		name: "dimension-match",
+		status: "fail",
+		message: `Embedding dimensions (${r}) do not match the Vectorize index dimensions (${n.dimensions}).`
+	}), t.push({
+		name: "metadata-filters",
+		status: e.service.config.metadataIndexedFields.length > 0 ? "pass" : "warn",
+		message: e.service.config.metadataIndexedFields.length > 0 ? `Configured metadata-index guidance for: ${e.service.config.metadataIndexedFields.join(", ")}.` : "No metadataIndexedFields configured. Add metadata indexes in Cloudflare before relying on filter-heavy queries."
+	}), {
+		ok: t.every((e) => e.status !== "fail"),
+		checks: t
+	};
+}
+//#endregion
+//#region src/embeddings-client.ts
+var Re = class {
+	constructor(e) {
+		this.config = e;
+	}
+	async embedQuery(e) {
+		let [t] = await this.embedBatch([e]);
+		return t;
+	}
+	async embedBatch(e) {
+		return e.length === 0 ? [] : [...(await K({
+			url: `${this.config.workersAiBaseUrl}/embeddings`,
+			apiToken: this.config.apiToken,
+			body: JSON.stringify({
+				model: this.config.model,
+				input: e
+			})
+		})).data].sort((e, t) => e.index - t.index).map((e) => e.embedding);
+	}
+	async probeDimensions() {
+		return (await this.embedQuery("openclaw-memory-dimension-probe")).length;
+	}
+};
+//#endregion
+//#region src/record-mapper.ts
+function ze(e) {
+	let t = e.trim().replace(/[.$"]/g, "_").replace(/\s+/g, "_");
+	return t ? t.startsWith("oc_") ? `user_${t}` : t : "metadata";
+}
+function Be(e) {
+	if (!e) return {};
+	let t = Object.entries(e).filter(([, e]) => [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof e));
+	return Object.fromEntries(t.map(([e, t]) => [ze(e), t]));
+}
+function Ve(e, t) {
+	return `${e}::${t}`;
+}
+function Y(e, t) {
+	return `${e}/${t}.md`;
+}
+function He(e) {
+	let t = e.replace(/\\/g, "/").replace(/^\//, "").split("/");
+	return t.length !== 2 || !t[1].endsWith(".md") ? null : {
+		namespace: t[0],
+		logicalId: t[1].slice(0, -3)
+	};
+}
+function Ue(e, t) {
+	let n = e.trim().replace(/\s+/g, " ");
+	if (!n) return "";
+	let r = n.toLowerCase().indexOf(t.trim().toLowerCase());
+	if (r === -1) return n.slice(0, 220);
+	let i = Math.max(0, r - 80), a = Math.min(n.length, r + Math.max(t.length, 40) + 80);
+	return n.slice(i, a);
+}
+function We(e) {
+	let t = e.input.id?.trim() || n(), r = Ve(e.namespace, t), i = (/* @__PURE__ */ new Date()).toISOString(), a = Be(e.input.metadata), o = {
+		...a,
+		[F.logicalId]: t,
+		[F.storageMode]: e.config.storageMode,
+		[F.createdAt]: i,
+		[F.updatedAt]: i
+	};
+	e.input.title && (o[F.title] = e.input.title), e.input.source && (o[F.source] = e.input.source);
+	let s;
+	if (e.config.storageMode === "vectorize-inline") {
+		let t = re.byteLength(e.input.text, "utf8");
+		if (t > e.config.inlineTextMaxBytes) throw new De(`Memory text is ${t} bytes, which exceeds the inline metadata limit of ${e.config.inlineTextMaxBytes}. Switch storage.mode to "companion-store" or reduce the payload size.`);
+		o[F.text] = e.input.text;
+	} else {
+		let n = Y(e.namespace, t);
+		o[F.pointer] = n, s = {
+			id: t,
+			namespace: e.namespace,
+			title: e.input.title,
+			text: e.input.text,
+			metadata: a,
+			source: e.input.source,
+			createdAt: i,
+			updatedAt: i
+		};
+	}
+	return {
+		logicalId: t,
+		vectorId: r,
+		path: Y(e.namespace, t),
+		vector: {
+			id: r,
+			namespace: e.namespace,
+			values: e.embedding,
+			metadata: o
+		},
+		companionRecord: s
+	};
+}
+function Ge(e) {
+	let t = e.metadata ?? {}, n = e.namespace ?? (typeof t[F.pointer] == "string" ? String(t[F.pointer]).split("/")[0] : "main"), r = typeof t[F.logicalId] == "string" ? String(t[F.logicalId]) : String(e.id ?? ""), i = Object.fromEntries(Object.entries(t).filter(([e]) => !e.startsWith("oc_")));
+	return {
+		logicalId: r,
+		vectorId: String(e.id ?? r),
+		namespace: n,
+		title: typeof t[F.title] == "string" ? String(t[F.title]) : void 0,
+		text: typeof t[F.text] == "string" ? String(t[F.text]) : void 0,
+		metadata: i,
+		source: typeof t[F.source] == "string" ? String(t[F.source]) : void 0,
+		createdAt: typeof t[F.createdAt] == "string" ? String(t[F.createdAt]) : void 0,
+		updatedAt: typeof t[F.updatedAt] == "string" ? String(t[F.updatedAt]) : void 0,
+		path: Y(n, r)
+	};
+}
+//#endregion
+//#region src/vectorize-client.ts
+var Ke = class {
+	constructor(e) {
+		this.config = e;
+	}
+	async describeIndex() {
+		return K({
+			url: this.config.vectorizeBaseUrl,
+			apiToken: this.config.apiToken,
+			method: "GET"
+		});
+	}
+	async createIndex(e, t = this.config.createIndex.metric) {
+		return K({
+			url: `${this.config.apiBaseUrl}/accounts/${this.config.accountId}/vectorize/v2/indexes`,
+			apiToken: this.config.apiToken,
+			body: JSON.stringify({
+				name: this.config.indexName,
+				description: this.config.createIndex.description,
+				config: {
+					dimensions: e,
+					metric: t
+				}
+			})
+		});
+	}
+	async upsert(e) {
+		let t = e.map((e) => JSON.stringify(e)).join("\n");
+		return (await K({
+			url: `${this.config.vectorizeBaseUrl}/upsert`,
+			apiToken: this.config.apiToken,
+			headers: { "Content-Type": "application/x-ndjson" },
+			body: t
+		})).mutationId;
+	}
+	async query(e) {
+		return (await K({
+			url: `${this.config.vectorizeBaseUrl}/query`,
+			apiToken: this.config.apiToken,
+			body: JSON.stringify({
+				vector: e.vector,
+				topK: e.topK ?? this.config.topK,
+				filter: e.filter,
+				namespace: e.namespace,
+				returnValues: e.returnValues ?? !1
+			})
+		})).matches ?? [];
+	}
+	async getByIds(e) {
+		return e.length === 0 ? [] : K({
+			url: `${this.config.vectorizeBaseUrl}/get_by_ids`,
+			apiToken: this.config.apiToken,
+			body: JSON.stringify({ ids: e })
+		});
+	}
+	async deleteByIds(e) {
+		if (e.length !== 0) return (await K({
+			url: `${this.config.vectorizeBaseUrl}/delete_by_ids`,
+			apiToken: this.config.apiToken,
+			body: JSON.stringify({ ids: e })
+		})).mutationId;
+	}
+}, qe = class {
+	embeddings;
+	vectorize;
+	companionStore;
+	constructor(e, t) {
+		this.config = e, this.openClawConfig = t, this.embeddings = new Re(e), this.vectorize = new Ke(e), this.companionStore = new Ie(e.companionStorePath);
+	}
+	resolveNamespace(e) {
+		return ae({
+			fixedNamespace: e.namespace ?? this.config.fixedNamespace,
+			sessionKey: e.sessionKey,
+			agentId: e.agentId,
+			workspaceDir: e.workspaceDir
+		});
+	}
+	async search(e) {
+		let t = this.resolveNamespace(e), n = await this.embeddings.embedQuery(e.query), r = await this.vectorize.query({
+			vector: n,
+			namespace: t,
+			topK: e.maxResults ?? this.config.topK,
+			filter: e.filter
+		});
+		return (await Promise.all(r.map(async (e) => {
+			let t = Ge(e), n = t.text ?? (await this.companionStore.get(t.namespace, t.logicalId))?.text ?? "";
+			return {
+				...t,
+				text: n,
+				score: e.score ?? 0
+			};
+		}))).filter((t) => t.score >= (e.minScore ?? this.config.minScore));
+	}
+	async get(e) {
+		let t = `${this.resolveNamespace(e)}::${e.id}`, [n] = await this.vectorize.getByIds([t]);
+		if (!n) return null;
+		let r = Ge(n), i = await this.companionStore.get(r.namespace, r.logicalId);
+		return {
+			...r,
+			text: r.text ?? i?.text ?? ""
+		};
+	}
+	async upsert(e) {
+		let t = this.resolveNamespace({
+			namespace: e.input.namespace,
+			sessionKey: e.sessionKey,
+			agentId: e.agentId,
+			workspaceDir: e.workspaceDir
+		}), n = await this.embeddings.embedQuery(e.input.text), r = We({
+			input: e.input,
+			namespace: t,
+			embedding: n,
+			config: this.config
+		});
+		r.companionRecord && await this.companionStore.upsert(r.companionRecord);
+		let i = await this.vectorize.upsert([r.vector]);
+		return {
+			...await this.get({
+				id: r.logicalId,
+				namespace: t
+			}) ?? this.fromCompanionFallback(r.companionRecord, r.logicalId, t, r.path),
+			mutationId: i
+		};
+	}
+	async delete(e) {
+		let t = this.resolveNamespace(e);
+		return await this.companionStore.delete(t, e.id), this.vectorize.deleteByIds([`${t}::${e.id}`]);
+	}
+	async doctor(e) {
+		return Le({
+			service: this,
+			createIndexIfMissing: e.createIndexIfMissing ?? !1
+		});
+	}
+	async ensureIndexExists(e) {
+		try {
+			return {
+				created: !1,
+				dimensions: (await this.vectorize.describeIndex()).config.dimensions
+			};
+		} catch (t) {
+			if (!e || !Fe(t)) throw t;
+			let n = this.config.createIndex.dimensions ?? await this.embeddings.probeDimensions();
+			return await this.vectorize.createIndex(n), {
+				created: !0,
+				dimensions: n
+			};
+		}
+	}
+	fromCompanionFallback(e, t, n, r) {
+		return {
+			logicalId: t,
+			vectorId: `${n}::${t}`,
+			namespace: n,
+			title: e?.title,
+			text: e?.text ?? "",
+			metadata: e?.metadata ?? {},
+			source: e?.source,
+			createdAt: e?.createdAt,
+			updatedAt: e?.updatedAt,
+			path: r
+		};
+	}
+};
+//#endregion
+//#region src/service-factory.ts
+async function X(e) {
+	return new qe(await W(e), e.openClawConfig);
+}
+//#endregion
+//#region src/cli.ts
+function Z(e) {
+	console.log(JSON.stringify(e, null, 2));
+}
+function Je(e) {
+	if (!e) return;
+	let t = JSON.parse(e);
+	if (!t || typeof t != "object" || Array.isArray(t)) throw Error("--metadata must be a JSON object.");
+	return t;
+}
+function Ye(e) {
+	if (!e) return;
+	let t = JSON.parse(e);
+	if (!t || typeof t != "object" || Array.isArray(t)) throw Error("--filter must be a JSON object.");
+	return t;
+}
+function Xe(e) {
+	return !!e && typeof e == "object" && typeof e.opts == "function";
+}
+function Ze(e) {
+	let t = e.at(-1);
+	return Xe(t) ? {
+		positionals: e.slice(0, -1),
+		options: t.opts?.() ?? {}
+	} : {
+		positionals: e,
+		options: {}
+	};
+}
+function Qe(e) {
+	if (e !== void 0) {
+		if (e === "overwrite" || e === "skip" || e === "fail") return e;
+		throw Error("--if-exists must be overwrite, skip, or fail.");
+	}
+}
+function $e(e, t) {
+	let n = e.command("cf-memory").description("Manage Cloudflare memory records.");
+	function r(e) {
+		return Ze(e).options;
+	}
+	n.command("doctor").description("Validate Workers AI and Vectorize configuration.").option("--create-index", "Create the Vectorize index if missing.").option("--json", "Print structured JSON output.").action(async (...e) => {
+		let n = r(e), i = await (await X({
+			pluginConfig: t.pluginConfig,
+			openClawConfig: t.openClawConfig,
+			env: process.env,
+			resolvePath: t.resolvePath
+		})).doctor({ createIndexIfMissing: !!n.createIndex });
+		if (n.json) Z(i);
+		else for (let e of i.checks) console.log(`[${e.status}] ${e.name}: ${e.message}`);
+		i.ok || (process.exitCode = 1);
+	}), n.command("search").description("Search stored Cloudflare memory.").argument("<query>", "Semantic search query.").option("--namespace <namespace>", "Optional namespace override.").option("--limit <count>", "Maximum number of results.").option("--filter <json>", "Optional metadata filter JSON.").action(async (e, n) => {
+		let r = n;
+		Z(await (await X({
+			pluginConfig: t.pluginConfig,
+			openClawConfig: t.openClawConfig,
+			env: process.env,
+			resolvePath: t.resolvePath
+		})).search({
+			query: String(e),
+			namespace: r.namespace,
+			maxResults: r.limit ? Number(r.limit) : void 0,
+			filter: Ye(r.filter)
+		}));
+	}), n.command("upsert").description("Insert or update a memory record.").argument("<text>", "Memory text.").option("--id <id>", "Stable logical id.").option("--title <title>", "Optional title.").option("--namespace <namespace>", "Optional namespace override.").option("--source <source>", "Optional source label.").option("--metadata <json>", "Optional metadata JSON object.").action(async (e, n) => {
+		let r = n;
+		Z(await (await X({
+			pluginConfig: t.pluginConfig,
+			openClawConfig: t.openClawConfig,
+			env: process.env,
+			resolvePath: t.resolvePath
+		})).upsert({ input: {
+			id: r.id,
+			title: r.title,
+			text: String(e),
+			namespace: r.namespace,
+			source: r.source,
+			metadata: Je(r.metadata)
+		} }));
+	}), n.command("delete").description("Delete a memory record.").argument("<id>", "Logical memory record id.").option("--namespace <namespace>", "Optional namespace override.").action(async (e, n) => {
+		let r = n;
+		Z({
+			id: e,
+			mutationId: await (await X({
+				pluginConfig: t.pluginConfig,
+				openClawConfig: t.openClawConfig,
+				env: process.env,
+				resolvePath: t.resolvePath
+			})).delete({
+				id: String(e),
+				namespace: r.namespace
+			})
+		});
+	}), n.command("migrate").description("Migrate legacy markdown memory into Cloudflare Vectorize.").argument("[sources...]", "Markdown files, directories, or glob patterns. Defaults to the current OpenClaw memory corpus when omitted.").option("--workspace <path>", "Workspace root used for default-provider discovery and relative path normalization.").option("--namespace <namespace>", "Target namespace override.").option("--derive-namespace-from-path", "Derive namespaces from the first relative path segment instead of using a single target namespace.").option("--if-exists <strategy>", "Duplicate handling: overwrite, skip, or fail.").option("--create-index", "Create the Vectorize index if missing.").option("--dry-run", "Plan the migration without writing records.").option("--json", "Print structured JSON output.").action(async (...e) => {
+		let { positionals: n, options: r } = Ze(e), i = n[0], a = n.length === 0 ? [] : Array.isArray(i) ? i.map((e) => String(e)) : n.map((e) => String(e)), o = await xe({
+			service: await X({
+				pluginConfig: t.pluginConfig,
+				openClawConfig: t.openClawConfig,
+				env: process.env,
+				resolvePath: t.resolvePath
+			}),
+			options: {
+				sourcePaths: a,
+				workspaceDir: r.workspace,
+				namespace: r.namespace,
+				namespaceStrategy: r.deriveNamespaceFromPath ? "path" : "single-target",
+				duplicateStrategy: Qe(r.ifExists),
+				dryRun: !!r.dryRun,
+				createIndexIfMissing: !!r.createIndex
+			}
+		});
+		r.json ? Z(o) : console.log(Se(o)), o.failed > 0 && (process.exitCode = 1);
+	});
+}
+//#endregion
+//#region src/prompt.ts
+var et = ({ availableTools: e }) => {
+	let t = ["Cloudflare memory is available through Vectorize semantic search and Workers AI embeddings.", "Use the memory tools for recalling past facts, preferences, and durable notes before asking repetitive follow-up questions."];
+	return e.has("cloudflare_memory_upsert") && t.push("When the user wants something remembered long-term, store it with cloudflare_memory_upsert."), e.has("cloudflare_memory_search") && t.push("Use cloudflare_memory_search to retrieve prior memories by semantic similarity or metadata filters."), t;
+};
+//#endregion
+//#region src/public-artifacts.ts
+function tt(e, t) {
+	return { async listArtifacts({ cfg: n }) {
+		let i = (await X({
+			pluginConfig: e,
+			openClawConfig: n,
+			env: process.env,
+			resolvePath: t
+		})).config;
+		try {
+			await r(i.companionStorePath);
+		} catch {
+			return [];
+		}
+		return [{
+			kind: "cloudflare-companion-store",
+			workspaceDir: d(i.companionStorePath),
+			relativePath: i.companionStorePath.split(/[/\\]/).at(-1) ?? "companion-store.json",
+			absolutePath: i.companionStorePath,
+			agentIds: [],
+			contentType: "json"
+		}];
+	} };
+}
+//#endregion
+//#region src/search-manager.ts
+var nt = class {
+	constructor(e, t) {
+		this.service = e, this.agentId = t;
+	}
+	async search(e, t) {
+		return (await this.service.search({
+			query: e,
+			maxResults: t?.maxResults,
+			minScore: t?.minScore,
+			sessionKey: t?.sessionKey,
+			agentId: this.agentId
+		})).map((t) => ({
+			path: t.path,
+			startLine: 1,
+			endLine: Math.max(1, t.text.split(/\r?\n/).length),
+			score: t.score,
+			snippet: Ue(t.text, e),
+			source: "memory",
+			citation: t.path
+		}));
+	}
+	async readFile(e) {
+		let t = He(e.relPath);
+		if (!t) throw Error(`Unsupported memory lookup path: ${e.relPath}`);
+		let n = await this.service.get({
+			id: t.logicalId,
+			namespace: t.namespace,
+			agentId: this.agentId
+		});
+		if (!n) throw Error(`Memory record not found for ${e.relPath}`);
+		let r = Math.max(1, e.from ?? 1), i = Math.max(1, e.lines ?? n.text.split(/\r?\n/).length);
+		return {
+			text: n.text.split(/\r?\n/).slice(r - 1, r - 1 + i).join("\n"),
+			path: n.path
+		};
+	}
+	status() {
+		return {
+			backend: "builtin",
+			provider: "cloudflare-vectorize",
+			model: this.service.config.model,
+			workspaceDir: this.service.config.companionStorePath,
+			custom: {
+				indexName: this.service.config.indexName,
+				storageMode: this.service.config.storageMode,
+				fixedNamespace: this.service.config.fixedNamespace
+			}
+		};
+	}
+	async probeEmbeddingAvailability() {
+		try {
+			return await this.service.embeddings.probeDimensions(), { ok: !0 };
+		} catch (e) {
+			return {
+				ok: !1,
+				error: e instanceof Error ? e.message : "Embedding probe failed."
+			};
+		}
+	}
+	async probeVectorAvailability() {
+		try {
+			return await this.service.vectorize.describeIndex(), !0;
+		} catch {
+			return !1;
+		}
+	}
+	async close() {}
+};
+//#endregion
+//#region src/runtime.ts
+function rt(e) {
+	let t = /* @__PURE__ */ new Map();
+	async function n(n, r) {
+		let i = await X({
+			pluginConfig: e.pluginConfig,
+			openClawConfig: n,
+			env: process.env,
+			resolvePath: e.resolvePath
+		}), a = `${r}::${i.config.indexName}::${i.config.storageMode}`, o = t.get(a);
+		if (o) return o;
+		let s = new nt(i, r);
+		return t.set(a, s), s;
+	}
+	return {
+		async getMemorySearchManager(e) {
+			try {
+				return { manager: await n(e.cfg, e.agentId) };
+			} catch (e) {
+				return {
+					manager: null,
+					error: e instanceof Error ? e.message : "Unable to create Cloudflare memory manager."
+				};
+			}
+		},
+		resolveMemoryBackendConfig() {
+			return { backend: "builtin" };
+		},
+		async closeAllMemorySearchManagers() {
+			await Promise.all([...t.values()].map((e) => e.close?.())), t.clear();
+		}
+	};
+}
+//#endregion
+//#region src/tools.ts
+async function Q(e, t) {
+	let n = t.runtimeConfig ?? t.config;
+	if (!n) throw Error("Cloudflare memory tools require an OpenClaw runtime config.");
+	return X({
+		pluginConfig: e,
+		openClawConfig: n,
+		env: process.env
+	});
+}
+function it(e, t) {
+	if (!e) return;
+	let n = JSON.parse(e);
+	if (!n || typeof n != "object" || Array.isArray(n)) throw Error(`${t} must be a JSON object.`);
+	return n;
+}
+var at = v.Union([
+	v.String(),
+	v.Number(),
+	v.Boolean()
+]);
+function $(e, t) {
+	return {
+		content: [{
+			type: "text",
+			text: e
+		}],
+		details: t
+	};
+}
+function ot(e, t) {
+	return {
+		name: "cloudflare_memory_search",
+		label: "Cloudflare Memory Search",
+		description: "Search Cloudflare-backed memory records using semantic retrieval.",
+		parameters: v.Object({
+			query: v.String({ description: "Semantic search query." }),
+			namespace: v.Optional(v.String({ description: "Optional namespace override." })),
+			maxResults: v.Optional(v.Number({ description: "Maximum results to return." })),
+			minScore: v.Optional(v.Number({ description: "Minimum similarity score from 0 to 1." })),
+			filterJson: v.Optional(v.String({ description: "Optional JSON object for Vectorize metadata filtering." }))
+		}),
+		async execute(n, r, i, a) {
+			let o = await Q(e, t), s = it(r.filterJson, "filterJson"), c = await o.search({
+				query: r.query,
+				namespace: r.namespace,
+				maxResults: r.maxResults,
+				minScore: r.minScore,
+				filter: s,
+				sessionKey: t.sessionKey,
+				agentId: t.agentId,
+				workspaceDir: t.workspaceDir
+			});
+			return c.length === 0 ? $("No matching memories found.", {
+				count: 0,
+				records: []
+			}) : $(c.map((e, t) => `${t + 1}. [${e.namespace}] ${e.title ?? e.logicalId} (${e.score.toFixed(3)})\n${e.text}`).join("\n\n"), {
+				count: c.length,
+				records: c.map((e) => ({
+					id: e.logicalId,
+					namespace: e.namespace,
+					title: e.title,
+					score: e.score,
+					path: e.path
+				}))
+			});
+		}
+	};
+}
+function st(e, t) {
+	return {
+		name: "cloudflare_memory_get",
+		label: "Cloudflare Memory Get",
+		description: "Get a Cloudflare-backed memory record by id.",
+		parameters: v.Object({
+			id: v.String({ description: "Logical memory record id." }),
+			namespace: v.Optional(v.String({ description: "Optional namespace override." }))
+		}),
+		async execute(n, r, i, a) {
+			let o = await (await Q(e, t)).get({
+				id: r.id,
+				namespace: r.namespace,
+				sessionKey: t.sessionKey,
+				agentId: t.agentId,
+				workspaceDir: t.workspaceDir
+			});
+			return o ? $(`${o.title ?? o.logicalId}\nNamespace: ${o.namespace}\nPath: ${o.path}\n\n${o.text}`, {
+				found: !0,
+				id: o.logicalId,
+				namespace: o.namespace,
+				metadata: o.metadata
+			}) : $("Memory record not found.", { found: !1 });
+		}
+	};
+}
+function ct(e, t) {
+	return {
+		name: "cloudflare_memory_upsert",
+		label: "Cloudflare Memory Upsert",
+		description: "Insert or update a Cloudflare-backed memory record.",
+		parameters: v.Object({
+			id: v.Optional(v.String({ description: "Optional stable logical id." })),
+			title: v.Optional(v.String({ description: "Optional title." })),
+			text: v.String({ description: "Memory text to store." }),
+			namespace: v.Optional(v.String({ description: "Optional namespace override." })),
+			source: v.Optional(v.String({ description: "Optional source label." })),
+			metadata: v.Optional(v.Record(v.String(), at, { description: "Flat metadata object with string, number, or boolean values." }))
+		}),
+		async execute(n, r, i, a) {
+			let o = await (await Q(e, t)).upsert({
+				input: {
+					id: r.id,
+					title: r.title,
+					text: r.text,
+					namespace: r.namespace,
+					source: r.source,
+					metadata: r.metadata
+				},
+				sessionKey: t.sessionKey,
+				agentId: t.agentId,
+				workspaceDir: t.workspaceDir
+			});
+			return $(`Stored memory ${o.logicalId} in namespace ${o.namespace}.`, {
+				id: o.logicalId,
+				namespace: o.namespace,
+				path: o.path,
+				mutationId: o.mutationId
+			});
+		}
+	};
+}
+function lt(e, t) {
+	return {
+		name: "cloudflare_memory_delete",
+		label: "Cloudflare Memory Delete",
+		description: "Delete a Cloudflare-backed memory record by id.",
+		parameters: v.Object({
+			id: v.String({ description: "Logical memory record id." }),
+			namespace: v.Optional(v.String({ description: "Optional namespace override." }))
+		}),
+		async execute(n, r, i, a) {
+			let o = await (await Q(e, t)).delete({
+				id: r.id,
+				namespace: r.namespace,
+				sessionKey: t.sessionKey,
+				agentId: t.agentId,
+				workspaceDir: t.workspaceDir
+			});
+			return $(`Deleted memory ${r.id}.`, { mutationId: o });
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+function ut() {
+	return {
+		id: "cloudflare-workers-ai",
+		defaultModel: N,
+		transport: "remote",
+		allowExplicitWhenConfiguredAuto: !0,
+		async create(e) {
+			let t = await W({
+				pluginConfig: Pe(e.config),
+				openClawConfig: e.config,
+				env: process.env
+			}), n = new qe({
+				...t,
+				model: e.model || t.model,
+				workersAiBaseUrl: e.remote?.baseUrl && e.remote.baseUrl.trim().length > 0 ? e.remote.baseUrl : t.workersAiBaseUrl,
+				apiToken: typeof e.remote?.apiKey == "string" && e.remote.apiKey.trim().length > 0 ? e.remote.apiKey : t.apiToken
+			}, e.config);
+			return {
+				provider: {
+					id: "cloudflare-workers-ai",
+					model: e.model || t.model,
+					embedQuery: (e) => n.embeddings.embedQuery(e),
+					embedBatch: (e) => n.embeddings.embedBatch(e)
+				},
+				runtime: {
+					id: "cloudflare-workers-ai",
+					cacheKeyData: {
+						accountId: t.accountId,
+						model: e.model || t.model
+					}
+				}
+			};
+		}
+	};
+}
+var dt = e({
+	id: T,
+	name: Ce,
+	description: we,
+	kind: "memory",
+	configSchema: z,
+	register(e) {
+		z.parse?.(e.pluginConfig ?? {}), e.registerMemoryEmbeddingProvider(ut()), e.registerMemoryCapability({
+			promptBuilder: et,
+			runtime: rt({
+				pluginConfig: e.pluginConfig,
+				resolvePath: e.resolvePath
+			}),
+			publicArtifacts: tt(e.pluginConfig, e.resolvePath)
+		}), e.registerTool((t) => ot(e.pluginConfig, t), { names: ["cloudflare_memory_search"] }), e.registerTool((t) => st(e.pluginConfig, t), { names: ["cloudflare_memory_get"] }), e.registerTool((t) => ct(e.pluginConfig, t), { names: ["cloudflare_memory_upsert"] }), e.registerTool((t) => lt(e.pluginConfig, t), { names: ["cloudflare_memory_delete"] }), e.registerCli(({ program: t }) => {
+			$e(t, {
+				pluginConfig: e.pluginConfig,
+				openClawConfig: e.config,
+				resolvePath: e.resolvePath
+			});
+		}, { descriptors: [{
+			name: "cf-memory",
+			description: "Manage Cloudflare Vectorize memory",
+			hasSubcommands: !0
+		}] }), W({
+			pluginConfig: e.pluginConfig,
+			openClawConfig: e.config,
+			env: process.env,
+			resolvePath: e.resolvePath
+		}).then((t) => {
+			e.logger.info(`${T}: registered for index ${t.indexName} using model ${t.model}.`);
+		}).catch((t) => {
+			let n = t instanceof Error ? t.message : "Unknown configuration error.";
+			e.logger.warn(`${T}: deferred config validation reported: ${n}`);
+		});
+	}
+});
+//#endregion
+export { dt as default };
+
+//# sourceMappingURL=index.js.map