@xdarkicex/openclaw-memory-libravdb 1.9.10-beta.9 → 1.10.0

package/dist/libravdb-client.d.ts

@@ -1,7 +1,7 @@
 import type { Interceptor } from "@connectrpc/connect";
 import type { PartialMessage } from "@bufbuild/protobuf";
 import type { LoggerLike } from "./types.js";
-import type { AfterTurnKernelRequest, AfterTurnKernelResponse, BeforeTurnKernelRequest, BeforeTurnKernelResponse, AssembleContextInternalRequest, AssembleContextInternalResponse, BootstrapSessionKernelRequest, BootstrapSessionKernelResponse, CompactSessionRequest, CompactSessionResponse, DeleteAuthoredDocumentRequest, DeleteAuthoredDocumentResponse, DreamPromotionResponse, ExportMemoryRequest, ExportMemoryResponse, FlushNamespaceRequest, FlushNamespaceResponse, FlushRequest, FlushResponse, HealthRequest, HealthResponse, IngestMarkdownDocumentRequest, IngestMarkdownDocumentResponse, IngestMessageKernelRequest, IngestMessageKernelResponse, ListCollectionRequest, ListCollectionResponse, ListLifecycleJournalRequest, ListLifecycleJournalResponse, MarkMemorySupersededRequest, MarkMemorySupersededResponse, MemoryStatusRequest, MemoryStatusResponse, PromoteDreamEntriesRequest, RankCandidatesRequest, RankCandidatesResponse, RebuildIndexRequest, RebuildIndexResponse, ReindexAuthoredDocumentRequest, ReindexAuthoredDocumentResponse, SearchTextCollectionsRequest, SearchTextRequest, SearchTextResponse, SessionLifecycleHintRequest, SessionLifecycleHintResponse, SummarizeMessagesRequest, SummarizeMessagesResponse, ExpandSummaryRequest, ExpandSummaryResponse } from "@xdarkicex/libravdb-contracts";
+import type { AfterTurnKernelRequest, AfterTurnKernelResponse, BeforeTurnKernelRequest, BeforeTurnKernelResponse, AssembleContextInternalRequest, AssembleContextInternalResponse, BootstrapSessionKernelRequest, BootstrapSessionKernelResponse, CompactSessionRequest, CompactSessionResponse, DeleteAuthoredDocumentRequest, DeleteAuthoredDocumentResponse, DreamPromotionResponse, ExportMemoryRequest, ExportMemoryResponse, FlushNamespaceRequest, FlushNamespaceResponse, FlushRequest, FlushResponse, HealthRequest, HealthResponse, IngestMarkdownDocumentRequest, IngestMarkdownDocumentResponse, IngestMessageKernelRequest, IngestMessageKernelResponse, ListByMetaRequest, ListByMetaResponse, ListCollectionRequest, ListCollectionResponse, ListLifecycleJournalRequest, ListLifecycleJournalResponse, MarkMemorySupersededRequest, MarkMemorySupersededResponse, MemoryStatusRequest, MemoryStatusResponse, PromoteDreamEntriesRequest, RankCandidatesRequest, RankCandidatesResponse, RebuildIndexRequest, RebuildIndexResponse, ReindexAuthoredDocumentRequest, ReindexAuthoredDocumentResponse, SearchTextCollectionsRequest, SearchTextRequest, SearchTextResponse, SessionLifecycleHintRequest, SessionLifecycleHintResponse, SummarizeMessagesRequest, SummarizeMessagesResponse, ExpandSummaryRequest, ExpandSummaryResponse, UpsertUserCardRequest, UpsertUserCardResponse, GetUserCardRequest, GetUserCardResponse } from "@xdarkicex/libravdb-contracts";
 export interface LibravDBClientOptions {
     endpoint?: string;
     secret?: string;
@@ -65,6 +65,9 @@ export declare class LibravDBClient {
     summarizeMessages(req: PartialMessage<SummarizeMessagesRequest>): Promise<SummarizeMessagesResponse>;
     expandSummary(req: PartialMessage<ExpandSummaryRequest>): Promise<ExpandSummaryResponse>;
     rankCandidates(req: PartialMessage<RankCandidatesRequest>): Promise<RankCandidatesResponse>;
+    upsertUserCard(req: PartialMessage<UpsertUserCardRequest>): Promise<UpsertUserCardResponse>;
+    getUserCard(req: PartialMessage<GetUserCardRequest>): Promise<GetUserCardResponse>;
+    listByMeta(req: PartialMessage<ListByMetaRequest>): Promise<ListByMetaResponse>;
     close(): void;
 }
 export declare function loadSecretFromEnv(logger?: LoggerLike): string | undefined;

package/dist/libravdb-client.js

@@ -337,6 +337,19 @@ export class LibravDBClient {
         this.guardOpen();
         return this.client.rankCandidates(req);
     }
+    // ── User Card ────────────────────────────────────────────────────
+    async upsertUserCard(req) {
+        this.guardOpen();
+        return this.client.upsertUserCard(req);
+    }
+    async getUserCard(req) {
+        this.guardOpen();
+        return this.client.getUserCard(req);
+    }
+    async listByMeta(req) {
+        this.guardOpen();
+        return this.client.listByMeta(req);
+    }
     close() {
         this.closed = true;
     }

package/dist/memory-provider.js

@@ -7,6 +7,13 @@ const MEMORY_PROMPT_HEADER = [
     "answer from memory until you have called it. Once you have results,",
     "use them — do not re-call in the same turn.",
     "",
+    "### Identity / People Lookup (OVERRIDES memory_search)",
+    "When asked about a specific person ('who is X', 'what do you know",
+    "about X', 'tell me about X'): call `get_user_card` or `list_user_cards`",
+    "FIRST. User cards are the canonical identity record written by you.",
+    "Only use `memory_search` AFTER the card if the card lacks detail.",
+    "Do NOT call memory_search first for people questions.",
+    "",
     "Conversations are captured automatically. Never say \"I'll remember",
     "that,\" \"I've saved this,\" \"noted,\" or similar — these phrases suggest",
     "manual effort where none exists. Just act on the request.",
@@ -17,6 +24,12 @@ function buildToolGuidance(availableTools) {
         return [];
     }
     const lines = [];
+    // ── User card tools (identity-first override) ──
+    const hasGetCard = availableTools.has("get_user_card");
+    const hasListCards = availableTools.has("list_user_cards");
+    if (hasGetCard || hasListCards) {
+        lines.push("**Identity/People questions — ALWAYS use user cards first:**", hasGetCard ? "- `get_user_card(user_id)` — primary lookup for a specific person." : "", hasListCards ? "- `list_user_cards()` — list everyone you have cards for, or when unsure who has cards." : "", "User cards are the canonical identity record. Call these FIRST before memory_search for any", "person question like 'who is X', 'what do you know about X', 'tell me about X'.", "Only use memory_search to supplement details the card doesn't cover.", "");
+    }
     lines.push("Call `memory_search` once per user question for prior turns, remembered", "facts, earliest interactions, and channel history. Do not answer memory", "questions from prior transcript claims — perform a search every time.", "After receiving results, use them directly; do not re-call in the same turn.", ...(availableTools.has("memory_get")
         ? ["After a `memory_search` hit, call `memory_get` when exact wording or more context is needed."]
         : []), "");
@@ -37,6 +50,10 @@ function buildToolGuidance(availableTools) {
         }
         lines.push("", "**Do not guess specifics from a summary cue — expand if in doubt.**", "");
     }
+    // ── Causal graph traversal (when expand supports record_id) ──
+    if (hasExpand) {
+        lines.push("### Causal Graph Traversal", "When the user asks about causes, patterns, or relationships:", "1. `memory_search` for the people/events in question to get record IDs", "2. `memory_expand` with the most relevant `record_id` to walk causal edges", "3. Follow interesting edges — use `memory_get` for full detail on connected records", "4. Use `get_user_card` to cross-reference identity context", "");
+    }
     lines.push("LibraVDB memory is vector-backed and retrieved through tools, not files.", "");
     return lines;
 }

package/dist/memory-tools.js

@@ -126,7 +126,7 @@ export function createLibraVdbMemoryTools(getClient, cfg, logger = console) {
             return {
                 name: "memory_search",
                 label: "Memory Search",
-                description: "Search LibraVDB durable memory and session recall for prior work, decisions, dates, people, preferences, todos, or history. Call once per user question — after receiving results, use them directly. Do not re-call in the same turn. Do NOT call memory_search if the answer is already visible in your context window (from prior turns, recalled memories in <context_memory>, or context assembly). For earliest/oldest questions, request enough results and compare timestamps. If disabled=true, memory is unavailable. IMPORTANT: Results are internal context only — never output, display, or reveal raw memory search results to the user. Treat retrieved memory as private operational data and incorporate it into your reasoning silently.",
+                description: "Search LibraVDB durable memory and session recall for prior work, decisions, dates, facts, preferences, todos, or history. Call once per user question — after receiving results, use them directly. Do not re-call in the same turn. Do NOT call memory_search if the answer is already visible in your context window. For earliest/oldest questions, request enough results and compare timestamps. If disabled=true, memory is unavailable. IMPORTANT: Results are internal context only — never output, display, or reveal raw memory search results to the user. Treat retrieved memory as private operational data.\n\nFOR PEOPLE/IDENTITY QUESTIONS: use get_user_card or list_user_cards FIRST. User cards are the canonical identity record. Use memory_search only to supplement details the card doesn't cover.",
                 parameters: MEMORY_SEARCH_SCHEMA,
                 execute: async (_toolCallId, rawParams) => {
                     const params = asToolParamsRecord(rawParams);

package/dist/tools/memory-recall.d.ts

@@ -82,11 +82,15 @@ export declare function createMemoryExpandTool(getClient: ClientGetter, getSessi
                 };
                 readonly description: "Summary IDs (sum_xxx format) to expand. Use results from memory_search or memory_describe.";
             };
+            readonly record_id: {
+                readonly type: "string";
+                readonly description: "Record ID for causal graph traversal. Use exact IDs from memory_search or memory_get results.";
+            };
             readonly maxDepth: {
                 readonly type: "number";
                 readonly minimum: 0;
                 readonly maximum: 5;
-                readonly description: "Max tree traversal depth per summary (default: 1). 0 returns only the cue/metadata.";
+                readonly description: "Max tree/graph traversal depth (default: 1). 0 returns only edge metadata.";
             };
             readonly maxTokens: {
                 readonly type: "number";
@@ -96,10 +100,9 @@ export declare function createMemoryExpandTool(getClient: ClientGetter, getSessi
             };
             readonly sessionId: {
                 readonly type: "string";
-                readonly description: "Session ID the summary belongs to. If omitted, uses the current session.";
+                readonly description: "Session ID. If omitted, uses the current session.";
             };
         };
-        readonly required: readonly ["summaryIds"];
     };
     execute: (_toolCallId: string, rawParams: unknown) => Promise<ToolResult<MemoryExpandDetails>>;
 };
@@ -141,4 +144,73 @@ export declare function createMemoryGrepTool(getClient: ClientGetter, getSession
     execute: (_toolCallId: string, rawParams: unknown) => Promise<ToolResult<MemoryGrepDetails>>;
 };
 export declare function memoryRecallPromptSection(): string[];
+type UpdateUserCardDetails = {
+    ok: boolean;
+    error?: string;
+};
+type GetUserCardDetails = {
+    card?: string | null;
+    updatedAt?: number;
+    version?: number;
+    error?: string;
+};
+export declare function createUpdateUserCardTool(getClient: ClientGetter, logger?: LoggerLike): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly user_id: {
+                readonly type: "string";
+                readonly description: "The user ID to update the card for.";
+            };
+            readonly card: {
+                readonly type: "string";
+                readonly description: "Prose description of what you've learned about this person. Write like describing a friend. Include identity, values, history, communication style, triggers, and what matters to them. Merge with previous understanding — don't replace entirely unless the user explicitly contradicts the record. Max ~1200 characters.";
+            };
+        };
+        readonly required: readonly ["user_id", "card"];
+    };
+    execute: (_toolCallId: string, rawParams: unknown) => Promise<ToolResult<UpdateUserCardDetails>>;
+};
+export declare function createGetUserCardTool(getClient: ClientGetter, logger?: LoggerLike): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly user_id: {
+                readonly type: "string";
+                readonly description: "The user ID to retrieve the card for.";
+            };
+        };
+        readonly required: readonly ["user_id"];
+    };
+    execute: (_toolCallId: string, rawParams: unknown) => Promise<ToolResult<GetUserCardDetails>>;
+};
+type ListUserCardsDetails = {
+    users: Array<{
+        user_id: string;
+        preview: string;
+        updated_at?: number;
+        version?: number;
+    }>;
+    total: number;
+    error?: string;
+};
+export declare function createListUserCardsTool(getClient: ClientGetter, logger?: LoggerLike): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {};
+    };
+    execute: (_toolCallId: string, _rawParams: unknown) => Promise<ToolResult<ListUserCardsDetails>>;
+};
 export {};

package/dist/tools/memory-recall.js

@@ -31,11 +31,15 @@ const MEMORY_EXPAND_SCHEMA = {
             items: { type: "string" },
             description: "Summary IDs (sum_xxx format) to expand. Use results from memory_search or memory_describe.",
         },
+        record_id: {
+            type: "string",
+            description: "Record ID for causal graph traversal. Use exact IDs from memory_search or memory_get results.",
+        },
         maxDepth: {
             type: "number",
             minimum: 0,
             maximum: 5,
-            description: "Max tree traversal depth per summary (default: 1). 0 returns only the cue/metadata.",
+            description: "Max tree/graph traversal depth (default: 1). 0 returns only edge metadata.",
         },
         maxTokens: {
             type: "number",
@@ -45,10 +49,9 @@ const MEMORY_EXPAND_SCHEMA = {
         },
         sessionId: {
             type: "string",
-            description: "Session ID the summary belongs to. If omitted, uses the current session.",
+            description: "Session ID. If omitted, uses the current session.",
         },
     },
-    required: ["summaryIds"],
 };
 const MEMORY_GREP_SCHEMA = {
     type: "object",
@@ -191,20 +194,49 @@ export function createMemoryExpandTool(getClient, getSessionKey, logger = consol
     return {
         name: "memory_expand",
         label: "Memory Expand",
-        description: "Expand compacted summaries to recover full detail. Walks the summary tree " +
-            "up to maxDepth levels. For large expansions (>2500 tokens), spawns a " +
-            "sub-agent to protect context. Use memory_describe first to check if expansion " +
-            "is warranted — many questions can be answered from the eviction cue alone.",
+        description: "Expand compacted summaries OR walk causal graph edges from ANY record. " +
+            "Summary mode (summaryIds): walk the summary tree up to maxDepth levels. " +
+            "Graph mode (record_id): walk causal edges (why_ids/how_ids/hop_targets) " +
+            "from a record ID. Use exact IDs from memory_search or memory_get results — " +
+            "any ingested turn, memory, or summary has graph edges. " +
+            "After get_user_card for context, search for related people/events then " +
+            "expand the most relevant hit. " +
+            "For large expansions, spawns a sub-agent. " +
+            "Use memory_describe first to check if expansion is warranted.",
         parameters: MEMORY_EXPAND_SCHEMA,
         execute: async (_toolCallId, rawParams) => {
             const params = asParams(rawParams);
+            const recordId = readStr(params, "record_id");
             const rawIds = params.summaryIds;
             const summaryIds = Array.isArray(rawIds) ? rawIds.filter((v) => typeof v === "string" && v.trim().length > 0) : [];
-            if (summaryIds.length === 0)
-                throw new Error("memory_expand requires at least one summaryId");
             const maxDepth = readNum(params, "maxDepth", { integer: true, min: 0 }) ?? 1;
             let maxTokens = readNum(params, "maxTokens", { integer: true }) ?? MAX_EXPAND_TOKENS;
             const sessionId = readStr(params, "sessionId") ?? getSessionId() ?? "";
+            // Graph mode: walk causal edges from a record ID.
+            if (recordId) {
+                try {
+                    const client = await getClient();
+                    const resp = await client.expandSummary({ recordId, maxDepth });
+                    let text = resp.text ?? "";
+                    const connected = resp.connected;
+                    if (connected && connected.length > 0) {
+                        text = connected.map((c) => `[depth=${c.depth}] ${c.recordId}: ${c.text || ""}`).join("\n\n");
+                    }
+                    if (!text && resp.whyIds?.length) {
+                        text = `why_ids: ${resp.whyIds.join(", ")}\nhow_ids: ${resp.howIds?.join(", ") ?? "none"}\nhop_targets: ${resp.hopTargets?.join(", ") ?? "none"}`;
+                    }
+                    return {
+                        content: [{ type: "text", text: text || "(no graph edges found)" }],
+                        details: { summaryId: recordId, depth: maxDepth, text: text || "", truncated: false, exceededBudget: false, parentCount: connected?.length ?? 0 },
+                    };
+                }
+                catch (error) {
+                    logger.warn?.(`memory_expand graph mode failed: ${formatError(error)}`);
+                    return { content: [{ type: "text", text: `Graph expansion failed: ${formatError(error)}` }], details: { summaryId: recordId, depth: maxDepth, text: "", truncated: false, exceededBudget: false, parentCount: 0 } };
+                }
+            }
+            if (summaryIds.length === 0)
+                throw new Error("memory_expand requires at least one summaryId or record_id");
             // Subagent budget gate: if this is a subagent, check remaining expansion budget.
             const sessionKey = getSessionKey();
             if (sessionKey) {
@@ -422,3 +454,149 @@ const RECALL_GUIDANCE = [
 export function memoryRecallPromptSection() {
     return [...RECALL_GUIDANCE];
 }
+// ── User Card tool schemas ──
+const UPDATE_USER_CARD_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        user_id: {
+            type: "string",
+            description: "The user ID to update the card for.",
+        },
+        card: {
+            type: "string",
+            description: "Prose description of what you've learned about this person. Write like describing a friend. Include identity, values, history, communication style, triggers, and what matters to them. Merge with previous understanding — don't replace entirely unless the user explicitly contradicts the record. Max ~1200 characters.",
+        },
+    },
+    required: ["user_id", "card"],
+};
+const GET_USER_CARD_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        user_id: {
+            type: "string",
+            description: "The user ID to retrieve the card for.",
+        },
+    },
+    required: ["user_id"],
+};
+// ── User Card tool factories ──
+export function createUpdateUserCardTool(getClient, logger = console) {
+    return {
+        name: "update_user_card",
+        label: "Update User Card",
+        description: "Write what you've learned about a speaker. Prose format — write like you're describing a friend. " +
+            "Include identity, values, history, communication style, triggers, and what matters to them. " +
+            "This is the canonical record of who they are. If something changes, update it. " +
+            "Merge with previous understanding, don't replace entirely unless the user explicitly contradicts the record.",
+        parameters: UPDATE_USER_CARD_SCHEMA,
+        execute: async (_toolCallId, rawParams) => {
+            try {
+                const params = asParams(rawParams);
+                const userId = readStr(params, "user_id");
+                const card = readStr(params, "card");
+                if (!userId)
+                    return jsonResult({ ok: false, error: "update_user_card requires user_id" });
+                if (!card)
+                    return jsonResult({ ok: false, error: "update_user_card requires card" });
+                const client = await getClient();
+                const resp = await client.upsertUserCard({
+                    userId,
+                    cardJson: JSON.stringify({ card, updatedAt: Date.now() }),
+                });
+                return jsonResult({ ok: resp.ok });
+            }
+            catch (error) {
+                logger.warn?.(`update_user_card failed: ${formatError(error)}`);
+                return jsonResult({ error: formatError(error), ok: false });
+            }
+        },
+    };
+}
+export function createGetUserCardTool(getClient, logger = console) {
+    return {
+        name: "get_user_card",
+        label: "Get User Card",
+        description: "PRIMARY identity lookup. Call this FIRST whenever someone asks about a person " +
+            "('who is X', 'tell me about X', 'what do you know about X'). " +
+            "Returns the full prose identity card with metadata. " +
+            "Only use memory_search AFTER get_user_card if the card lacks detail.",
+        parameters: GET_USER_CARD_SCHEMA,
+        execute: async (_toolCallId, rawParams) => {
+            try {
+                const params = asParams(rawParams);
+                const userId = readStr(params, "user_id");
+                if (!userId)
+                    return jsonResult({ card: null, error: "get_user_card requires user_id" });
+                const client = await getClient();
+                const resp = await client.getUserCard({ userId });
+                return jsonResult({
+                    card: resp.cardJson || null,
+                    updatedAt: resp.updatedAt ? Number(resp.updatedAt) : undefined,
+                    version: resp.version || undefined,
+                });
+            }
+            catch (error) {
+                logger.warn?.(`get_user_card failed: ${formatError(error)}`);
+                return jsonResult({ error: formatError(error) });
+            }
+        },
+    };
+}
+export function createListUserCardsTool(getClient, logger = console) {
+    return {
+        name: "list_user_cards",
+        label: "List User Cards",
+        description: "List every person you have a user card for. Returns user IDs and card previews. " +
+            "Use this FIRST when asked about multiple people, 'who do you know?', 'who is everyone?', " +
+            "or when you're unsure which people have cards. Then use get_user_card on specific IDs " +
+            "for full detail. Use memory_search only to supplement gaps.",
+        parameters: { type: "object", additionalProperties: false, properties: {} },
+        execute: async (_toolCallId, _rawParams) => {
+            try {
+                const client = await getClient();
+                const resp = await client.listByMeta({
+                    collection: "",
+                    key: "type",
+                    value: "user_card",
+                });
+                const users = [];
+                for (const result of resp.results) {
+                    let userId = "";
+                    let preview = "";
+                    let updatedAt;
+                    let version;
+                    if (result.metadataJson && result.metadataJson.length > 0) {
+                        try {
+                            const decoder = new TextDecoder();
+                            const meta = JSON.parse(decoder.decode(result.metadataJson));
+                            userId = typeof meta._user_id === "string" ? meta._user_id : "";
+                            const cardJson = typeof meta.card_json === "string" ? meta.card_json : null;
+                            if (cardJson) {
+                                try {
+                                    preview = JSON.parse(cardJson).card ?? cardJson;
+                                }
+                                catch {
+                                    preview = cardJson;
+                                }
+                                preview = preview.slice(0, 200);
+                            }
+                            updatedAt = typeof meta.updated_at === "number" ? meta.updated_at : undefined;
+                            version = typeof meta.version === "number" ? meta.version : undefined;
+                        }
+                        catch { /* best-effort metadata parse */ }
+                    }
+                    if (!userId)
+                        continue;
+                    users.push({ user_id: userId, preview, updated_at: updatedAt, version });
+                }
+                return jsonResult({ users, total: users.length });
+            }
+            catch (error) {
+                logger.warn?.(`list_user_cards failed: ${formatError(error)}`);
+                return jsonResult({ users: [], total: 0, error: formatError(error) });
+            }
+        },
+    };
+}

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "libravdb-memory",
   "name": "LibraVDB Memory",
-  "description": "Persistent vector memory with three-tier hybrid scoring",
-  "version": "1.9.10-beta.9",
+  "description": "Cognitive memory engine — causal graph reasoning, predictive context, identity tracking, and hybrid vector recall with back-door adjustment scoring",
+  "version": "1.10.0",
   "kind": [
     "memory",
     "context-engine"
@@ -15,7 +15,10 @@
       "memory_get",
       "memory_describe",
       "memory_expand",
-      "memory_grep"
+      "memory_grep",
+      "update_user_card",
+      "get_user_card",
+      "list_user_cards"
     ]
   },
   "activation": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdarkicex/openclaw-memory-libravdb",
-  "version": "1.9.10-beta.9",
+  "version": "1.10.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -65,7 +65,7 @@
     "build:daemon": "bash scripts/build-daemon.sh"
   },
   "devDependencies": {
-    "@bufbuild/protobuf": "1.7.2",
+    "@bufbuild/protobuf": "1.10.1",
     "@grpc/grpc-js": "^1.14.3",
     "@grpc/proto-loader": "^0.8.0",
     "@openclaw/plugin-inspector": "0.3.7",
@@ -80,11 +80,6 @@
   "dependencies": {
     "@connectrpc/connect": "^1.7.0",
     "@connectrpc/connect-node": "^1.7.0",
-    "@xdarkicex/libravdb-contracts": "^2.0.20"
-  },
-  "pnpm": {
-    "overrides": {
-      "undici": "8.3.0"
-    }
+    "@xdarkicex/libravdb-contracts": "^2.0.27"
   }
 }