@xdarkicex/openclaw-memory-libravdb 1.4.14 → 1.4.16

package/dist/context-engine.d.ts

@@ -83,6 +83,7 @@ export declare function buildContextEngineFactory(runtime: PluginRuntime, cfg: P
         }>;
         tokenBudget: number;
         prompt?: string;
+        currentTokenCount?: number;
     }): Promise<OpenClawCompatibleAssembleResult>;
     compact(args: {
         sessionId: string;

package/dist/context-engine.js

@@ -30,15 +30,6 @@ function normalizeCompactResult(response) {
         },
     };
 }
-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 "";
@@ -69,10 +60,6 @@ function stringifyKernelBlock(block) {
         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 : "";
     }
 }
@@ -81,10 +68,6 @@ function normalizeKernelContent(content) {
         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");
@@ -101,6 +84,14 @@ function approximateMessageTokens(message) {
 function approximateMessagesTokens(messages) {
     return messages.reduce((sum, message) => sum + approximateMessageTokens(message), 0);
 }
+function normalizeCurrentTokenCount(currentTokenCount) {
+    if (typeof currentTokenCount !== "number" ||
+        !Number.isFinite(currentTokenCount) ||
+        currentTokenCount <= 0) {
+        return undefined;
+    }
+    return Math.max(1, Math.floor(currentTokenCount));
+}
 function normalizeTokenBudget(tokenBudget) {
     if (typeof tokenBudget !== "number" || !Number.isFinite(tokenBudget) || tokenBudget <= 0) {
         return undefined;
@@ -128,6 +119,33 @@ function resolveDynamicCompactThreshold(tokenBudget, compactThreshold, compactio
     const fraction = normalizeThresholdFraction(compactionThresholdFraction);
     return Math.max(1, Math.floor(normalizedBudget * fraction));
 }
+function resolvePredictiveCompactionTarget(params) {
+    const currentTokenCount = normalizeCurrentTokenCount(params.currentTokenCount);
+    const threshold = normalizeTokenBudget(params.threshold);
+    if (currentTokenCount == null || threshold == null || currentTokenCount < threshold) {
+        return undefined;
+    }
+    const belowThresholdTarget = Math.max(1, threshold - 1);
+    return belowThresholdTarget < currentTokenCount
+        ? belowThresholdTarget
+        : Math.max(1, currentTokenCount - 1);
+}
+function logPredictiveCompactionAttempt(params) {
+    params.logger.info?.(`LibraVDB predictive compaction trigger phase=${params.phase} sessionId=${params.sessionId} ` +
+        `currentTokenCount=${params.currentTokenCount} threshold=${params.threshold} ` +
+        `targetSize=${params.targetSize} tokenBudget=${params.tokenBudget ?? "unknown"}`);
+}
+function logPredictiveCompactionOutcome(params) {
+    const message = `LibraVDB predictive compaction ${params.compacted ? "completed" : "did not compact"} ` +
+        `phase=${params.phase} sessionId=${params.sessionId} currentTokenCount=${params.currentTokenCount} ` +
+        `threshold=${params.threshold} targetSize=${params.targetSize} tokenBudget=${params.tokenBudget ?? "unknown"}` +
+        (params.reason ? ` reason=${params.reason}` : "");
+    if (params.compacted) {
+        params.logger.info?.(message);
+        return;
+    }
+    params.logger.warn?.(message);
+}
 function truncateContentToTokenBudget(content, tokenBudget) {
     if (tokenBudget <= 0)
         return "";
@@ -191,6 +209,10 @@ function buildBudgetFallbackContext(messages, tokenBudget) {
         systemPromptAddition: "",
     };
 }
+function resolvePredictiveCompactionTokenCount(args) {
+    return (normalizeCurrentTokenCount(args.currentTokenCount) ??
+        approximateMessagesTokens(args.messages) + approximateTokenCount(args.prompt ?? ""));
+}
 export function normalizeKernelMessage(message) {
     return {
         role: message.role,
@@ -263,7 +285,12 @@ export function buildContextEngineFactory(runtime, cfg, recallCache, logger = co
             sessionId: requireSessionId(args.sessionId, "compact"),
             force: args.force,
             ...(typeof targetSize === "number" ? { targetSize } : {}),
-            ...(typeof args.currentTokenCount === "number" ? { currentTokenCount: args.currentTokenCount } : {}),
+            ...(() => {
+                const normalizedCurrentTokenCount = normalizeCurrentTokenCount(args.currentTokenCount);
+                return normalizedCurrentTokenCount != null
+                    ? { currentTokenCount: normalizedCurrentTokenCount }
+                    : {};
+            })(),
             ...(typeof cfg.continuityMinTurns === "number"
                 ? { continuityMinTurns: cfg.continuityMinTurns }
                 : {}),
@@ -293,6 +320,45 @@ export function buildContextEngineFactory(runtime, cfg, recallCache, logger = co
             };
         }
     }
+    async function performAfterTurnPredictiveCompaction(args) {
+        const dynamicCompactThreshold = getDynamicCompactThreshold(args.tokenBudget);
+        const predictiveTargetSize = resolvePredictiveCompactionTarget({
+            currentTokenCount: args.currentTokenCount,
+            threshold: dynamicCompactThreshold,
+        });
+        if (args.currentTokenCount == null ||
+            dynamicCompactThreshold == null ||
+            predictiveTargetSize == null) {
+            return;
+        }
+        logPredictiveCompactionAttempt({
+            logger,
+            phase: "afterTurn",
+            sessionId: args.sessionId,
+            currentTokenCount: args.currentTokenCount,
+            threshold: dynamicCompactThreshold,
+            targetSize: predictiveTargetSize,
+            tokenBudget: args.tokenBudget,
+        });
+        const compactionResult = await runCompaction({
+            sessionId: args.sessionId,
+            targetSize: predictiveTargetSize,
+            tokenBudget: args.tokenBudget,
+            force: true,
+            currentTokenCount: args.currentTokenCount,
+        });
+        logPredictiveCompactionOutcome({
+            logger,
+            phase: "afterTurn",
+            sessionId: args.sessionId,
+            currentTokenCount: args.currentTokenCount,
+            threshold: dynamicCompactThreshold,
+            targetSize: predictiveTargetSize,
+            tokenBudget: args.tokenBudget,
+            compacted: compactionResult.compacted,
+            reason: compactionResult.reason,
+        });
+    }
     return {
         info: { id: "libravdb-memory", name: "LibraVDB Memory", ownsCompaction: true },
         ownsCompaction: true,
@@ -337,18 +403,47 @@ export function buildContextEngineFactory(runtime, cfg, recallCache, logger = co
         },
         async assemble(args) {
             const messages = normalizeKernelMessages(args.messages);
-            const currentContextTokens = approximateMessagesTokens(messages) + approximateTokenCount(args.prompt ?? "");
+            const currentContextTokens = resolvePredictiveCompactionTokenCount({
+                currentTokenCount: args.currentTokenCount,
+                messages,
+                prompt: args.prompt,
+            });
             const dynamicCompactThreshold = getDynamicCompactThreshold(args.tokenBudget);
-            if (dynamicCompactThreshold != null &&
-                currentContextTokens >= dynamicCompactThreshold) {
+            const predictiveTargetSize = resolvePredictiveCompactionTarget({
+                currentTokenCount: currentContextTokens,
+                threshold: dynamicCompactThreshold,
+            });
+            if (dynamicCompactThreshold != null && predictiveTargetSize != null) {
+                logPredictiveCompactionAttempt({
+                    logger,
+                    phase: "assemble",
+                    sessionId: args.sessionId,
+                    currentTokenCount: currentContextTokens,
+                    threshold: dynamicCompactThreshold,
+                    targetSize: predictiveTargetSize,
+                    tokenBudget: args.tokenBudget,
+                });
                 const compactionResult = await runCompaction({
                     sessionId: args.sessionId,
+                    targetSize: predictiveTargetSize,
                     tokenBudget: args.tokenBudget,
                     force: true,
                     currentTokenCount: currentContextTokens,
                 });
-                if (!compactionResult.ok || !compactionResult.compacted) {
-                    logger.warn?.(`LibraVDB predictive compaction blocked assemble path at ${currentContextTokens} tokens (threshold=${dynamicCompactThreshold}): ${compactionResult.reason ?? "compaction declined"}`);
+                logPredictiveCompactionOutcome({
+                    logger,
+                    phase: "assemble",
+                    sessionId: args.sessionId,
+                    currentTokenCount: currentContextTokens,
+                    threshold: dynamicCompactThreshold,
+                    targetSize: predictiveTargetSize,
+                    tokenBudget: args.tokenBudget,
+                    compacted: compactionResult.compacted,
+                    reason: compactionResult.reason,
+                });
+                if (!compactionResult.ok) {
+                    logger.warn?.(`LibraVDB predictive compaction blocked assemble path at ${currentContextTokens} tokens ` +
+                        `(threshold=${dynamicCompactThreshold}): ${compactionResult.reason ?? "compaction failed"}`);
                     return buildBudgetFallbackContext(messages, args.tokenBudget);
                 }
             }
@@ -396,8 +491,11 @@ export function buildContextEngineFactory(runtime, cfg, recallCache, logger = co
         async afterTurn(args) {
             const messages = normalizeKernelMessages(args.messages);
             const kernel = runtime.getKernel();
+            const currentTokenCount = normalizeCurrentTokenCount(typeof args.runtimeContext?.currentTokenCount === "number"
+                ? args.runtimeContext.currentTokenCount
+                : undefined);
             if (kernel) {
-                return await kernel.afterTurn({
+                const result = await kernel.afterTurn({
                     sessionId: args.sessionId,
                     sessionKey: args.sessionKey,
                     userId: args.userId,
@@ -405,12 +503,24 @@ export function buildContextEngineFactory(runtime, cfg, recallCache, logger = co
                     prePromptMessageCount: args.prePromptMessageCount,
                     isHeartbeat: args.isHeartbeat,
                 });
+                await performAfterTurnPredictiveCompaction({
+                    sessionId: args.sessionId,
+                    tokenBudget: args.tokenBudget,
+                    currentTokenCount,
+                });
+                return result;
             }
             const rpc = await runtime.getRpc();
-            return await rpc.call("after_turn_kernel", {
+            const result = await rpc.call("after_turn_kernel", {
                 ...args,
                 messages,
             });
+            await performAfterTurnPredictiveCompaction({
+                sessionId: args.sessionId,
+                tokenBudget: args.tokenBudget,
+                currentTokenCount,
+            });
+            return result;
         }
     };
 }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "libravdb-memory",
   "name": "LibraVDB Memory",
   "description": "Persistent vector memory with three-tier hybrid scoring",
-  "version": "1.4.14",
+  "version": "1.4.16",
   "kind": [
     "memory",
     "context-engine"

package/package.json

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