@xdarkicex/openclaw-memory-libravdb 1.4.9 → 1.4.11

package/dist/context-engine.d.ts

@@ -1,6 +1,42 @@
 import type { PluginRuntime } from "./plugin-runtime.js";
 import type { LoggerLike, PluginConfig, RecallCache, SearchResult } from "./types.js";
 import { AssembleContextInternalResponse } from "./generated/libravdb/ipc/v1/rpc_pb.js";
+type KernelCompatibleMessage = {
+    role: string;
+    content: string;
+    id?: string;
+};
+type OpenClawCompatibleMessage = {
+    role: string;
+    content: string;
+    id?: string;
+};
+type OpenClawCompatibleAssembleResult = {
+    messages: OpenClawCompatibleMessage[];
+    estimatedTokens: number;
+    systemPromptAddition: string;
+    debug?: AssembleContextInternalResponse["debug"];
+};
+export declare function normalizeKernelMessage(message: {
+    role: string;
+    content: unknown;
+    id?: string;
+}): KernelCompatibleMessage;
+export declare function normalizeKernelMessages(messages: Array<{
+    role: string;
+    content: unknown;
+    id?: string;
+}>): KernelCompatibleMessage[];
+export declare function normalizeAssembleResult(result: {
+    messages?: Array<{
+        role: string;
+        content?: unknown;
+        id?: string;
+    }>;
+    estimatedTokens?: number;
+    systemPromptAddition?: string;
+    debug?: AssembleContextInternalResponse["debug"];
+}): OpenClawCompatibleAssembleResult;
 export declare function buildContextEngineFactory(runtime: PluginRuntime, cfg: PluginConfig, recallCache: RecallCache<SearchResult>, logger?: LoggerLike): {
     info: {
         id: string;
@@ -19,7 +55,7 @@ export declare function buildContextEngineFactory(runtime: PluginRuntime, cfg: P
         userId?: string;
         message: {
             role: string;
-            content: string;
+            content: unknown;
             id?: string;
         };
         isHeartbeat?: boolean;
@@ -30,16 +66,17 @@ export declare function buildContextEngineFactory(runtime: PluginRuntime, cfg: P
         userId?: string;
         messages: Array<{
             role: string;
-            content: string;
+            content: unknown;
             id?: string;
         }>;
         tokenBudget: number;
         prompt?: string;
-    }): Promise<AssembleContextInternalResponse>;
+    }): Promise<OpenClawCompatibleAssembleResult>;
     compact(args: {
         sessionId: string;
         force?: boolean;
         targetSize?: number;
+        tokenBudget?: number;
     }): Promise<any>;
     afterTurn(args: {
         sessionId: string;
@@ -47,10 +84,13 @@ export declare function buildContextEngineFactory(runtime: PluginRuntime, cfg: P
         userId?: string;
         messages: Array<{
             role: string;
-            content: string;
+            content: unknown;
             id?: string;
         }>;
         prePromptMessageCount?: number;
         isHeartbeat?: boolean;
+        tokenBudget?: number;
+        runtimeContext?: Record<string, unknown>;
     }): Promise<any>;
 };
+export {};

package/dist/context-engine.js

@@ -1,4 +1,113 @@
+function describeUnexpectedContent(value) {
+    try {
+        const serialized = JSON.stringify(value);
+        return serialized === undefined ? String(value) : serialized;
+    }
+    catch {
+        return String(value);
+    }
+}
+function stringifyKernelBlock(block) {
+    if (!block || typeof block !== "object") {
+        return "";
+    }
+    const record = block;
+    switch (record.type) {
+        case "text":
+            return typeof record.text === "string" ? record.text : "";
+        case "thinking":
+            return typeof record.thinking === "string" ? record.thinking : "";
+        case "toolCall": {
+            const name = typeof record.name === "string" ? record.name : "tool";
+            const args = record.arguments;
+            let renderedArgs = "";
+            if (typeof args === "string") {
+                renderedArgs = args;
+            }
+            else if (args !== undefined) {
+                try {
+                    renderedArgs = JSON.stringify(args);
+                }
+                catch {
+                    renderedArgs = String(args);
+                }
+            }
+            return renderedArgs ? `[tool:${name}] ${renderedArgs}` : `[tool:${name}]`;
+        }
+        case "image":
+            return "[image omitted]";
+        default:
+            console.warn("[libravdb] unsupported kernel content block", {
+                type: record.type,
+                block: describeUnexpectedContent(record),
+            });
+            return typeof record.text === "string" ? record.text : "";
+    }
+}
+function normalizeKernelContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        console.warn("[libravdb] unexpected kernel content shape", {
+            kind: typeof content,
+            value: describeUnexpectedContent(content),
+        });
+        return "";
+    }
+    return content.map(stringifyKernelBlock).filter((part) => part.length > 0).join("\n");
+}
+export function normalizeKernelMessage(message) {
+    return {
+        role: message.role,
+        content: normalizeKernelContent(message.content),
+        ...(typeof message.id === "string" ? { id: message.id } : {}),
+    };
+}
+export function normalizeKernelMessages(messages) {
+    return messages.map((message) => normalizeKernelMessage(message));
+}
+export function normalizeAssembleResult(result) {
+    const messages = Array.isArray(result.messages)
+        ? result.messages.map((message) => ({
+            // OpenClaw replay only expects conversational turns here, so assemble output
+            // is collapsed to user/assistant even though normalizeKernelMessage preserves
+            // richer inbound roles. If kernel.assembleContext starts emitting other roles,
+            // this coercion point is where that contract needs to be revisited.
+            role: message.role === "user" ? "user" : "assistant",
+            content: normalizeKernelContent(message.content),
+            ...(typeof message.id === "string" ? { id: message.id } : {}),
+        }))
+        : [];
+    return {
+        messages,
+        estimatedTokens: typeof result.estimatedTokens === "number" ? result.estimatedTokens : 0,
+        systemPromptAddition: typeof result.systemPromptAddition === "string" ? result.systemPromptAddition : "",
+        ...(result.debug != null ? { debug: result.debug } : {}),
+    };
+}
 export function buildContextEngineFactory(runtime, cfg, recallCache, logger = console) {
+    function buildCompactSessionRequest(args) {
+        // OpenClaw core now requests budget-style compaction using tokenBudget,
+        // but the current LibraVDB compact_session wire contract still expects
+        // targetSize. Use tokenBudget as the compatibility target so overflow and
+        // timeout retries still compact toward the host's requested prompt budget.
+        const targetSize = args.targetSize ?? args.tokenBudget;
+        return {
+            sessionId: args.sessionId,
+            force: args.force,
+            ...(typeof targetSize === "number" ? { targetSize } : {}),
+            ...(typeof cfg.continuityMinTurns === "number"
+                ? { continuityMinTurns: cfg.continuityMinTurns }
+                : {}),
+            ...(typeof cfg.continuityTailBudgetTokens === "number"
+                ? { continuityTailBudgetTokens: cfg.continuityTailBudgetTokens }
+                : {}),
+            ...(typeof cfg.continuityPriorContextTokens === "number"
+                ? { continuityPriorContextTokens: cfg.continuityPriorContextTokens }
+                : {}),
+        };
+    }
     return {
         info: { id: "libravdb-memory", name: "LibraVDB Memory", ownsCompaction: true },
         ownsCompaction: true,
@@ -24,39 +133,44 @@ export function buildContextEngineFactory(runtime, cfg, recallCache, logger = co
             return await rpc.call("bootstrap_session_kernel", args);
         },
         async ingest(args) {
+            const message = normalizeKernelMessage(args.message);
             const kernel = runtime.getKernel();
             if (kernel) {
                 return await kernel.ingestMessage({
                     sessionId: args.sessionId,
                     sessionKey: args.sessionKey,
                     userId: args.userId,
-                    message: args.message,
+                    message,
                     isHeartbeat: args.isHeartbeat,
                 });
             }
             const rpc = await runtime.getRpc();
-            return await rpc.call("ingest_message_kernel", args);
+            return await rpc.call("ingest_message_kernel", {
+                ...args,
+                message,
+            });
         },
         async assemble(args) {
+            const messages = normalizeKernelMessages(args.messages);
             const kernel = runtime.getKernel();
             if (kernel) {
-                return await kernel.assembleContext({
+                return normalizeAssembleResult(await kernel.assembleContext({
                     sessionId: args.sessionId,
                     sessionKey: args.sessionKey,
                     userId: args.userId,
                     queryText: args.prompt ?? "",
-                    visibleMessages: args.messages,
+                    visibleMessages: messages,
                     tokenBudget: args.tokenBudget,
                     config: {},
                     emitDebug: true
-                });
+                }));
             }
             const rpc = await runtime.getRpc();
             const resp = await rpc.call("assemble_context_internal", {
                 sessionId: args.sessionId,
                 sessionKey: args.sessionKey,
                 userId: args.userId,
-                messages: args.messages,
+                messages,
                 tokenBudget: args.tokenBudget,
                 prompt: args.prompt,
                 emitDebug: true,
@@ -92,34 +206,35 @@ export function buildContextEngineFactory(runtime, cfg, recallCache, logger = co
                     ingestionGateThreshold: cfg.ingestionGateThreshold,
                 },
             });
-            return resp;
+            return normalizeAssembleResult(resp);
         },
         async compact(args) {
+            const request = buildCompactSessionRequest(args);
             const kernel = runtime.getKernel();
             if (kernel) {
-                return await kernel.compactSession({
-                    sessionId: args.sessionId,
-                    force: args.force,
-                    targetSize: args.targetSize,
-                });
+                return await kernel.compactSession(request);
             }
             const rpc = await runtime.getRpc();
-            return await rpc.call("compact_session", args);
+            return await rpc.call("compact_session", request);
         },
         async afterTurn(args) {
+            const messages = normalizeKernelMessages(args.messages);
             const kernel = runtime.getKernel();
             if (kernel) {
                 return await kernel.afterTurn({
                     sessionId: args.sessionId,
                     sessionKey: args.sessionKey,
                     userId: args.userId,
-                    messages: args.messages,
+                    messages,
                     prePromptMessageCount: args.prePromptMessageCount,
                     isHeartbeat: args.isHeartbeat,
                 });
             }
             const rpc = await runtime.getRpc();
-            return await rpc.call("after_turn_kernel", args);
+            return await rpc.call("after_turn_kernel", {
+                ...args,
+                messages,
+            });
         }
     };
 }

package/dist/index.js

@@ -12,7 +12,7 @@ export default definePluginEntry({
     id: "libravdb-memory",
     name: "LibraVDB Memory",
     description: "Persistent vector memory with three-tier hybrid scoring",
-    kind: "context-engine",
+    kind: ["memory", "context-engine"],
     register(api) {
         const cfg = api.pluginConfig;
         const recallCache = createRecallCache();

package/dist/plugin-runtime.d.ts

@@ -4,6 +4,7 @@ import type { LoggerLike, PluginConfig } from "./types.js";
 export type RpcGetter = () => Promise<RpcClient>;
 export declare const DEFAULT_RPC_TIMEOUT_MS = 30000;
 export declare const STARTUP_HEALTH_TIMEOUT_MS = 2000;
+export declare function resolveStartupHealthTimeoutMs(cfg: PluginConfig): number;
 export interface LifecycleHint {
     hook: "before_reset" | "session_end";
     reason?: string;

package/dist/plugin-runtime.js

@@ -4,6 +4,9 @@ import { daemonProvisioningHint, startSidecar } from "./sidecar.js";
 import { readFileSync } from "node:fs";
 export const DEFAULT_RPC_TIMEOUT_MS = 30000;
 export const STARTUP_HEALTH_TIMEOUT_MS = 2000;
+export function resolveStartupHealthTimeoutMs(cfg) {
+    return Math.max(STARTUP_HEALTH_TIMEOUT_MS, cfg.rpcTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS);
+}
 export function createPluginRuntime(cfg, logger = console) {
     let started = null;
     let stopped = false;
@@ -19,7 +22,7 @@ export function createPluginRuntime(cfg, logger = console) {
                     timeoutMs: cfg.rpcTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS,
                 });
                 const health = await rpc.call("health", {}, {
-                    timeoutMs: STARTUP_HEALTH_TIMEOUT_MS,
+                    timeoutMs: resolveStartupHealthTimeoutMs(cfg),
                 });
                 if (!health.ok) {
                     try {

package/dist/rpc-protobuf-codecs.js

@@ -23,6 +23,13 @@ function normalizeSearchTextResponse(bytes) {
     }
     return response;
 }
+function normalizeAssembleContextInternalResponse(bytes) {
+    const response = decodeProtobufResult(AssembleContextInternalResponse, bytes);
+    if (!Array.isArray(response.messages)) {
+        response.messages = [];
+    }
+    return response;
+}
 function normalizeExcludeByCollection(value) {
     const normalized = {};
     if (!value) {
@@ -68,7 +75,7 @@ export const rpcProtobufCodecs = {
     bootstrap_session_kernel: codec((params) => encodeMessage(BootstrapSessionKernelRequest, params), (bytes) => decodeProtobufResult(BootstrapSessionKernelResponse, bytes)),
     ingest_message_kernel: codec((params) => encodeMessage(IngestMessageKernelRequest, params), (bytes) => decodeProtobufResult(IngestMessageKernelResponse, bytes)),
     after_turn_kernel: codec((params) => encodeMessage(AfterTurnKernelRequest, params), (bytes) => decodeProtobufResult(AfterTurnKernelResponse, bytes)),
-    assemble_context_internal: codec((params) => encodeMessage(AssembleContextInternalRequest, params), (bytes) => decodeProtobufResult(AssembleContextInternalResponse, bytes)),
+    assemble_context_internal: codec((params) => encodeMessage(AssembleContextInternalRequest, params), normalizeAssembleContextInternalResponse),
     compact_session: codec((params) => encodeMessage(CompactSessionRequest, params), (bytes) => decodeProtobufResult(CompactSessionResponse, bytes)),
     rank_candidates: codec((params) => encodeMessage(RankCandidatesRequest, params), (bytes) => decodeProtobufResult(RankCandidatesResponse, bytes)),
 };

package/dist/rpc.d.ts

@@ -8,6 +8,7 @@ export declare class RpcClient {
     private sentMagic;
     constructor(socket: SidecarSocket, options: RpcCallOptions);
     call<T>(method: string, params: unknown, callOptions?: Partial<RpcCallOptions>): Promise<T>;
+    private waitForReconnect;
     private handleData;
     private dispatchMessage;
     private rejectAll;

package/dist/rpc.js

@@ -26,12 +26,13 @@ export class RpcClient {
         return await new Promise((resolve, reject) => {
             const id = ++this.seq;
             const timeoutMs = callOptions.timeoutMs ?? this.options.timeoutMs;
+            const deadline = Date.now() + timeoutMs;
             const timer = setTimeout(() => {
                 this.pending.delete(id);
                 reject(new Error(`RPC timeout: ${method} (${timeoutMs}ms)`));
             }, timeoutMs);
             this.pending.set(id, { resolve, reject, timer, decodeResult: codec.decodeResult });
-            try {
+            const buildFrame = () => {
                 const envelope = new RpcRequest({
                     id,
                     method,
@@ -41,18 +42,93 @@ export class RpcClient {
                 const header = Buffer.alloc(4);
                 header.writeUInt32BE(payload.byteLength, 0);
                 const chunks = [];
-                if (!this.sentMagic) {
+                const includesMagic = !this.sentMagic;
+                if (includesMagic) {
                     chunks.push(Buffer.from([0x02]));
-                    this.sentMagic = true;
                 }
                 chunks.push(header, payload);
-                this.socket.write(Buffer.concat(chunks));
-            }
-            catch (error) {
+                return { frame: Buffer.concat(chunks), includesMagic };
+            };
+            const send = (allowReconnectRetry) => {
+                if (!this.pending.has(id)) {
+                    return;
+                }
+                const { frame, includesMagic } = buildFrame();
+                try {
+                    this.socket.write(frame);
+                    if (includesMagic) {
+                        this.sentMagic = true;
+                    }
+                }
+                catch (error) {
+                    if (allowReconnectRetry && isReconnectableSocketGap(error)) {
+                        this.sentMagic = false;
+                        const remainingMs = Math.max(0, deadline - Date.now());
+                        if (remainingMs <= 0) {
+                            if (!this.pending.has(id)) {
+                                return;
+                            }
+                            clearTimeout(timer);
+                            this.pending.delete(id);
+                            reject(new Error(`RPC timeout: ${method} (${timeoutMs}ms)`));
+                            return;
+                        }
+                        void this.waitForReconnect(remainingMs)
+                            .then(() => {
+                            if (!this.pending.has(id)) {
+                                return;
+                            }
+                            send(false);
+                        })
+                            .catch((reconnectError) => {
+                            if (!this.pending.has(id)) {
+                                return;
+                            }
+                            clearTimeout(timer);
+                            this.pending.delete(id);
+                            reject(reconnectError instanceof Error
+                                ? reconnectError
+                                : new Error(String(reconnectError)));
+                        });
+                        return;
+                    }
+                    clearTimeout(timer);
+                    this.pending.delete(id);
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            };
+            send(true);
+        });
+    }
+    async waitForReconnect(timeoutMs) {
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const onConnect = () => {
+                if (settled)
+                    return;
+                settled = true;
                 clearTimeout(timer);
-                this.pending.delete(id);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
+                this.socket.off("error", onError);
+                resolve();
+            };
+            const onError = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                this.socket.off("connect", onConnect);
+                reject(error);
+            };
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                this.socket.off("connect", onConnect);
+                this.socket.off("error", onError);
+                reject(new Error(`Sidecar reconnect timed out (${timeoutMs}ms)`));
+            }, timeoutMs);
+            this.socket.once("connect", onConnect);
+            this.socket.once("error", onError);
         });
     }
     handleData(chunk) {
@@ -119,3 +195,6 @@ export class RpcClient {
         }
     }
 }
+function isReconnectableSocketGap(error) {
+    return error instanceof Error && /Sidecar socket unavailable/i.test(error.message);
+}

package/dist/sidecar.d.ts

@@ -17,6 +17,7 @@ declare class PlaceholderSocket implements SidecarSocket {
     setEncoding(_encoding: string): void;
     on(event: "data" | "close" | "error", handler: DataHandler | CloseHandler | ErrorHandler): void;
     once(event: "connect" | "error", handler: CloseHandler | ErrorHandler): void;
+    off(event: "connect" | "error", handler: CloseHandler | ErrorHandler): void;
     write(chunk: Buffer | string): void;
     destroy(): void;
     private emitError;
@@ -28,7 +29,7 @@ export declare function isTcpEndpoint(endpoint: string): boolean;
 export declare function resolveEndpoint(cfg: PluginConfig): string;
 export declare function resolveConfiguredEndpoint(cfg: PluginConfig): string;
 export declare function daemonProvisioningHint(): string;
-export declare function defaultEndpoint(platform?: NodeJS.Platform, homeDir?: string): string;
+export declare function defaultEndpoint(platform?: NodeJS.Platform, homeDir?: string, pathExists?: (path: string) => boolean): string;
 export declare function buildSidecarEnv(cfg: PluginConfig): Record<string, string>;
 export { PlaceholderSocket };
 export declare function probeSidecarEndpoint(cfg: PluginConfig): Promise<string | null>;

package/dist/sidecar.js

@@ -38,6 +38,13 @@ class PlaceholderSocket {
         }
         this.errorOnce.add(handler);
     }
+    off(event, handler) {
+        if (event === "connect") {
+            this.connectOnce.delete(handler);
+            return;
+        }
+        this.errorOnce.delete(handler);
+    }
     write(chunk) {
         try {
             const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
@@ -95,13 +102,15 @@ class SupervisorSocket {
     connectOnce = new Set();
     errorOnce = new Set();
     current;
-    encoding = "utf8";
+    encoding;
     generation = 0;
     bind(socket) {
         this.current = socket;
         this.generation += 1;
         const generation = this.generation;
-        socket.setEncoding(this.encoding);
+        if (this.encoding) {
+            socket.setEncoding(this.encoding);
+        }
         socket.on("data", (chunk) => {
             if (generation !== this.generation) {
                 return;
@@ -163,6 +172,13 @@ class SupervisorSocket {
         }
         this.errorOnce.add(handler);
     }
+    off(event, handler) {
+        if (event === "connect") {
+            this.connectOnce.delete(handler);
+            return;
+        }
+        this.errorOnce.delete(handler);
+    }
     write(chunk) {
         if (!this.current) {
             throw new Error("Sidecar socket unavailable");
@@ -314,7 +330,7 @@ export function resolveConfiguredEndpoint(cfg) {
 export function daemonProvisioningHint() {
     return "If you installed the npm package, install and start libravdbd separately; the package does not provision the daemon binary, ONNX Runtime, or model assets.";
 }
-export function defaultEndpoint(platform = process.platform, homeDir = os.homedir()) {
+export function defaultEndpoint(platform = process.platform, homeDir = os.homedir(), pathExists = fs.existsSync) {
     // Honour the daemon's own env var first (set by Homebrew LaunchAgent / systemd unit).
     const envEndpoint = process.env.LIBRAVDB_RPC_ENDPOINT?.trim();
     if (envEndpoint && isConfiguredEndpoint(envEndpoint)) {
@@ -335,7 +351,7 @@ export function defaultEndpoint(platform = process.platform, homeDir = os.homedi
     for (const dir of candidateDirs) {
         const sockPath = path.join(dir, sockName);
         try {
-            if (fs.existsSync(sockPath)) {
+            if (pathExists(sockPath)) {
                 return `unix:${sockPath}`;
             }
         }

package/dist/types.d.ts

@@ -131,6 +131,8 @@ export interface SidecarSocket {
     on(event: "error", handler: (error: Error) => void): void;
     once(event: "connect", handler: () => void): void;
     once(event: "error", handler: (error: Error) => void): void;
+    off(event: "connect", handler: () => void): void;
+    off(event: "error", handler: (error: Error) => void): void;
     write(chunk: Buffer | string): void;
     destroy(err?: Error): void;
 }

package/docs/install.md

@@ -67,13 +67,22 @@ If you run the daemon on a non-default endpoint, add a plugin config:
 }
 ```
 
+When `sidecarPath` is set to `"auto"`, the plugin resolves endpoints in this order on macOS/Linux:
+
+1. `LIBRAVDB_RPC_ENDPOINT` if it is set to a valid daemon endpoint
+2. `$HOME/.clawdb/run/libravdb.sock` if it exists
+3. `/opt/homebrew/var/clawdb/run/libravdb.sock` if it exists
+4. `/usr/local/var/clawdb/run/libravdb.sock` if it exists
+5. fallback to `$HOME/.clawdb/run/libravdb.sock`
+
 ## Sidecar Daemon Install
 
 The daemon owns the local database, embeddings, and JSON-RPC endpoint.
 
 Default endpoints:
 
-- macOS/Linux: `unix:$HOME/.clawdb/run/libravdb.sock`
+- Homebrew on macOS: `unix:/opt/homebrew/var/clawdb/run/libravdb.sock`
+- macOS/Linux user-local installs: `unix:$HOME/.clawdb/run/libravdb.sock`
 - Windows: `tcp:127.0.0.1:37421`
 
 Default data path:

package/docs/installation.md

@@ -142,7 +142,8 @@ Install and start `libravdbd` separately for the same user account that runs Ope
 
 Default endpoints:
 
-- macOS/Linux: `unix:$HOME/.clawdb/run/libravdb.sock`
+- Homebrew on macOS: `unix:/opt/homebrew/var/clawdb/run/libravdb.sock`
+- macOS/Linux user-local installs: `unix:$HOME/.clawdb/run/libravdb.sock`
 - Windows: `tcp:127.0.0.1:37421`
 
 If you run the daemon on a different endpoint, set `plugins.configs.libravdb-memory.sidecarPath` in `~/.openclaw/openclaw.json`.
@@ -176,6 +177,18 @@ brew install libravdbd
 brew services start libravdbd
 ```
 
+With `sidecarPath: "auto"`, Homebrew installs on Apple Silicon should resolve to:
+
+```text
+unix:/opt/homebrew/var/clawdb/run/libravdb.sock
+```
+
+User-local installs still default to:
+
+```text
+unix:$HOME/.clawdb/run/libravdb.sock
+```
+
 The daemon release pipeline generates a publish-ready `libravdbd.rb` formula asset for release assets named:
 
 - `libravdbd-darwin-arm64`

package/openclaw.plugin.json

@@ -2,17 +2,35 @@
   "id": "libravdb-memory",
   "name": "LibraVDB Memory",
   "description": "Persistent vector memory with three-tier hybrid scoring",
-  "version": "1.4.9",
-  "kind": "context-engine",
+  "version": "1.4.11",
+  "kind": [
+    "memory",
+    "context-engine"
+  ],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
     "properties": {
-      "dbPath": { "type": "string" },
-      "sidecarPath": { "type": "string" },
-      "useSessionSummarySearchExperiment": { "type": "boolean" },
-      "embeddingRuntimePath": { "type": "string" },
-      "embeddingBackend": { "type": "string", "enum": ["bundled", "onnx-local", "custom-local"] },
+      "dbPath": {
+        "type": "string"
+      },
+      "sidecarPath": {
+        "type": "string"
+      },
+      "useSessionSummarySearchExperiment": {
+        "type": "boolean"
+      },
+      "embeddingRuntimePath": {
+        "type": "string"
+      },
+      "embeddingBackend": {
+        "type": "string",
+        "enum": [
+          "bundled",
+          "onnx-local",
+          "custom-local"
+        ]
+      },
       "embeddingProfile": {
         "type": "string",
         "default": "all-minilm-l6-v2"
@@ -21,22 +39,60 @@
         "type": "string",
         "default": "all-minilm-l6-v2"
       },
-      "embeddingModelPath": { "type": "string" },
-      "embeddingTokenizerPath": { "type": "string" },
-      "embeddingDimensions": { "type": "number" },
-      "embeddingNormalize": { "type": "boolean" },
-      "summarizerBackend": { "type": "string", "enum": ["bundled", "onnx-local", "ollama-local", "custom-local"] },
-      "summarizerProfile": { "type": "string" },
-      "summarizerRuntimePath": { "type": "string" },
-      "summarizerModelPath": { "type": "string" },
-      "summarizerTokenizerPath": { "type": "string" },
-      "summarizerModel": { "type": "string" },
-      "summarizerEndpoint": { "type": "string" },
-      "sessionTTL": { "type": "number" },
-      "topK": { "type": "number" },
-      "alpha": { "type": "number" },
-      "beta": { "type": "number" },
-      "gamma": { "type": "number" },
+      "embeddingModelPath": {
+        "type": "string"
+      },
+      "embeddingTokenizerPath": {
+        "type": "string"
+      },
+      "embeddingDimensions": {
+        "type": "number"
+      },
+      "embeddingNormalize": {
+        "type": "boolean"
+      },
+      "summarizerBackend": {
+        "type": "string",
+        "enum": [
+          "bundled",
+          "onnx-local",
+          "ollama-local",
+          "custom-local"
+        ]
+      },
+      "summarizerProfile": {
+        "type": "string"
+      },
+      "summarizerRuntimePath": {
+        "type": "string"
+      },
+      "summarizerModelPath": {
+        "type": "string"
+      },
+      "summarizerTokenizerPath": {
+        "type": "string"
+      },
+      "summarizerModel": {
+        "type": "string"
+      },
+      "summarizerEndpoint": {
+        "type": "string"
+      },
+      "sessionTTL": {
+        "type": "number"
+      },
+      "topK": {
+        "type": "number"
+      },
+      "alpha": {
+        "type": "number"
+      },
+      "beta": {
+        "type": "number"
+      },
+      "gamma": {
+        "type": "number"
+      },
       "ingestionGateThreshold": {
         "type": "number",
         "default": 0.35
@@ -47,7 +103,9 @@
       },
       "markdownIngestionRoots": {
         "type": "array",
-        "items": { "type": "string" }
+        "items": {
+          "type": "string"
+        }
       },
       "markdownIngestionObsidianEnabled": {
         "type": "boolean",
@@ -55,15 +113,21 @@
       },
       "markdownIngestionObsidianRoots": {
         "type": "array",
-        "items": { "type": "string" }
+        "items": {
+          "type": "string"
+        }
       },
       "markdownIngestionObsidianInclude": {
         "type": "array",
-        "items": { "type": "string" }
+        "items": {
+          "type": "string"
+        }
       },
       "markdownIngestionObsidianExclude": {
         "type": "array",
-        "items": { "type": "string" }
+        "items": {
+          "type": "string"
+        }
       },
       "markdownIngestionObsidianDebounceMs": {
         "type": "number",
@@ -71,11 +135,15 @@
       },
       "markdownIngestionInclude": {
         "type": "array",
-        "items": { "type": "string" }
+        "items": {
+          "type": "string"
+        }
       },
       "markdownIngestionExclude": {
         "type": "array",
-        "items": { "type": "string" }
+        "items": {
+          "type": "string"
+        }
       },
       "markdownIngestionCollection": {
         "type": "string",
@@ -103,16 +171,38 @@
         "type": "object",
         "additionalProperties": false,
         "default": {
-          "w1c": 0.35, "w2c": 0.40, "w3c": 0.25,
-          "w1t": 0.40, "w2t": 0.35, "w3t": 0.25
+          "w1c": 0.35,
+          "w2c": 0.4,
+          "w3c": 0.25,
+          "w1t": 0.4,
+          "w2t": 0.35,
+          "w3t": 0.25
         },
         "properties": {
-          "w1c": { "type": "number", "default": 0.35 },
-          "w2c": { "type": "number", "default": 0.40 },
-          "w3c": { "type": "number", "default": 0.25 },
-          "w1t": { "type": "number", "default": 0.40 },
-          "w2t": { "type": "number", "default": 0.35 },
-          "w3t": { "type": "number", "default": 0.25 }
+          "w1c": {
+            "type": "number",
+            "default": 0.35
+          },
+          "w2c": {
+            "type": "number",
+            "default": 0.4
+          },
+          "w3c": {
+            "type": "number",
+            "default": 0.25
+          },
+          "w1t": {
+            "type": "number",
+            "default": 0.4
+          },
+          "w2t": {
+            "type": "number",
+            "default": 0.35
+          },
+          "w3t": {
+            "type": "number",
+            "default": 0.25
+          }
         }
       },
       "gatingTechNorm": {
@@ -132,21 +222,42 @@
         "default": 0.5,
         "description": "Controls how much summary confidence affects retrieval score. 0 ignores summary quality and 1 fully suppresses zero-confidence summaries."
       },
-      "recencyLambdaSession": { "type": "number" },
-      "recencyLambdaUser": { "type": "number" },
-      "recencyLambdaGlobal": { "type": "number" },
-      "tokenBudgetFraction": { "type": "number" },
-      "compactThreshold": { "type": "number" },
+      "recencyLambdaSession": {
+        "type": "number"
+      },
+      "recencyLambdaUser": {
+        "type": "number"
+      },
+      "recencyLambdaGlobal": {
+        "type": "number"
+      },
+      "tokenBudgetFraction": {
+        "type": "number"
+      },
+      "compactThreshold": {
+        "type": "number"
+      },
       "compactSessionTokenBudget": {
         "type": "number",
         "default": 2000,
         "description": "Auto-trigger compaction when the session accumulates this many tokens since the last compaction. Set to 0 to disable auto-compaction."
       },
-      "ollamaUrl": { "type": "string" },
-      "compactModel": { "type": "string" },
-      "rpcTimeoutMs": { "type": "number", "default": 30000 },
-      "maxRetries": { "type": "number" },
-      "logLevel": { "type": "string" }
+      "ollamaUrl": {
+        "type": "string"
+      },
+      "compactModel": {
+        "type": "string"
+      },
+      "rpcTimeoutMs": {
+        "type": "number",
+        "default": 30000
+      },
+      "maxRetries": {
+        "type": "number"
+      },
+      "logLevel": {
+        "type": "string"
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdarkicex/openclaw-memory-libravdb",
-  "version": "1.4.9",
+  "version": "1.4.11",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",