@openclaw/memory-lancedb 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/config.js

@@ -62,153 +62,84 @@ function resolveEmbeddingDimensions(embedding) {
 	if (dimensions === void 0 || !Number.isInteger(dimensions) || dimensions < 1) throw new Error("embedding.dimensions must be a positive integer");
 	return dimensions;
 }
-const memoryConfigSchema = {
-	parse(value) {
-		if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("memory config required");
-		const cfg = value;
-		assertAllowedKeys(cfg, [
-			"embedding",
-			"dreaming",
-			"dbPath",
-			"autoCapture",
-			"autoRecall",
-			"captureMaxChars",
-			"customTriggers",
-			"recallMaxChars",
-			"storageOptions"
-		], "memory config");
-		const embedding = cfg.embedding;
-		if (!embedding || typeof embedding !== "object" || Array.isArray(embedding)) throw new Error("embedding config required");
-		assertAllowedKeys(embedding, [...EMBEDDING_CONFIG_KEYS], "embedding config");
-		if (Object.keys(embedding).length === 0) throw new Error("embedding config must include at least one setting");
-		const dimensions = resolveEmbeddingDimensions(embedding);
-		const model = resolveEmbeddingModel(embedding, dimensions);
-		const provider = typeof embedding.provider === "string" ? embedding.provider.trim() : "openai";
-		if (!provider) throw new Error("embedding.provider must not be empty");
-		const captureMaxChars = resolveBoundedIntegerConfig({
-			value: cfg.captureMaxChars,
-			fallback: 500,
-			min: 100,
-			max: 1e4,
-			label: "captureMaxChars"
-		});
-		const recallMaxChars = resolveBoundedIntegerConfig({
-			value: cfg.recallMaxChars,
-			fallback: DEFAULT_RECALL_MAX_CHARS,
-			min: 100,
-			max: 1e4,
-			label: "recallMaxChars"
+const memoryConfigSchema = { parse(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("memory config required");
+	const cfg = value;
+	assertAllowedKeys(cfg, [
+		"embedding",
+		"dreaming",
+		"dbPath",
+		"autoCapture",
+		"autoRecall",
+		"captureMaxChars",
+		"customTriggers",
+		"recallMaxChars",
+		"storageOptions"
+	], "memory config");
+	const embedding = cfg.embedding;
+	if (!embedding || typeof embedding !== "object" || Array.isArray(embedding)) throw new Error("embedding config required");
+	assertAllowedKeys(embedding, [...EMBEDDING_CONFIG_KEYS], "embedding config");
+	if (Object.keys(embedding).length === 0) throw new Error("embedding config must include at least one setting");
+	const dimensions = resolveEmbeddingDimensions(embedding);
+	const model = resolveEmbeddingModel(embedding, dimensions);
+	const provider = typeof embedding.provider === "string" ? embedding.provider.trim() : "openai";
+	if (!provider) throw new Error("embedding.provider must not be empty");
+	const captureMaxChars = resolveBoundedIntegerConfig({
+		value: cfg.captureMaxChars,
+		fallback: 500,
+		min: 100,
+		max: 1e4,
+		label: "captureMaxChars"
+	});
+	const recallMaxChars = resolveBoundedIntegerConfig({
+		value: cfg.recallMaxChars,
+		fallback: DEFAULT_RECALL_MAX_CHARS,
+		min: 100,
+		max: 1e4,
+		label: "recallMaxChars"
+	});
+	let customTriggers;
+	if (cfg.customTriggers !== void 0) {
+		if (!Array.isArray(cfg.customTriggers)) throw new Error("customTriggers must be an array of strings");
+		customTriggers = cfg.customTriggers.map((trigger, index) => {
+			if (typeof trigger !== "string") throw new Error(`customTriggers.${index} must be a string`);
+			const normalized = trigger.trim();
+			if (!normalized) throw new Error(`customTriggers.${index} must not be empty`);
+			if (normalized.length > 100) throw new Error(`customTriggers.${index} must be at most 100 characters`);
+			return normalized;
 		});
-		let customTriggers;
-		if (cfg.customTriggers !== void 0) {
-			if (!Array.isArray(cfg.customTriggers)) throw new Error("customTriggers must be an array of strings");
-			customTriggers = cfg.customTriggers.map((trigger, index) => {
-				if (typeof trigger !== "string") throw new Error(`customTriggers.${index} must be a string`);
-				const normalized = trigger.trim();
-				if (!normalized) throw new Error(`customTriggers.${index} must not be empty`);
-				if (normalized.length > 100) throw new Error(`customTriggers.${index} must be at most 100 characters`);
-				return normalized;
-			});
-			if (customTriggers.length > 50) throw new Error("customTriggers must include at most 50 entries");
-		}
-		const dreaming = cfg.dreaming === void 0 ? void 0 : cfg.dreaming && typeof cfg.dreaming === "object" && !Array.isArray(cfg.dreaming) ? cfg.dreaming : (() => {
-			throw new Error("dreaming config must be an object");
-		})();
-		let storageOptions;
-		const storageOpts = cfg.storageOptions;
-		if (storageOpts !== void 0 && storageOpts !== null) {
-			if (!storageOpts || typeof storageOpts !== "object" || Array.isArray(storageOpts)) throw new Error("storageOptions must be an object");
-			storageOptions = {};
-			for (const [key, valueLocal] of Object.entries(storageOpts)) {
-				if (typeof valueLocal !== "string") throw new Error(`storageOptions.${key} must be a string`);
-				storageOptions[key] = resolveEnvVars(valueLocal);
-			}
-		}
-		return {
-			embedding: {
-				provider,
-				model,
-				apiKey: typeof embedding.apiKey === "string" ? resolveEnvVars(embedding.apiKey) : void 0,
-				baseUrl: typeof embedding.baseUrl === "string" ? resolveEnvVars(embedding.baseUrl) : void 0,
-				dimensions
-			},
-			dreaming,
-			dbPath: typeof cfg.dbPath === "string" ? cfg.dbPath : DEFAULT_DB_PATH,
-			autoCapture: cfg.autoCapture === true,
-			autoRecall: cfg.autoRecall !== false,
-			captureMaxChars,
-			...customTriggers ? { customTriggers } : {},
-			recallMaxChars,
-			...storageOptions ? { storageOptions } : {}
-		};
-	},
-	uiHints: {
-		"embedding.provider": {
-			label: "Embedding Provider",
-			placeholder: "openai",
-			help: "Memory embedding provider adapter to use (for example openai, github-copilot, ollama)"
-		},
-		"embedding.apiKey": {
-			label: "OpenAI API Key",
-			sensitive: true,
-			placeholder: "sk-proj-...",
-			help: "Optional API key override for OpenAI-compatible embeddings; omit to use configured provider auth"
-		},
-		"embedding.baseUrl": {
-			label: "Base URL",
-			placeholder: "https://api.openai.com/v1",
-			help: "Optional provider or OpenAI-compatible embedding endpoint base URL",
-			advanced: true
-		},
-		"embedding.dimensions": {
-			label: "Dimensions",
-			placeholder: "1536",
-			help: "Vector dimensions for custom models (required for non-standard models)",
-			advanced: true
-		},
-		"embedding.model": {
-			label: "Embedding Model",
-			placeholder: DEFAULT_MODEL,
-			help: "OpenAI embedding model to use"
-		},
-		dbPath: {
-			label: "Database Path",
-			placeholder: "~/.openclaw/memory/lancedb",
-			advanced: true,
-			help: "Local filesystem path or cloud storage URI (s3://, gs://) for LanceDB database"
-		},
-		autoCapture: {
-			label: "Auto-Capture",
-			help: "Automatically capture important information from conversations"
-		},
-		autoRecall: {
-			label: "Auto-Recall",
-			help: "Automatically inject relevant memories into context"
-		},
-		captureMaxChars: {
-			label: "Capture Max Chars",
-			help: "Maximum message length eligible for auto-capture",
-			advanced: true,
-			placeholder: String(500)
-		},
-		customTriggers: {
-			label: "Custom Triggers",
-			help: "Literal phrases that should make auto-capture consider a message memory-worthy",
-			advanced: true
-		},
-		recallMaxChars: {
-			label: "Recall Query Max Chars",
-			help: "Maximum prompt/query length embedded for memory recall. Lower for small local embedding models.",
-			advanced: true,
-			placeholder: String(DEFAULT_RECALL_MAX_CHARS)
-		},
-		storageOptions: {
-			label: "Storage Options",
-			sensitive: true,
-			advanced: true,
-			help: "Storage configuration options (access_key, secret_key, endpoint, etc.); supports ${ENV_VAR} values"
+		if (customTriggers.length > 50) throw new Error("customTriggers must include at most 50 entries");
+	}
+	const dreaming = cfg.dreaming === void 0 ? void 0 : cfg.dreaming && typeof cfg.dreaming === "object" && !Array.isArray(cfg.dreaming) ? cfg.dreaming : (() => {
+		throw new Error("dreaming config must be an object");
+	})();
+	let storageOptions;
+	const storageOpts = cfg.storageOptions;
+	if (storageOpts !== void 0 && storageOpts !== null) {
+		if (!storageOpts || typeof storageOpts !== "object" || Array.isArray(storageOpts)) throw new Error("storageOptions must be an object");
+		storageOptions = {};
+		for (const [key, valueLocal] of Object.entries(storageOpts)) {
+			if (typeof valueLocal !== "string") throw new Error(`storageOptions.${key} must be a string`);
+			storageOptions[key] = resolveEnvVars(valueLocal);
 		}
 	}
-};
+	return {
+		embedding: {
+			provider,
+			model,
+			apiKey: typeof embedding.apiKey === "string" ? resolveEnvVars(embedding.apiKey) : void 0,
+			baseUrl: typeof embedding.baseUrl === "string" ? resolveEnvVars(embedding.baseUrl) : void 0,
+			dimensions
+		},
+		dreaming,
+		dbPath: typeof cfg.dbPath === "string" ? cfg.dbPath : DEFAULT_DB_PATH,
+		autoCapture: cfg.autoCapture === true,
+		autoRecall: cfg.autoRecall !== false,
+		captureMaxChars,
+		...customTriggers ? { customTriggers } : {},
+		recallMaxChars,
+		...storageOptions ? { storageOptions } : {}
+	};
+} };
 //#endregion
 export { DEFAULT_CAPTURE_MAX_CHARS, DEFAULT_RECALL_MAX_CHARS, MEMORY_CATEGORIES, memoryConfigSchema, vectorDimsForModel };

package/dist/doctor-contract-api.js

@@ -1,9 +1,10 @@
 import { MEMORY_AGENT_ID_COLUMN, MEMORY_TABLE_NAME, hasAgentScopeColumn, memoryAgentPredicate, quoteLanceSqlString } from "./lancedb-schema.js";
-import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
+import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
 //#region extensions/memory-lancedb/doctor-contract-api.ts
 const LEGACY_ENVELOPE_DELETE_BATCH_SIZE = 500;
 const LEGACY_ENVELOPE_SENTINEL_LINE_RE = new RegExp(`^(?:${[
@@ -37,14 +38,11 @@ function resolveMemoryLanceDbPluginRoot(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 pluginConfig = asOptionalRecord(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;
@@ -52,7 +50,7 @@ function resolveConfiguredDbPath(config, env, pluginRoot) {
 	return path.resolve(pluginRoot, configured);
 }
 function resolveStorageOptions(config, env) {
-	const rawOptions = asRecord(asRecord(config.plugins?.entries?.["memory-lancedb"]?.config)?.storageOptions);
+	const rawOptions = asOptionalRecord(asOptionalRecord(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`);

package/dist/embeddings.js

@@ -1,15 +1,16 @@
+import { formatErrorMessage, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolve } from "node:path";
 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()
@@ -40,7 +41,7 @@ var OpenAiCompatibleEmbeddings = class {
 			baseURL: baseUrl
 		}));
 	}
-	async embed(text, options) {
+	async embed(_agentId, text, options) {
 		const dimensions = this.dimensions;
 		const startedAtMs = options?.timeoutMs && Number.isFinite(options.timeoutMs) ? Date.now() : null;
 		try {
@@ -112,17 +113,51 @@ var ProviderAdapterEmbeddings = class {
 	constructor(api, embedding) {
 		this.api = api;
 		this.embedding = embedding;
+		this.providers = /* @__PURE__ */ new Map();
 		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;
+	getProvider(agentId) {
+		const config = this.api.runtime.config?.current?.() ?? this.api.config;
+		const agentDir = this.api.runtime.agent.resolveAgentDir(config, agentId);
+		const existing = this.providers.get(agentId);
+		if (existing?.config === config && existing.agentDir === agentDir) return existing;
+		if (existing) {
+			this.providers.delete(agentId);
+			this.retireProvider(existing);
+		}
+		const entry = {
+			config,
+			agentDir,
+			promise: this.createProvider(config, agentDir).catch((err) => {
+				if (this.providers.get(agentId) === entry) this.providers.delete(agentId);
+				throw err;
+			}),
+			activeUses: 0,
+			idleWaiters: /* @__PURE__ */ new Set()
+		};
+		this.providers.set(agentId, entry);
+		return entry;
+	}
+	retireProvider(entry) {
+		runProviderAdapterLifecycle(async () => {
+			if (entry.activeUses > 0) await new Promise((resolve) => {
+				entry.idleWaiters.add(resolve);
+			});
+			const provider = await entry.promise.catch(() => null);
+			if (provider) PROVIDER_ADAPTER_LIFECYCLE.retainedProviders.add(provider);
+			await drainRetainedProviders();
+		}).catch(() => void 0);
+	}
+	invalidateProvidersForAuthMutation(event) {
+		const changedAgentDir = event.agentDir ? resolve(event.agentDir) : void 0;
+		for (const [agentId, entry] of this.providers) {
+			if (!event.affectsInheritedStores && resolve(entry.agentDir) !== changedAgentDir) continue;
+			this.providers.delete(agentId);
+			this.retireProvider(entry);
+		}
 	}
 	acquireUse() {
 		if (this.closed) throw new Error("memory-lancedb embeddings are closed");
@@ -145,27 +180,24 @@ var ProviderAdapterEmbeddings = class {
 			this.idleWaiters.add(resolve);
 		});
 	}
-	async createProvider() {
+	async createProvider(config, agentDir) {
 		return await runProviderAdapterLifecycle(async () => {
 			await drainRetainedProviders();
-			return await this.createProviderAfterRetirement();
+			return await this.createProviderAfterRetirement(config, agentDir);
 		});
 	}
-	async createProviderAfterRetirement() {
-		const cfg = this.api.runtime.config?.current?.() ?? this.api.config;
+	async createProviderAfterRetirement(config, agentDir) {
 		const providerId = this.embedding.provider;
-		const { getMemoryEmbeddingProvider } = await loadMemoryEmbeddingProviderModule();
-		const adapter = getMemoryEmbeddingProvider(providerId, cfg);
+		const { getMemoryEmbeddingProvider, registerRuntimeAuthProfileStoreMutationListener } = await loadMemoryEmbeddingProviderModule();
+		if (!this.closed && !this.unregisterAuthMutationListener) this.unregisterAuthMutationListener = registerRuntimeAuthProfileStoreMutationListener((event) => this.invalidateProvidersForAuthMutation(event));
+		const adapter = getMemoryEmbeddingProvider(providerId, config);
 		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,
+			config,
 			agentDir,
 			provider: providerId,
 			fallback: "none",
@@ -176,19 +208,30 @@ var ProviderAdapterEmbeddings = class {
 		if (!result.provider) throw new Error(`Memory embedding provider ${providerId} is unavailable.`);
 		return result.provider;
 	}
-	async embed(text, options) {
+	async embed(agentId, 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;
+			const entry = this.getProvider(normalizeAgentId(agentId));
+			entry.activeUses += 1;
 			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 });
+				const provider = await entry.promise;
+				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 {
-				if (timer) clearTimeout(timer);
+				entry.activeUses -= 1;
+				if (entry.activeUses === 0) {
+					const waiters = Array.from(entry.idleWaiters);
+					entry.idleWaiters.clear();
+					for (const resolve of waiters) resolve();
+				}
 			}
 		} finally {
 			releaseUse();
@@ -211,15 +254,19 @@ var ProviderAdapterEmbeddings = class {
 	}
 	async closeOnce() {
 		this.closed = true;
-		const providerPromise = this.providerPromise;
+		this.unregisterAuthMutationListener?.();
+		this.unregisterAuthMutationListener = void 0;
+		const providers = Array.from(this.providers.entries());
 		await runProviderAdapterLifecycle(async () => {
 			await this.awaitIdle();
-			const provider = await providerPromise?.catch(() => null);
-			if (provider) PROVIDER_ADAPTER_LIFECYCLE.retainedProviders.add(provider);
+			for (const [, entry] of providers) {
+				const provider = await entry.promise.catch(() => null);
+				if (provider) PROVIDER_ADAPTER_LIFECYCLE.retainedProviders.add(provider);
+			}
 			try {
 				await drainRetainedProviders();
 			} finally {
-				if (this.providerPromise === providerPromise) this.providerPromise = void 0;
+				for (const [agentId, entry] of providers) if (this.providers.get(agentId) === entry) this.providers.delete(agentId);
 			}
 		});
 	}
@@ -244,8 +291,17 @@ async function runWithTimeout(params) {
 		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 {
@@ -263,13 +319,14 @@ function buildMemoryRecallUnavailableResult(error) {
 }
 var MemoryRecallEmbeddingError = class extends Error {
 	constructor(originalError) {
-		super(formatMemoryRecallError(originalError));
+		super(formatErrorMessage(originalError));
 		this.originalError = originalError;
 		this.name = "MemoryRecallEmbeddingError";
 	}
 };
 const testing = {
 	isEmbeddingDimensionsRejectedError,
+	isMemoryRecallTimeoutError,
 	runWithTimeout,
 	truncateEmbeddingVector
 };
@@ -296,4 +353,4 @@ function normalizeEmbeddingVector(value) {
 	throw new Error("Embedding response is missing a vector");
 }
 //#endregion
-export { MemoryRecallEmbeddingError, buildMemoryRecallUnavailableResult, createEmbeddings, formatMemoryRecallError, normalizeEmbeddingVector, runWithTimeout, testing };
+export { MemoryRecallEmbeddingError, buildMemoryRecallUnavailableResult, createEmbeddings, isMemoryRecallTimeoutError, normalizeEmbeddingVector, runWithTimeout, testing };

package/dist/index.js

@@ -1,12 +1,13 @@
 import { definePluginEntry } from "./api.js";
 import { MEMORY_CATEGORIES, memoryConfigSchema, vectorDimsForModel } from "./config.js";
-import { MemoryRecallEmbeddingError, buildMemoryRecallUnavailableResult, createEmbeddings, formatMemoryRecallError, normalizeEmbeddingVector, runWithTimeout, testing } from "./embeddings.js";
+import { MemoryRecallEmbeddingError, buildMemoryRecallUnavailableResult, createEmbeddings, isMemoryRecallTimeoutError, normalizeEmbeddingVector, runWithTimeout, testing } from "./embeddings.js";
 import { MemoryDB } from "./lancedb-store.js";
 import { dropMediaNoteLines, looksLikeEnvelopeSludge, sanitizeForMemoryCapture } from "./memory-capture-sanitization.js";
 import { cleanMemorySearchResults, detectCategory, escapeMemoryForPrompt, extractLatestUserText, extractUserTextContent, findCleanDuplicateMemory, formatRelevantMemoriesContext, looksLikePromptInjection, messageFingerprint, normalizeRecallQuery, resolveAutoCaptureStartIndex, shouldCapture } from "./memory-policy.js";
 import { parseMemoryCliFilter, registerMemoryCli } from "./memory-cli.js";
 import { resolveAgentConfig, resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
 import { optionalFiniteNumberSchema, optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { readFiniteNumberParam, readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
 import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
@@ -18,7 +19,7 @@ import { Type } from "typebox";
 const loadMemoryHostCoreModule = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/memory-host-core"));
 const DEFAULT_AUTO_RECALL_TIMEOUT_MS = 15e3;
 const DEFAULT_TOOL_RECALL_TIMEOUT_MS = 15e3;
-const DEFAULT_TOOL_RECALL_COOLDOWN_MS = 6e4;
+const DEFAULT_RECALL_COOLDOWN_MS = 6e4;
 const DEFAULT_TOOL_RECALL_OVERFETCH_EXTRA = 10;
 const DEFAULT_AUTO_RECALL_OVERFETCH_LIMIT = 10;
 const DEFAULT_AUTO_RECALL_RESULT_CAP = 3;
@@ -97,7 +98,7 @@ var memory_lancedb_default = definePluginEntry({
 		};
 		const recordMemoryRecallCooldown = (agentId, error) => {
 			memoryRecallCooldowns.set(agentId, {
-				until: Date.now() + DEFAULT_TOOL_RECALL_COOLDOWN_MS,
+				until: Date.now() + DEFAULT_RECALL_COOLDOWN_MS,
 				error
 			});
 		};
@@ -124,6 +125,7 @@ var memory_lancedb_default = definePluginEntry({
 					const currentCfg = resolveCurrentHookConfig();
 					const cooldown = readMemoryRecallCooldown(agentId);
 					if (cooldown) return buildMemoryRecallUnavailableResult(cooldown.error);
+					let recallPhase = "embedding";
 					let recall;
 					try {
 						recall = await runWithTimeout({
@@ -131,23 +133,24 @@ var memory_lancedb_default = definePluginEntry({
 							task: async () => {
 								let vector;
 								try {
-									vector = await embeddings.embed(normalizeRecallQuery(query, currentCfg.recallMaxChars), { timeoutMs: DEFAULT_TOOL_RECALL_TIMEOUT_MS });
+									vector = await embeddings.embed(agentId, normalizeRecallQuery(query, currentCfg.recallMaxChars), { timeoutMs: DEFAULT_TOOL_RECALL_TIMEOUT_MS });
 								} catch (error) {
 									throw new MemoryRecallEmbeddingError(error);
 								}
+								recallPhase = "search";
 								return await db.search(agentId, vector, limit + DEFAULT_TOOL_RECALL_OVERFETCH_EXTRA, .1);
 							}
 						});
 					} catch (error) {
 						if (!(error instanceof MemoryRecallEmbeddingError)) throw error;
-						const message = formatMemoryRecallError(error.originalError);
-						recordMemoryRecallCooldown(agentId, message);
+						const message = formatErrorMessage(error.originalError);
+						if (isMemoryRecallTimeoutError(error.originalError)) recordMemoryRecallCooldown(agentId, message);
 						api.logger.warn?.(`memory-lancedb: memory_recall failed: ${message}; returning unavailable memory result`);
 						return buildMemoryRecallUnavailableResult(message);
 					}
 					if (recall.status === "timeout") {
 						const message = `memory_recall timed out after ${Math.round(DEFAULT_TOOL_RECALL_TIMEOUT_MS / 1e3)}s`;
-						recordMemoryRecallCooldown(agentId, message);
+						if (recallPhase === "embedding") recordMemoryRecallCooldown(agentId, message);
 						api.logger.warn?.(`memory-lancedb: memory_recall timed out after ${DEFAULT_TOOL_RECALL_TIMEOUT_MS}ms; returning unavailable memory result`);
 						return buildMemoryRecallUnavailableResult(message);
 					}
@@ -225,7 +228,7 @@ var memory_lancedb_default = definePluginEntry({
 							reason: "prompt_injection_detected"
 						}
 					};
-					const vector = await embeddings.embed(text);
+					const vector = await embeddings.embed(agentId, text);
 					const existing = await findCleanDuplicateMemory(db, agentId, vector);
 					if (existing) return {
 						content: [{
@@ -294,7 +297,7 @@ var memory_lancedb_default = definePluginEntry({
 					}
 					if (query) {
 						const currentCfg = resolveCurrentHookConfig();
-						const vector = await embeddings.embed(normalizeRecallQuery(query, currentCfg.recallMaxChars));
+						const vector = await embeddings.embed(agentId, normalizeRecallQuery(query, currentCfg.recallMaxChars));
 						const results = await db.search(agentId, vector, 5, .7);
 						if (results.length === 0) return {
 							content: [{
@@ -352,17 +355,30 @@ var memory_lancedb_default = definePluginEntry({
 			const agentId = resolveEnabledAgentId(ctx.agentId);
 			if (!agentId) return;
 			if (!event.prompt || event.prompt.length < 5) return;
+			const cooldown = readMemoryRecallCooldown(agentId);
+			if (cooldown) {
+				api.logger.debug?.(`memory-lancedb: auto-recall skipped during recall cooldown: ${cooldown.error}`);
+				return;
+			}
 			try {
 				const recallQuery = normalizeRecallQuery(dropMediaNoteLines(extractLatestUserText(Array.isArray(event.messages) ? event.messages : []) ?? event.prompt), currentCfg.recallMaxChars);
 				if (!recallQuery) return;
+				let recallPhase = "embedding";
 				const recall = await runWithTimeout({
 					timeoutMs: DEFAULT_AUTO_RECALL_TIMEOUT_MS,
 					task: async () => {
-						const vector = await embeddings.embed(recallQuery, { timeoutMs: DEFAULT_AUTO_RECALL_TIMEOUT_MS });
+						let vector;
+						try {
+							vector = await embeddings.embed(agentId, recallQuery, { timeoutMs: DEFAULT_AUTO_RECALL_TIMEOUT_MS });
+						} catch (error) {
+							throw new MemoryRecallEmbeddingError(error);
+						}
+						recallPhase = "search";
 						return await db.search(agentId, vector, DEFAULT_AUTO_RECALL_OVERFETCH_LIMIT, .3);
 					}
 				});
 				if (recall.status === "timeout") {
+					if (recallPhase === "embedding") recordMemoryRecallCooldown(agentId, `auto-recall timed out after ${Math.round(DEFAULT_AUTO_RECALL_TIMEOUT_MS / 1e3)}s`);
 					api.logger.warn?.(`memory-lancedb: auto-recall timed out after ${DEFAULT_AUTO_RECALL_TIMEOUT_MS}ms; skipping memory injection to avoid stalling agent startup`);
 					return;
 				}
@@ -376,6 +392,7 @@ var memory_lancedb_default = definePluginEntry({
 				if (!context) return;
 				return { prependContext: context };
 			} catch (err) {
+				if (err instanceof MemoryRecallEmbeddingError && isMemoryRecallTimeoutError(err.originalError)) recordMemoryRecallCooldown(agentId, formatErrorMessage(err.originalError));
 				api.logger.warn(`memory-lancedb: recall failed: ${String(err)}`);
 			}
 		});
@@ -404,7 +421,7 @@ var memory_lancedb_default = definePluginEntry({
 							capturableSeen++;
 							if (capturableSeen > 3) continue;
 							const category = detectCategory(sanitized);
-							const vector = await embeddings.embed(sanitized);
+							const vector = await embeddings.embed(agentId, sanitized);
 							if (await findCleanDuplicateMemory(db, agentId, vector)) continue;
 							await db.store(agentId, {
 								text: sanitized,

package/dist/memory-cli.js

@@ -65,8 +65,8 @@ function registerMemoryCli(api, db, embeddings, resolveCliAgentId, recallMaxChar
 			let operationFailed = false;
 			try {
 				const agentId = resolveCliAgentId(opts.agent);
-				const vector = await embeddings.embed(normalizeRecallQuery(query, recallMaxChars));
 				const limit = parsePositiveIntegerOption(opts.limit, "--limit");
+				const vector = await embeddings.embed(agentId, normalizeRecallQuery(query, recallMaxChars));
 				const output = (await db.search(agentId, vector, limit, .3)).map((r) => ({
 					id: r.entry.id,
 					text: r.entry.text,

package/openclaw.plugin.json

@@ -1,5 +1,8 @@
 {
   "id": "memory-lancedb",
+  "doctorContract": {
+    "stateMigrations": true
+  },
   "name": "Memory LanceDB",
   "description": "OpenClaw LanceDB-backed long-term memory plugin with auto-recall, auto-capture, and vector search.",
   "catalog": { "featured": true, "order": 70 },

package/package.json

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