@openclaw/memory-lancedb 2026.5.27 → 2026.5.28-beta.2

package/dist/config.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { parseFiniteNumber } from "openclaw/plugin-sdk/number-runtime";
 //#region extensions/memory-lancedb/config.ts
 const MEMORY_CATEGORIES = [
 	"preference",
@@ -56,11 +57,27 @@ function resolveEnvVars(value) {
 		return envValue;
 	});
 }
-function resolveEmbeddingModel(embedding) {
+function resolveEmbeddingModel(embedding, dimensions) {
 	const model = typeof embedding.model === "string" ? embedding.model : DEFAULT_MODEL;
-	if (typeof embedding.dimensions !== "number") vectorDimsForModel(model);
+	if (dimensions === void 0) vectorDimsForModel(model);
 	return model;
 }
+function resolveFiniteIntegerConfig(value) {
+	if (typeof value !== "number") return;
+	const parsed = parseFiniteNumber(value);
+	return parsed === void 0 ? void 0 : Math.floor(parsed);
+}
+function resolveBoundedIntegerConfig(params) {
+	const resolved = resolveFiniteIntegerConfig(params.value) ?? params.fallback;
+	if (resolved < params.min || resolved > params.max) throw new Error(`${params.label} must be between ${params.min} and ${params.max}`);
+	return resolved;
+}
+function resolveEmbeddingDimensions(embedding) {
+	if (embedding.dimensions === void 0) return;
+	const dimensions = typeof embedding.dimensions === "number" ? parseFiniteNumber(embedding.dimensions) : void 0;
+	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");
@@ -80,13 +97,24 @@ const memoryConfigSchema = {
 		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 model = resolveEmbeddingModel(embedding);
+		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 = typeof cfg.captureMaxChars === "number" ? Math.floor(cfg.captureMaxChars) : void 0;
-		const recallMaxChars = typeof cfg.recallMaxChars === "number" ? Math.floor(cfg.recallMaxChars) : void 0;
-		if (typeof captureMaxChars === "number" && (captureMaxChars < 100 || captureMaxChars > 1e4)) throw new Error("captureMaxChars must be between 100 and 10000");
-		if (typeof recallMaxChars === "number" && (recallMaxChars < 100 || recallMaxChars > 1e4)) throw new Error("recallMaxChars must be between 100 and 10000");
+		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");
@@ -118,15 +146,15 @@ const memoryConfigSchema = {
 				model,
 				apiKey: typeof embedding.apiKey === "string" ? resolveEnvVars(embedding.apiKey) : void 0,
 				baseUrl: typeof embedding.baseUrl === "string" ? resolveEnvVars(embedding.baseUrl) : void 0,
-				dimensions: typeof embedding.dimensions === "number" ? embedding.dimensions : void 0
+				dimensions
 			},
 			dreaming,
 			dbPath: typeof cfg.dbPath === "string" ? cfg.dbPath : DEFAULT_DB_PATH,
 			autoCapture: cfg.autoCapture === true,
 			autoRecall: cfg.autoRecall !== false,
-			captureMaxChars: captureMaxChars ?? 500,
+			captureMaxChars,
 			...customTriggers ? { customTriggers } : {},
-			recallMaxChars: recallMaxChars ?? 1e3,
+			recallMaxChars,
 			...storageOptions ? { storageOptions } : {}
 		};
 	},

package/dist/index.js

@@ -3,6 +3,8 @@ import { DEFAULT_RECALL_MAX_CHARS, MEMORY_CATEGORIES, memoryConfigSchema, vector
 import { loadLanceDbModule } from "./lancedb-runtime.js";
 import { Buffer } from "node:buffer";
 import { randomUUID } from "node:crypto";
+import { optionalFiniteNumberSchema, optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
+import { readFiniteNumberParam, readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
 import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { ensureGlobalUndiciEnvProxyDispatcher } from "openclaw/plugin-sdk/runtime-env";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -52,9 +54,12 @@ function extractLatestUserText(messages) {
 }
 function normalizeRecallQuery(text, maxChars = DEFAULT_RECALL_MAX_CHARS) {
 	const normalized = text.replace(/\s+/g, " ").trim();
-	const limit = Math.max(0, Math.floor(maxChars));
+	const limit = normalizeMaxChars(maxChars, DEFAULT_RECALL_MAX_CHARS);
 	return normalized.length > limit ? truncateUtf16Safe(normalized, limit).trimEnd() : normalized;
 }
+function normalizeMaxChars(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : fallback;
+}
 function messageFingerprint(message) {
 	const msgObj = asOptionalRecord(message);
 	if (!msgObj) return `${typeof message}:${String(message)}`;
@@ -334,7 +339,7 @@ function matchesCustomTrigger(text, customTriggers) {
 	return customTriggers.some((trigger) => lower.includes(trigger.toLocaleLowerCase()));
 }
 function shouldCapture(text, options) {
-	const maxChars = options?.maxChars ?? 500;
+	const maxChars = normalizeMaxChars(options?.maxChars, 500);
 	if (text.length > maxChars) return false;
 	if (text.includes("<relevant-memories>")) return false;
 	if (text.startsWith("<") && text.includes("</")) return false;
@@ -417,10 +422,12 @@ var memory_lancedb_default = definePluginEntry({
 			description: "Search through long-term memories. Use when you need context about user preferences, past decisions, or previously discussed topics.",
 			parameters: Type.Object({
 				query: Type.String({ description: "Search query" }),
-				limit: Type.Optional(Type.Number({ description: "Max results (default: 5)" }))
+				limit: optionalPositiveIntegerSchema({ description: "Max results (default: 5)" })
 			}),
 			async execute(_toolCallId, params) {
-				const { query, limit = 5 } = params;
+				const rawParams = params;
+				const query = rawParams.query;
+				const limit = readPositiveIntegerParam(rawParams, "limit") ?? 5;
 				const currentCfg = resolveCurrentHookConfig();
 				const vector = await embeddings.embed(normalizeRecallQuery(query, currentCfg.recallMaxChars));
 				const results = await db.search(vector, limit, .1);
@@ -457,14 +464,22 @@ var memory_lancedb_default = definePluginEntry({
 			description: "Save important information in long-term memory. Use for preferences, facts, decisions.",
 			parameters: Type.Object({
 				text: Type.String({ description: "Information to remember" }),
-				importance: Type.Optional(Type.Number({ description: "Importance 0-1 (default: 0.7)" })),
+				importance: optionalFiniteNumberSchema({
+					description: "Importance 0-1 (default: 0.7)",
+					minimum: 0,
+					maximum: 1
+				}),
 				category: Type.Optional(Type.Unsafe({
 					type: "string",
 					enum: [...MEMORY_CATEGORIES]
 				}))
 			}),
 			async execute(_toolCallId, params) {
-				const { text, importance = .7, category = "other" } = params;
+				const { text, category = "other" } = params;
+				const importance = readFiniteNumberParam(params, "importance", {
+					min: 0,
+					max: 1
+				}) ?? .7;
 				if (looksLikePromptInjection(text)) return {
 					content: [{
 						type: "text",
@@ -589,7 +604,8 @@ var memory_lancedb_default = definePluginEntry({
 			});
 			memory.command("search").description("Search memories").argument("<query>", "Search query").option("--limit <n>", "Max results", "5").action(async (query, opts) => {
 				const vector = await embeddings.embed(normalizeRecallQuery(query, cfg.recallMaxChars));
-				const output = (await db.search(vector, Number.parseInt(opts.limit, 10), .3)).map((r) => ({
+				const limit = parsePositiveIntegerOption(opts.limit, "--limit");
+				const output = (await db.search(vector, limit, .3)).map((r) => ({
 					id: r.entry.id,
 					text: r.entry.text,
 					category: r.entry.category,
@@ -626,8 +642,7 @@ var memory_lancedb_default = definePluginEntry({
 					if (!/^[a-zA-Z0-9_\-\s='"><!.,()%*]+$/.test(filterCondition)) throw new Error("Filter condition contains invalid characters");
 					query = query.where(filterCondition);
 				}
-				const limit = Number.parseInt(opts.limit, 10);
-				if (Number.isNaN(limit) || limit <= 0) throw new Error("Invalid limit: must be a positive integer");
+				const limit = parsePositiveIntegerOption(opts.limit, "--limit") ?? 10;
 				if (!opts.orderBy) query = query.limit(limit);
 				let rows = await query.toArray();
 				if (opts.orderBy) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/memory-lancedb",
-  "version": "2026.5.27",
+  "version": "2026.5.28-beta.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/memory-lancedb",
-      "version": "2026.5.27",
+      "version": "2026.5.28-beta.2",
       "dependencies": {
         "@lancedb/lancedb": "0.29.0",
         "apache-arrow": "18.1.0",

package/openclaw.plugin.json

@@ -103,7 +103,8 @@
             "type": "string"
           },
           "dimensions": {
-            "type": "number"
+            "type": "integer",
+            "minimum": 1
           }
         }
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/memory-lancedb",
-  "version": "2026.5.27",
+  "version": "2026.5.28-beta.2",
   "description": "OpenClaw LanceDB-backed long-term memory plugin with auto-recall, auto-capture, and vector search.",
   "repository": {
     "type": "git",
@@ -26,10 +26,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.5.27"
+      "pluginApi": ">=2026.5.28-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.5.27"
+      "openclawVersion": "2026.5.28-beta.2"
     },
     "release": {
       "bundleRuntimeDependencies": false,
@@ -46,7 +46,7 @@
     "npm-shrinkwrap.json"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.5.27"
+    "openclaw": ">=2026.5.28-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {