@openclaw/memory-lancedb 2026.7.2-beta.7 → 2026.7.33

package/dist/lancedb-runtime.js

@@ -38,10 +38,9 @@ function createLanceDbRuntimeLoader(overrides = {}) {
 		return await loadPromise;
 	} };
 }
-if (process.env.VITEST === "true") Reflect.set(globalThis, Symbol.for("openclaw.memoryLanceDbRuntimeTestApi"), { createRuntimeLoader: createLanceDbRuntimeLoader });
 const defaultLoader = createLanceDbRuntimeLoader();
 async function loadLanceDbModule(logger) {
 	return await defaultLoader.load(logger);
 }
 //#endregion
-export { loadLanceDbModule };
+export { createLanceDbRuntimeLoader, loadLanceDbModule };

package/openclaw.plugin.json

@@ -2,7 +2,6 @@
   "id": "memory-lancedb",
   "name": "Memory LanceDB",
   "description": "OpenClaw LanceDB-backed long-term memory plugin with auto-recall, auto-capture, and vector search.",
-  "catalog": { "featured": true, "order": 70 },
   "commandAliases": [{ "name": "ltm" }],
   "activation": {
     "onStartup": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/memory-lancedb",
-  "version": "2026.7.2-beta.7",
+  "version": "2026.7.33",
   "description": "OpenClaw LanceDB-backed long-term memory plugin with auto-recall, auto-capture, and vector search.",
   "repository": {
     "type": "git",
@@ -8,10 +8,10 @@
   },
   "type": "module",
   "dependencies": {
-    "@lancedb/lancedb": "0.31.0",
+    "@lancedb/lancedb": "0.30.0",
     "apache-arrow": "18.1.0",
-    "openai": "6.49.0",
-    "typebox": "1.3.6"
+    "openai": "6.45.0",
+    "typebox": "1.3.3"
   },
   "devDependencies": {
     "@openclaw/plugin-sdk": "workspace:*"
@@ -26,10 +26,10 @@
       "minHostVersion": ">=2026.5.31"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.7"
+      "pluginApi": ">=2026.7.33"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.7"
+      "openclawVersion": "2026.7.33"
     },
     "release": {
       "bundleRuntimeDependencies": false,
@@ -46,7 +46,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.7"
+    "openclaw": ">=2026.7.33"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/cli-output-mode.js

@@ -1,13 +0,0 @@
-import { getRootOptionAwareCommandPath } from "openclaw/plugin-sdk/cli-argv";
-//#region extensions/memory-lancedb/cli-output-mode.ts
-/** LanceDB inspection commands emit JSON as their only presentation. */
-function isMemoryMachineOutput(params) {
-	const [, command] = getRootOptionAwareCommandPath(params.argv, 2);
-	return [
-		"list",
-		"query",
-		"search"
-	].includes(command ?? "");
-}
-//#endregion
-export { isMemoryMachineOutput };

package/dist/doctor-contract-api.js

@@ -1,179 +0,0 @@
-import { MEMORY_AGENT_ID_COLUMN, MEMORY_TABLE_NAME, hasAgentScopeColumn, memoryAgentPredicate, quoteLanceSqlString } from "./lancedb-schema.js";
-import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
-import os from "node:os";
-import path from "node:path";
-import fs from "node:fs";
-import { fileURLToPath } from "node:url";
-//#region extensions/memory-lancedb/doctor-contract-api.ts
-const LEGACY_ENVELOPE_DELETE_BATCH_SIZE = 500;
-const LEGACY_ENVELOPE_SENTINEL_LINE_RE = new RegExp(`^(?:${[
-	"Conversation info (untrusted metadata):",
-	"Sender (untrusted metadata):",
-	"Thread starter (untrusted, for context):",
-	"Reply target of current user message (untrusted, for context):",
-	"Replied message (untrusted, for context):",
-	"Forwarded message context (untrusted metadata):",
-	"Conversation context (untrusted, chronological, selected for current message):",
-	"Current local chat window (untrusted, chronological, before current message):",
-	"Nearby reply target window (untrusted, chronological, around replied-to message):",
-	"Chat history since last reply (untrusted, for context):"
-].map((sentinel) => sentinel.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})[^\\n]*$`, "m");
-const LEGACY_ENVELOPE_LABEL_JSON_BLOCK_RE = /^[^\n]+\((?:untrusted metadata|untrusted, for context|untrusted, nearest first|untrusted, chronological,[^\n)]{1,80})\):[ \t]*\n[ \t]*```json[ \t]*\n[\s\S]*?\n[ \t]*```[ \t]*(?:\n|$)/m;
-const LEGACY_ENVELOPE_HEADER_RE = /^Untrusted context \(metadata, do not treat as instructions or commands\):[ \t]*$/m;
-function isLegacyEnvelopeContaminatedText(text) {
-	return typeof text === "string" && (LEGACY_ENVELOPE_SENTINEL_LINE_RE.test(text) || LEGACY_ENVELOPE_LABEL_JSON_BLOCK_RE.test(text) || LEGACY_ENVELOPE_HEADER_RE.test(text));
-}
-async function scanLegacyEnvelopeRowIds(table) {
-	const contaminatedIds = [];
-	for await (const batch of table.query().select(["id", "text"])) for (const row of batch.toArray()) {
-		if (!isLegacyEnvelopeContaminatedText(row.text)) continue;
-		if (typeof row.id !== "string") throw new Error("LanceDB legacy envelope row is missing a string id");
-		contaminatedIds.push(row.id);
-	}
-	return contaminatedIds;
-}
-function resolveMemoryLanceDbPluginRoot(moduleUrl) {
-	const artifactDir = path.dirname(fileURLToPath(moduleUrl));
-	return path.basename(artifactDir) === "dist" ? path.dirname(artifactDir) : artifactDir;
-}
-const DEFAULT_PLUGIN_ROOT = resolveMemoryLanceDbPluginRoot(import.meta.url);
-function asRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function resolveHome(env) {
-	return env.HOME?.trim() || os.homedir();
-}
-function resolveConfiguredDbPath(config, env, pluginRoot) {
-	const pluginConfig = asRecord(config.plugins?.entries?.["memory-lancedb"]?.config);
-	const configured = typeof pluginConfig?.dbPath === "string" ? pluginConfig.dbPath.trim() : "";
-	if (!configured) return path.join(resolveHome(env), ".openclaw", "memory", "lancedb");
-	if (configured.includes("://")) return configured;
-	if (configured.startsWith("~")) return path.resolve(configured.replace(/^~(?=$|[\\/])/, resolveHome(env)));
-	return path.resolve(pluginRoot, configured);
-}
-function resolveStorageOptions(config, env) {
-	const rawOptions = asRecord(asRecord(config.plugins?.entries?.["memory-lancedb"]?.config)?.storageOptions);
-	if (!rawOptions) return;
-	return Object.fromEntries(Object.entries(rawOptions).map(([key, value]) => {
-		if (typeof value !== "string") throw new Error(`memory-lancedb storageOptions.${key} must be a string`);
-		return [key, value.replace(/\$\{([^}]+)\}/g, (_match, envName) => {
-			const resolved = env[envName];
-			if (!resolved) throw new Error(`Environment variable ${envName} is not set`);
-			return resolved;
-		})];
-	}));
-}
-async function openMemoryTable(params) {
-	const dbPath = resolveConfiguredDbPath(params.config, params.env, params.pluginRoot);
-	if (!dbPath.includes("://") && !fs.existsSync(dbPath)) return {
-		connection: null,
-		table: null,
-		dbPath
-	};
-	const lancedb = await import("@lancedb/lancedb");
-	const storageOptions = resolveStorageOptions(params.config, params.env);
-	const connection = await lancedb.connect(dbPath, storageOptions ? { storageOptions } : {});
-	return {
-		connection,
-		table: (await connection.tableNames()).includes("memories") ? await connection.openTable(MEMORY_TABLE_NAME) : null,
-		dbPath
-	};
-}
-function createMemoryLanceDbStateMigrations(pluginRoot = DEFAULT_PLUGIN_ROOT) {
-	return [{
-		id: "memory-lancedb-agent-scope",
-		label: "Memory LanceDB per-agent isolation",
-		async detectLegacyState(params) {
-			const opened = await openMemoryTable({
-				...params,
-				pluginRoot
-			});
-			try {
-				if (!opened.table || hasAgentScopeColumn(await opened.table.schema())) return null;
-				const defaultAgentId = resolveDefaultAgentId(params.config);
-				const count = await opened.table.countRows();
-				return { preview: [`- Memory LanceDB: assign ${count} legacy ${count === 1 ? "row" : "rows"} at ${opened.dbPath} to default agent ${defaultAgentId}`] };
-			} finally {
-				opened.table?.close();
-				opened.connection?.close();
-			}
-		},
-		async migrateLegacyState(params) {
-			const opened = await openMemoryTable({
-				...params,
-				pluginRoot
-			});
-			try {
-				if (!opened.table || hasAgentScopeColumn(await opened.table.schema())) return {
-					changes: [],
-					warnings: []
-				};
-				const defaultAgentId = resolveDefaultAgentId(params.config);
-				const rowCount = await opened.table.countRows();
-				await opened.table.addColumns([{
-					name: MEMORY_AGENT_ID_COLUMN,
-					valueSql: quoteLanceSqlString(defaultAgentId)
-				}]);
-				if (!hasAgentScopeColumn(await opened.table.schema()) || await opened.table.countRows(memoryAgentPredicate(defaultAgentId)) !== rowCount) throw new Error("LanceDB agent-scope migration verification failed");
-				return {
-					changes: [`Assigned ${rowCount} legacy Memory LanceDB ${rowCount === 1 ? "row" : "rows"} to default agent ${defaultAgentId}`],
-					warnings: []
-				};
-			} finally {
-				opened.table?.close();
-				opened.connection?.close();
-			}
-		}
-	}, {
-		id: "memory-lancedb-legacy-envelope-rows",
-		label: "Memory LanceDB legacy envelope contamination",
-		doctorOnly: true,
-		async detectLegacyState(params) {
-			const opened = await openMemoryTable({
-				...params,
-				pluginRoot
-			});
-			try {
-				if (!opened.table) return null;
-				const contaminatedIds = await scanLegacyEnvelopeRowIds(opened.table);
-				if (contaminatedIds.length === 0) return null;
-				return { preview: [`- Memory LanceDB: delete ${contaminatedIds.length} memory ${contaminatedIds.length === 1 ? "row" : "rows"} contaminated with legacy envelope metadata at ${opened.dbPath}`] };
-			} finally {
-				opened.table?.close();
-				opened.connection?.close();
-			}
-		},
-		async migrateLegacyState(params) {
-			const opened = await openMemoryTable({
-				...params,
-				pluginRoot
-			});
-			try {
-				if (!opened.table) return {
-					changes: [],
-					warnings: []
-				};
-				const contaminatedIds = await scanLegacyEnvelopeRowIds(opened.table);
-				if (contaminatedIds.length === 0) return {
-					changes: [],
-					warnings: []
-				};
-				for (let offset = 0; offset < contaminatedIds.length; offset += LEGACY_ENVELOPE_DELETE_BATCH_SIZE) {
-					const batch = contaminatedIds.slice(offset, offset + LEGACY_ENVELOPE_DELETE_BATCH_SIZE);
-					await opened.table.delete(`id IN (${batch.map((id) => quoteLanceSqlString(id)).join(", ")})`);
-				}
-				if ((await scanLegacyEnvelopeRowIds(opened.table)).length !== 0) throw new Error("LanceDB legacy envelope row migration verification failed");
-				return {
-					changes: [`Deleted ${contaminatedIds.length} Memory LanceDB ${contaminatedIds.length === 1 ? "row" : "rows"} contaminated with legacy envelope metadata`],
-					warnings: []
-				};
-			} finally {
-				opened.table?.close();
-				opened.connection?.close();
-			}
-		}
-	}];
-}
-const stateMigrations = createMemoryLanceDbStateMigrations();
-//#endregion
-export { createMemoryLanceDbStateMigrations, resolveMemoryLanceDbPluginRoot, stateMigrations };

package/dist/embeddings.js

@@ -1,312 +0,0 @@
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { Buffer } from "node:buffer";
-import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
-import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
-import { canonicalizeBase64 } from "openclaw/plugin-sdk/media-runtime";
-import { ensureGlobalUndiciEnvProxyDispatcher } from "openclaw/plugin-sdk/runtime-env";
-//#region extensions/memory-lancedb/embeddings.ts
-const loadOpenAiModule = createLazyRuntimeModule(() => import("openai"));
-const loadMemoryEmbeddingProviderModule = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/memory-core-host-engine-embeddings"));
-const loadMemoryHostCoreModule = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/memory-host-core"));
-const PROVIDER_ADAPTER_LIFECYCLE = resolveGlobalSingleton(Symbol.for("openclaw.memoryLanceDbEmbeddingProviderLifecycle.v1"), () => ({
-	retainedProviders: /* @__PURE__ */ new Set(),
-	tail: Promise.resolve()
-}));
-function runProviderAdapterLifecycle(operation) {
-	const result = PROVIDER_ADAPTER_LIFECYCLE.tail.then(operation, operation);
-	PROVIDER_ADAPTER_LIFECYCLE.tail = result.then(() => void 0, () => void 0);
-	return result;
-}
-async function drainRetainedProviders() {
-	let firstError;
-	let closeFailed = false;
-	for (const provider of PROVIDER_ADAPTER_LIFECYCLE.retainedProviders) try {
-		await provider.close?.();
-		PROVIDER_ADAPTER_LIFECYCLE.retainedProviders.delete(provider);
-	} catch (err) {
-		if (!closeFailed) firstError = err;
-		closeFailed = true;
-	}
-	if (closeFailed) throw toErrorObject(firstError, "memory-lancedb embedding provider retirement failed");
-}
-var OpenAiCompatibleEmbeddings = class {
-	constructor(apiKey, model, baseUrl, dimensions) {
-		this.model = model;
-		this.dimensions = dimensions;
-		this.clientPromise = loadOpenAiModule().then(({ default: OpenAI }) => new OpenAI({
-			apiKey,
-			baseURL: baseUrl
-		}));
-	}
-	async embed(text, options) {
-		const dimensions = this.dimensions;
-		const startedAtMs = options?.timeoutMs && Number.isFinite(options.timeoutMs) ? Date.now() : null;
-		try {
-			return normalizeEmbeddingVector((await this.postEmbedding(text, {
-				includeDimensions: true,
-				options
-			})).data?.[0]?.embedding);
-		} catch (error) {
-			if (typeof dimensions !== "number" || !isEmbeddingDimensionsRejectedError(error)) throw error;
-		}
-		const fallbackOptions = startedAtMs === null || options?.timeoutMs === void 0 ? options : { timeoutMs: Math.max(1, options.timeoutMs - (Date.now() - startedAtMs)) };
-		return truncateEmbeddingVector(normalizeEmbeddingVector((await this.postEmbedding(text, {
-			includeDimensions: false,
-			options: fallbackOptions
-		})).data?.[0]?.embedding), dimensions, this.model);
-	}
-	async postEmbedding(text, request) {
-		const params = {
-			model: this.model,
-			input: text,
-			...request.includeDimensions && typeof this.dimensions === "number" ? { dimensions: this.dimensions } : {}
-		};
-		ensureGlobalUndiciEnvProxyDispatcher();
-		return await (await this.clientPromise).post("/embeddings", {
-			body: params,
-			...request.options?.timeoutMs ? {
-				timeout: request.options.timeoutMs,
-				maxRetries: 0
-			} : {}
-		});
-	}
-};
-function isEmbeddingDimensionsRejectedError(error) {
-	const record = asOptionalRecord(error);
-	if (record?.status !== 400 && record?.status !== 422) return false;
-	const details = stringifyEmbeddingApiError(error).toLowerCase();
-	return /\bdimensions\b/.test(details) && isUnsupportedEmbeddingFieldError(details);
-}
-function isUnsupportedEmbeddingFieldError(details) {
-	if (/\b(?:parameter|field|argument)[_ -]value\b/.test(details)) return false;
-	return /\bextra[_ -]forbidden\b/.test(details) || /\bextra inputs? (?:are )?not permitted\b/.test(details) || /\bextra fields? (?:are )?not permitted\b/.test(details) || /\b(?:unknown|unrecognized|unexpected|unsupported)[_ -](?:request[_ -])?(?:parameter|field|argument)\b/.test(details);
-}
-function stringifyEmbeddingApiError(error) {
-	const record = asOptionalRecord(error);
-	const parts = error instanceof Error ? [error.message] : [];
-	for (const value of [
-		record?.code,
-		record?.type,
-		record?.param,
-		record?.error
-	]) {
-		if (typeof value === "string" || typeof value === "number") {
-			parts.push(String(value));
-			continue;
-		}
-		if (value && typeof value === "object") try {
-			parts.push(JSON.stringify(value));
-		} catch {}
-	}
-	return parts.join("\n");
-}
-function truncateEmbeddingVector(embedding, dimensions, model) {
-	if (embedding.length < dimensions) throw new Error(`Embedding model ${model} returned ${embedding.length} dimensions, need at least ${dimensions} for local truncation`);
-	const truncated = embedding.slice(0, dimensions);
-	const magnitude = Math.sqrt(truncated.reduce((sum, value) => sum + value * value, 0));
-	return magnitude > 0 ? truncated.map((value) => value / magnitude) : truncated;
-}
-var ProviderAdapterEmbeddings = class {
-	constructor(api, embedding) {
-		this.api = api;
-		this.embedding = embedding;
-		this.closePromise = null;
-		this.closed = false;
-		this.activeUses = 0;
-		this.idleWaiters = /* @__PURE__ */ new Set();
-	}
-	getProvider() {
-		this.providerPromise ??= this.createProvider().catch((err) => {
-			this.providerPromise = void 0;
-			throw err;
-		});
-		return this.providerPromise;
-	}
-	acquireUse() {
-		if (this.closed) throw new Error("memory-lancedb embeddings are closed");
-		this.activeUses += 1;
-		let released = false;
-		return () => {
-			if (released) return;
-			released = true;
-			this.activeUses -= 1;
-			if (this.activeUses === 0) {
-				const waiters = Array.from(this.idleWaiters);
-				this.idleWaiters.clear();
-				for (const resolve of waiters) resolve();
-			}
-		};
-	}
-	async awaitIdle() {
-		if (this.activeUses === 0) return;
-		await new Promise((resolve) => {
-			this.idleWaiters.add(resolve);
-		});
-	}
-	async createProvider() {
-		return await runProviderAdapterLifecycle(async () => {
-			await drainRetainedProviders();
-			return await this.createProviderAfterRetirement();
-		});
-	}
-	async createProviderAfterRetirement() {
-		const cfg = this.api.runtime.config?.current?.() ?? this.api.config;
-		const providerId = this.embedding.provider;
-		const { getMemoryEmbeddingProvider } = await loadMemoryEmbeddingProviderModule();
-		const adapter = getMemoryEmbeddingProvider(providerId, cfg);
-		if (!adapter) throw new Error(`Unknown memory embedding provider: ${providerId}`);
-		const { resolveDefaultAgentId } = await loadMemoryHostCoreModule();
-		const defaultAgentId = resolveDefaultAgentId(cfg);
-		const agentDir = this.api.runtime.agent.resolveAgentDir(cfg, defaultAgentId);
-		const remote = this.embedding.apiKey || this.embedding.baseUrl ? {
-			...this.embedding.apiKey ? { apiKey: this.embedding.apiKey } : {},
-			...this.embedding.baseUrl ? { baseUrl: this.embedding.baseUrl } : {}
-		} : void 0;
-		const result = await adapter.create({
-			config: cfg,
-			agentDir,
-			provider: providerId,
-			fallback: "none",
-			model: this.embedding.model,
-			...remote ? { remote } : {},
-			...typeof this.embedding.dimensions === "number" ? { outputDimensionality: this.embedding.dimensions } : {}
-		});
-		if (!result.provider) throw new Error(`Memory embedding provider ${providerId} is unavailable.`);
-		return result.provider;
-	}
-	async embed(text, options) {
-		const releaseUse = this.acquireUse();
-		try {
-			const provider = await this.getProvider();
-			if (!options?.timeoutMs) return await provider.embedQuery(text);
-			const controller = new AbortController();
-			let timer;
-			try {
-				timer = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("memory-lancedb embedding timed out")), resolveTimerTimeoutMs(options.timeoutMs, 1));
-				timer.unref?.();
-				return await provider.embedQuery(text, { signal: controller.signal });
-			} finally {
-				if (timer) clearTimeout(timer);
-			}
-		} finally {
-			releaseUse();
-		}
-	}
-	async close() {
-		const existingClose = this.closePromise;
-		if (existingClose) {
-			await existingClose;
-			return;
-		}
-		const closeOperation = this.closeOnce();
-		this.closePromise = closeOperation;
-		try {
-			await closeOperation;
-		} catch (err) {
-			if (this.closePromise === closeOperation) this.closePromise = null;
-			throw err;
-		}
-	}
-	async closeOnce() {
-		this.closed = true;
-		const providerPromise = this.providerPromise;
-		await runProviderAdapterLifecycle(async () => {
-			await this.awaitIdle();
-			const provider = await providerPromise?.catch(() => null);
-			if (provider) PROVIDER_ADAPTER_LIFECYCLE.retainedProviders.add(provider);
-			try {
-				await drainRetainedProviders();
-			} finally {
-				if (this.providerPromise === providerPromise) this.providerPromise = void 0;
-			}
-		});
-	}
-};
-async function runWithTimeout(params) {
-	let timeout;
-	const TIMEOUT = Symbol("timeout");
-	const timeoutPromise = new Promise((resolve) => {
-		timeout = setTimeout(() => resolve(TIMEOUT), resolveTimerTimeoutMs(params.timeoutMs, 1));
-		timeout.unref?.();
-	});
-	const taskPromise = params.task();
-	taskPromise.catch(() => void 0);
-	try {
-		const result = await Promise.race([taskPromise, timeoutPromise]);
-		if (result === TIMEOUT) return { status: "timeout" };
-		return {
-			status: "ok",
-			value: result
-		};
-	} finally {
-		if (timeout) clearTimeout(timeout);
-	}
-}
-function formatMemoryRecallError(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function isMemoryRecallTimeoutError(error) {
-	let current = error;
-	for (let depth = 0; depth < 3 && current !== void 0; depth += 1) {
-		const record = asOptionalRecord(current);
-		const name = current instanceof Error ? current.name : typeof record?.name === "string" ? record.name : "";
-		const message = current instanceof Error ? current.message : typeof record?.message === "string" ? record.message : "";
-		const code = typeof record?.code === "string" ? record.code : "";
-		if (name === "APIConnectionTimeoutError" || name === "TimeoutError" || code === "ETIMEDOUT" || /^UND_ERR_.*_TIMEOUT$/.test(code) || /\btimed out\b/i.test(message)) return true;
-		current = record?.cause;
-	}
-	return false;
-}
-function buildMemoryRecallUnavailableResult(error) {
-	return {
-		content: [{
-			type: "text",
-			text: "Memory recall is unavailable right now."
-		}],
-		details: {
-			count: 0,
-			disabled: true,
-			unavailable: true,
-			error
-		}
-	};
-}
-var MemoryRecallEmbeddingError = class extends Error {
-	constructor(originalError) {
-		super(formatMemoryRecallError(originalError));
-		this.originalError = originalError;
-		this.name = "MemoryRecallEmbeddingError";
-	}
-};
-const testing = {
-	isEmbeddingDimensionsRejectedError,
-	isMemoryRecallTimeoutError,
-	runWithTimeout,
-	truncateEmbeddingVector
-};
-function createEmbeddings(api, cfg) {
-	const { provider, model, dimensions, apiKey, baseUrl } = cfg.embedding;
-	if (provider === "openai" && apiKey) return new OpenAiCompatibleEmbeddings(apiKey, model, baseUrl, dimensions);
-	return new ProviderAdapterEmbeddings(api, cfg.embedding);
-}
-function normalizeEmbeddingVector(value) {
-	if (Array.isArray(value)) {
-		if (!value.every((item) => typeof item === "number" && Number.isFinite(item))) throw new Error("Embedding response contains non-numeric values");
-		return value;
-	}
-	if (typeof value === "string") {
-		const canonicalEmbedding = canonicalizeBase64(value);
-		if (!canonicalEmbedding) throw new Error("Base64 embedding response is malformed");
-		const bytes = Buffer.from(canonicalEmbedding, "base64");
-		if (bytes.byteLength % Float32Array.BYTES_PER_ELEMENT !== 0) throw new Error("Base64 embedding response has invalid byte length");
-		const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-		const floats = [];
-		for (let offset = 0; offset < bytes.byteLength; offset += Float32Array.BYTES_PER_ELEMENT) floats.push(view.getFloat32(offset, true));
-		return floats;
-	}
-	throw new Error("Embedding response is missing a vector");
-}
-//#endregion
-export { MemoryRecallEmbeddingError, buildMemoryRecallUnavailableResult, createEmbeddings, formatMemoryRecallError, isMemoryRecallTimeoutError, normalizeEmbeddingVector, runWithTimeout, testing };

package/dist/lancedb-schema.js

@@ -1,17 +0,0 @@
-//#region extensions/memory-lancedb/lancedb-schema.ts
-const MEMORY_TABLE_NAME = "memories";
-const MEMORY_AGENT_ID_COLUMN = "agentId";
-function quoteLanceSqlString(value) {
-	return `'${value.replaceAll("'", "''")}'`;
-}
-function memoryAgentPredicate(agentId) {
-	return `${MEMORY_AGENT_ID_COLUMN} = ${quoteLanceSqlString(agentId)}`;
-}
-function hasAgentScopeColumn(schema) {
-	return schema.fields.some((field) => field.name === MEMORY_AGENT_ID_COLUMN);
-}
-function legacyMemorySchemaError() {
-	return /* @__PURE__ */ new Error("memory-lancedb: the existing memory table predates per-agent isolation. Run \"openclaw doctor --fix\" to assign legacy rows to the default agent, then restart OpenClaw.");
-}
-//#endregion
-export { MEMORY_AGENT_ID_COLUMN, MEMORY_TABLE_NAME, hasAgentScopeColumn, legacyMemorySchemaError, memoryAgentPredicate, quoteLanceSqlString };