@openviking/openclaw-plugin 2026.5.26 → 2026.6.2

package/dist/auto-recall.js

@@ -1,6 +1,7 @@
 import { pickMemoriesForInjection, postProcessMemories, summarizeInjectionMemories, toJsonLog, } from "./memory-ranking.js";
 import { quickRecallPrecheck, withTimeout } from "./process-manager.js";
 import { sanitizeUserTextForCapture } from "./text-utils.js";
+import { estimateTextTokens } from "./token-estimator.js";
 const AUTO_RECALL_TIMEOUT_MS = 5_000;
 const RECALL_QUERY_MAX_CHARS = 4_000;
 export const AUTO_RECALL_SOURCE_MARKER = "Source: openviking-auto-recall";
@@ -25,11 +26,29 @@ export function prepareRecallQuery(rawText) {
         finalChars: query.length,
     };
 }
-/** Estimate token count using chars/4 heuristic for diagnostics. */
+/** Estimate token count using the shared CJK-aware fallback for diagnostics. */
 export function estimateTokenCount(text) {
-    if (!text)
-        return 0;
-    return Math.ceil(text.length / 4);
+    return estimateTextTokens(text);
+}
+function memoryCategory(item) {
+    return item.category?.trim() || "memory";
+}
+function indentContent(content) {
+    return content
+        .split("\n")
+        .map((line) => `  ${line}`)
+        .join("\n");
+}
+function formatMemoryLine(item, content, options) {
+    const category = memoryCategory(item);
+    if (!options.includeUri) {
+        return `- [${category}] ${content}`;
+    }
+    return [
+        `- [${category}]`,
+        `  <uri>${item.uri}</uri>`,
+        indentContent(content),
+    ].join("\n");
 }
 async function resolveMemoryContent(item, readFn, options) {
     let content;
@@ -57,7 +76,7 @@ export async function buildMemoryLines(memories, readFn, options) {
     const lines = [];
     for (const item of memories) {
         const content = await resolveMemoryContent(item, readFn, options);
-        lines.push(`- [${item.category ?? "memory"}] ${content}`);
+        lines.push(formatMemoryLine(item, content, options));
     }
     return lines;
 }
@@ -78,7 +97,7 @@ export async function buildMemoryLinesWithBudget(memories, readFn, options) {
             break;
         }
         const content = await resolveMemoryContent(item, readFn, options);
-        const line = `- [${item.category ?? "memory"}] ${content}`;
+        const line = formatMemoryLine(item, content, options);
         const separatorChars = lines.length > 0 ? 1 : 0;
         const projectedChars = totalChars + separatorChars + line.length;
         if (projectedChars > charBudget) {
@@ -105,7 +124,7 @@ export async function buildAutoRecallContext(params) {
     if (!cfg.autoRecall || queryText.length < 5) {
         return { memoryCount: 0, estimatedTokens: 0 };
     }
-    const precheck = await quickRecallPrecheck(cfg.baseUrl);
+    const precheck = await quickRecallPrecheck(client, agentId);
     if (!precheck.ok) {
         verbose?.(`openviking: skipping auto-recall because precheck failed (${precheck.reason})`);
         return { memoryCount: 0, estimatedTokens: 0 };
@@ -154,6 +173,7 @@ export async function buildAutoRecallContext(params) {
         const { lines: memoryLines, estimatedTokens } = await buildMemoryLinesWithBudget(memories, (uri) => client.read(uri, agentId), {
             recallPreferAbstract: cfg.recallPreferAbstract,
             recallMaxInjectedChars: cfg.recallMaxInjectedChars,
+            includeUri: true,
         });
         if (memoryLines.length === 0) {
             verbose?.(`openviking: skipping auto-recall injection; no complete memories fit maxInjectedChars=${cfg.recallMaxInjectedChars}`);

package/dist/client.js

@@ -155,8 +155,8 @@ export class OpenVikingClient {
             clearTimeout(timer);
         }
     }
-    async healthCheck() {
-        await this.request("/health");
+    async healthCheck(agentId, requestTimeoutMs) {
+        await this.request("/health", {}, agentId, requestTimeoutMs);
     }
     async getRuntimeIdentity(agentId) {
         const effectiveAgentId = this.resolveEffectiveAgentId(agentId);

package/dist/context-engine.js

@@ -4,6 +4,7 @@ import { AUTO_RECALL_SOURCE_MARKER, buildAutoRecallContext, prepareRecallQuery,
 import { compileSessionPatterns, extractNewTurnMessages, shouldBypassSession, } from "./text-utils.js";
 import { toJsonLog, } from "./memory-ranking.js";
 import { sanitizeToolUseResultPairing } from "./session-transcript-repair.js";
+import { estimateAgentMessageTokens, estimateAgentMessagesTokens, estimateTextTokens, } from "./token-estimator.js";
 export function toRoleId(senderId) {
     if (!senderId) {
         return undefined;
@@ -30,15 +31,10 @@ function allocateContextBudget(totalBudget, instructionTokens = 0) {
     return { archiveMemory, sessionContext, reserved };
 }
 function roughEstimate(messages) {
-    return Math.ceil(JSON.stringify(messages).length / 4);
+    return estimateAgentMessagesTokens(messages);
 }
 function msgTokenEstimate(msg) {
-    const raw = msg.content;
-    if (typeof raw === "string")
-        return Math.ceil(raw.length / 4);
-    if (Array.isArray(raw))
-        return Math.ceil(JSON.stringify(raw).length / 4);
-    return 1;
+    return estimateAgentMessageTokens(msg);
 }
 function normalizeTimestamp(value) {
     if (typeof value === "number" && Number.isFinite(value)) {
@@ -503,7 +499,7 @@ function buildSystemPromptAddition() {
 }
 function buildInstructionPrompt() {
     const text = buildSystemPromptAddition();
-    return { text, tokens: Math.ceil(text.length / 4) };
+    return { text, tokens: estimateTextTokens(text) };
 }
 function buildArchiveMemory(archiveOverview, _preAbstracts, _budget) {
     const messages = [];

package/dist/index.js

@@ -8,6 +8,7 @@ import { clampScore, postProcessMemories, pickMemoriesForInjection, } from "./me
 import { createMemoryOpenVikingContextEngine, openClawSessionToOvStorageId, openClawSessionRefToOvStorageId, } from "./context-engine.js";
 import { buildMemoryLines, buildMemoryLinesWithBudget, estimateTokenCount, prepareRecallQuery, } from "./auto-recall.js";
 export { buildMemoryLines, buildMemoryLinesWithBudget, estimateTokenCount, prepareRecallQuery, };
+export { estimateAgentMessageTokens, estimateAgentMessagesTokens, estimateSerializedTokens, estimateTextTokens, } from "./token-estimator.js";
 function parseToolResultRef(value) {
     const raw = typeof value === "string" ? value.trim() : "";
     if (!raw) {
@@ -848,7 +849,7 @@ const contextEnginePlugin = {
         api.registerTool((ctx) => ({
             name: "memory_store",
             label: "Memory Store (OpenViking)",
-            description: "Store text in OpenViking memory pipeline by writing to a session and running memory extraction.",
+            description: "Store text in OpenViking memory pipeline by writing to a session and running memory extraction. Use when the user explicitly asks to remember, save, or store an important long-term fact, preference, project, or decision; automatic capture is threshold/commit dependent.",
             parameters: Type.Object({
                 text: Type.String({ description: "Information to store as memory source text" }),
                 role: Type.Optional(Type.String({ description: "Session role, default user" })),
@@ -914,7 +915,25 @@ const contextEnginePlugin = {
                     }
                     if (memoriesCount === 0) {
                         api.logger.warn(`openviking: memory_store committed but 0 memories extracted (sessionId=${sessionId}). ` +
-                            "Check OpenViking server logs for embedding/extract errors (e.g. 401 API key, or extraction pipeline).");
+                            "No OpenViking-managed long-term memory was created. Check memory.extraction_enabled, VLM configuration/API keys, or whether the text was judged not durable.");
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Memory extraction completed for session ${sessionId}, but produced 0 memories. ` +
+                                        "No OpenViking-managed long-term memory was stored. Check memory.extraction_enabled, VLM configuration/API keys, or whether the text is durable enough to remember.",
+                                },
+                            ],
+                            details: {
+                                action: "failed",
+                                sessionId,
+                                status: commitResult.status,
+                                error: "no_memories_extracted",
+                                memoriesCount,
+                                archived: commitResult.archived ?? false,
+                                usedTempSession,
+                            },
+                        };
                     }
                     else {
                         api.logger.info?.(`openviking: memory_store committed, memories=${memoriesCount}`);

package/dist/process-manager.js

@@ -10,29 +10,17 @@ export function withTimeout(promise, timeoutMs, timeoutMessage) {
         });
     });
 }
-export async function quickHealthCheck(baseUrl, timeoutMs) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+export async function quickHealthCheck(client, agentId, timeoutMs) {
     try {
-        const response = await fetch(`${baseUrl}/health`, {
-            method: "GET",
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            return false;
-        }
-        const body = (await response.json().catch(() => ({})));
-        return body.status === "ok";
+        await client.healthCheck(agentId, timeoutMs);
+        return true;
     }
     catch {
         return false;
     }
-    finally {
-        clearTimeout(timer);
-    }
 }
-export async function quickRecallPrecheck(baseUrl) {
-    const healthOk = await quickHealthCheck(baseUrl, 500);
+export async function quickRecallPrecheck(client, agentId) {
+    const healthOk = await quickHealthCheck(client, agentId, 500);
     if (healthOk) {
         return { ok: true };
     }

package/dist/token-estimator.js

@@ -0,0 +1,51 @@
+function isCjkCodePoint(codePoint) {
+    return ((codePoint >= 0x3400 && codePoint <= 0x4dbf) ||
+        (codePoint >= 0x4e00 && codePoint <= 0x9fff) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x2ebef) ||
+        (codePoint >= 0x3040 && codePoint <= 0x30ff) ||
+        (codePoint >= 0x31f0 && codePoint <= 0x31ff) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7af) ||
+        (codePoint >= 0x1100 && codePoint <= 0x11ff) ||
+        (codePoint >= 0x3130 && codePoint <= 0x318f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xffef) ||
+        (codePoint >= 0x3000 && codePoint <= 0x303f));
+}
+function codePointWeight(codePoint) {
+    if (isCjkCodePoint(codePoint)) {
+        return 1.5;
+    }
+    if (codePoint > 0xffff) {
+        return 2;
+    }
+    return 0.25;
+}
+export function estimateTextTokens(text) {
+    if (!text) {
+        return 0;
+    }
+    let weightedTokens = 0;
+    for (const char of text) {
+        weightedTokens += codePointWeight(char.codePointAt(0) ?? 0);
+    }
+    return Math.ceil(weightedTokens);
+}
+export function estimateSerializedTokens(value) {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    if (typeof value === "string") {
+        return estimateTextTokens(value);
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+        return estimateTextTokens(String(value));
+    }
+    const serialized = JSON.stringify(value);
+    return estimateTextTokens(serialized ?? "");
+}
+export function estimateAgentMessageTokens(message) {
+    return estimateSerializedTokens(message);
+}
+export function estimateAgentMessagesTokens(messages) {
+    return estimateSerializedTokens(messages);
+}