@openviking/openclaw-plugin 2026.5.10-dev.3 → 2026.5.21

package/dist/client.js

@@ -245,6 +245,36 @@ export class OpenVikingClient {
     async read(uri, agentId) {
         return this.request(`/api/v1/content/read?uri=${encodeURIComponent(uri)}`, {}, agentId);
     }
+    async readToolResult(sessionId, toolResultId, options, agentId) {
+        const params = new URLSearchParams();
+        if (options?.offset !== undefined)
+            params.set("offset", String(options.offset));
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options?.includeMetadata !== undefined) {
+            params.set("include_metadata", String(options.includeMetadata));
+        }
+        const query = params.toString();
+        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/tool-results/${encodeURIComponent(toolResultId)}${query ? `?${query}` : ""}`, {}, agentId);
+    }
+    async searchToolResult(sessionId, toolResultId, queryText, options, agentId) {
+        const params = new URLSearchParams({ q: queryText });
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options?.contextChars !== undefined) {
+            params.set("context_chars", String(options.contextChars));
+        }
+        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/tool-results/${encodeURIComponent(toolResultId)}/search?${params.toString()}`, {}, agentId);
+    }
+    async listToolResults(sessionId, options, agentId) {
+        const params = new URLSearchParams();
+        if (options?.toolName)
+            params.set("tool_name", options.toolName);
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        const query = params.toString();
+        return this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/tool-results${query ? `?${query}` : ""}`, {}, agentId);
+    }
     async uploadTempFile(filePath, agentId) {
         const fileBytes = await readFile(filePath);
         const form = new FormData();

package/dist/context-engine.js

@@ -29,9 +29,6 @@ function allocateContextBudget(totalBudget, instructionTokens = 0) {
     const sessionContext = Math.max(usableBudget - archiveMemory, 0);
     return { archiveMemory, sessionContext, reserved };
 }
-function estimateTokens(messages) {
-    return Math.max(1, messages.length * 80);
-}
 function roughEstimate(messages) {
     return Math.ceil(JSON.stringify(messages).length / 4);
 }
@@ -265,6 +262,10 @@ export function convertToAgentMessages(msg) {
             const toolName = typeof p.tool_name === "string" ? p.tool_name : undefined;
             const status = typeof p.tool_status === "string" ? p.tool_status : "unknown";
             const output = typeof p.tool_output === "string" ? p.tool_output : "";
+            const ref = typeof p.tool_output_ref === "string" ? p.tool_output_ref : "";
+            const originalChars = typeof p.tool_output_original_chars === "number"
+                ? p.tool_output_original_chars
+                : undefined;
             if (toolId) {
                 // Structured path: emit canonical toolCall + toolResult pair (works for any role)
                 toolCallBlocks.push({
@@ -273,9 +274,15 @@ export function convertToAgentMessages(msg) {
                     name: toolName ?? "unknown",
                     arguments: p.tool_input ?? {},
                 });
-                const resultText = (status === "completed" || status === "error")
+                let resultText = (status === "completed" || status === "error")
                     ? (output || "(no output)")
                     : "(interrupted — tool did not complete)";
+                if (ref && !resultText.includes(ref)) {
+                    const suffix = originalChars !== undefined
+                        ? `\n[tool-result-ref] ${ref} original_chars=${originalChars}`
+                        : `\n[tool-result-ref] ${ref}`;
+                    resultText += suffix;
+                }
                 const resultPayload = {
                     role: "toolResult",
                     toolCallId: toolId,
@@ -330,6 +337,32 @@ export function convertToAgentMessages(msg) {
     }
     return result;
 }
+function isToolOnlyMessage(msg) {
+    return msg.role === "user" && msg.parts.length > 0 && msg.parts.every((part) => part.type === "tool");
+}
+function coalesceConsecutiveToolMessages(messages) {
+    const result = [];
+    let pendingTools;
+    const flush = () => {
+        if (pendingTools) {
+            result.push(pendingTools);
+            pendingTools = undefined;
+        }
+    };
+    for (const msg of messages) {
+        if (isToolOnlyMessage(msg)) {
+            if (!pendingTools) {
+                pendingTools = { role: "user", parts: [] };
+            }
+            pendingTools.parts.push(...msg.parts);
+            continue;
+        }
+        flush();
+        result.push(msg);
+    }
+    flush();
+    return result;
+}
 function normalizeAssistantContent(messages) {
     for (let i = 0; i < messages.length; i++) {
         const msg = messages[i];
@@ -965,7 +998,8 @@ export function createMemoryOpenVikingContextEngine(params) {
                     afterTurnParams.prePromptMessageCount >= 0
                     ? afterTurnParams.prePromptMessageCount
                     : 0;
-                const { messages: extractedMessages, newCount } = extractNewTurnMessages(messages, start);
+                const { messages: extractedMessagesRaw, newCount } = extractNewTurnMessages(messages, start);
+                const extractedMessages = coalesceConsecutiveToolMessages(extractedMessagesRaw);
                 if (extractedMessages.length === 0) {
                     diag("afterTurn_skip", OVSessionId, {
                         reason: "no_new_turn_messages",
@@ -1055,9 +1089,7 @@ export function createMemoryOpenVikingContextEngine(params) {
                 if (commitResult.task_id && cfg.logFindRequests) {
                     logger.info(`openviking: Phase2 memory extraction runs asynchronously on the server (task_id=${commitResult.task_id}). ` +
                         "memories_extracted appears only after that task completes — not in this immediate response.");
-                    if (cfg.logFindRequests) {
-                        void pollPhase2ExtractionOutcome(getClient, commitResult.task_id, agentId, logger, OVSessionId);
-                    }
+                    void pollPhase2ExtractionOutcome(getClient, commitResult.task_id, agentId, logger, OVSessionId);
                 }
             }
             catch (err) {

package/dist/index.js

@@ -4,10 +4,39 @@ import { registerSetupCli } from "./commands/setup.js";
 import { OpenVikingClient, isMemoryUri } from "./client.js";
 import { formatMessageFaithful, toRoleId } from "./context-engine.js";
 import { compileSessionPatterns, shouldBypassSession, } from "./text-utils.js";
-import { clampScore, postProcessMemories, formatMemoryLines, } from "./memory-ranking.js";
+import { clampScore, postProcessMemories, pickMemoriesForInjection, } from "./memory-ranking.js";
 import { createMemoryOpenVikingContextEngine, openClawSessionToOvStorageId, openClawSessionRefToOvStorageId, } from "./context-engine.js";
 import { buildMemoryLines, buildMemoryLinesWithBudget, estimateTokenCount, prepareRecallQuery, } from "./auto-recall.js";
 export { buildMemoryLines, buildMemoryLinesWithBudget, estimateTokenCount, prepareRecallQuery, };
+function parseToolResultRef(value) {
+    const raw = typeof value === "string" ? value.trim() : "";
+    if (!raw) {
+        return null;
+    }
+    const match = raw.match(/^viking:\/\/session\/([^/]+)\/tool-results\/([^/?#]+)(?:[?#].*)?$/);
+    if (!match) {
+        return null;
+    }
+    const sessionId = decodeURIComponent(match[1]);
+    const toolResultId = decodeURIComponent(match[2]);
+    if (!sessionId || !toolResultId) {
+        return null;
+    }
+    return {
+        sessionId,
+        toolResultId,
+        ref: `viking://session/${encodeURIComponent(sessionId)}/tool-results/${encodeURIComponent(toolResultId)}`,
+    };
+}
+function getOptionalInteger(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.floor(value);
+}
+function getPositiveInteger(value, fallback) {
+    return Math.max(1, getOptionalInteger(value, fallback));
+}
 const DEFAULT_OPENCLAW_AGENT_ID = "main";
 /**
  * OpenViking `UserIdentifier` allows only [a-zA-Z0-9_-] for agent_id
@@ -764,29 +793,54 @@ const contextEnginePlugin = {
                         total: leafOnly.length,
                     };
                 }
-                const memories = postProcessMemories(result.memories ?? [], {
-                    limit,
+                const leafOnly = (result.memories ?? []).filter((m) => !m.level || m.level === 2);
+                const processed = postProcessMemories(leafOnly, {
+                    limit: requestLimit,
                     scoreThreshold,
                 });
+                const memories = pickMemoriesForInjection(processed, limit, query);
                 if (memories.length === 0) {
                     return {
                         content: [{ type: "text", text: "No relevant OpenViking memories found." }],
                         details: { count: 0, total: result.total ?? 0, scoreThreshold },
                     };
                 }
+                const { lines: memoryLines } = await buildMemoryLinesWithBudget(memories, (uri) => recallClient.read(uri, session.agentId), {
+                    recallPreferAbstract: false,
+                    recallMaxInjectedChars: cfg.recallMaxInjectedChars,
+                });
+                if (memoryLines.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `No complete OpenViking memories fit recallMaxInjectedChars=${cfg.recallMaxInjectedChars}.`,
+                            },
+                        ],
+                        details: {
+                            count: 0,
+                            memories,
+                            total: result.total ?? memories.length,
+                            scoreThreshold,
+                            requestLimit,
+                            recallMaxInjectedChars: cfg.recallMaxInjectedChars,
+                        },
+                    };
+                }
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `Found ${memories.length} memories:\n\n${formatMemoryLines(memories)}`,
+                            text: `Found ${memoryLines.length} memories:\n\n${memoryLines.join("\n")}`,
                         },
                     ],
                     details: {
-                        count: memories.length,
+                        count: memoryLines.length,
                         memories,
                         total: result.total ?? memories.length,
                         scoreThreshold,
                         requestLimit,
+                        recallMaxInjectedChars: cfg.recallMaxInjectedChars,
                     },
                 };
             },
@@ -1133,6 +1187,242 @@ const contextEnginePlugin = {
                 }
             },
         }), { name: "ov_archive_expand" });
+        api.registerTool((ctx) => ({
+            name: "openviking_tool_result_read",
+            label: "Tool Result Read (OpenViking)",
+            description: "Restore the full original content of a tool result that was externalized by OpenViking. " +
+                "Use when a previous tool result was externalized and only a preview is visible — " +
+                "the preview contains a [tool-result-ref] or viking://session/.../tool-results/... URI. " +
+                "\"Read\" tool returns the same truncated preview; this tool returns the complete content. " +
+                "To read all content: pass offset=0 and a limit large enough to cover the whole result " +
+                "(e.g. limit=100000). Use offset/limit for paging only when you need a specific section.",
+            parameters: Type.Object({
+                tool_output_ref: Type.String({
+                    description: "Exact OV URI from the preview, e.g. viking://session/<session_id>/tool-results/<tool_result_id>",
+                }),
+                offset: Type.Optional(Type.Number({ description: "Unicode character offset. Default: 0" })),
+                limit: Type.Optional(Type.Number({ description: "Maximum Unicode characters to read. Default: 20000" })),
+            }),
+            async execute(_toolCallId, params) {
+                if (isBypassedSession(ctx)) {
+                    return makeBypassedToolResult("openviking_tool_result_read");
+                }
+                const session = resolvePluginSessionRouting(ctx);
+                if (!session.ovSessionId) {
+                    return {
+                        content: [{ type: "text", text: "Error: no active session." }],
+                        details: { error: "no_session" },
+                    };
+                }
+                const parsed = parseToolResultRef(params.tool_output_ref ?? params.ref ?? params.uri);
+                if (!parsed) {
+                    return {
+                        content: [{ type: "text", text: "Error: tool_output_ref must be a viking://session/.../tool-results/... URI." }],
+                        details: { error: "invalid_tool_output_ref" },
+                    };
+                }
+                if (parsed.sessionId !== session.ovSessionId) {
+                    return {
+                        content: [{ type: "text", text: "Error: refusing to read a tool result from another session." }],
+                        details: {
+                            error: "session_mismatch",
+                            requestedSessionId: parsed.sessionId,
+                            currentSessionId: session.ovSessionId,
+                        },
+                    };
+                }
+                const offset = Math.max(0, getOptionalInteger(params.offset, 0));
+                const limit = getOptionalInteger(params.limit, 20_000);
+                if (limit < -1) {
+                    return {
+                        content: [{ type: "text", text: "Error: limit must be -1 or greater than or equal to 0." }],
+                        details: { error: "invalid_limit", limit },
+                    };
+                }
+                try {
+                    const client = await getClient();
+                    const result = await client.readToolResult(session.ovSessionId, parsed.toolResultId, { offset, limit, includeMetadata: true }, session.agentId);
+                    const returnedChars = result.content.length;
+                    const nextOffset = result.offset + returnedChars;
+                    const text = result.content || "(empty tool result chunk)";
+                    return {
+                        content: [{ type: "text", text }],
+                        details: {
+                            action: "read",
+                            tool_output_ref: parsed.ref,
+                            tool_result_id: result.tool_result_id,
+                            offset: result.offset,
+                            limit: result.limit,
+                            returned_chars: returnedChars,
+                            total_chars: result.total_chars,
+                            has_more: result.has_more,
+                            next_offset: result.has_more ? nextOffset : null,
+                            metadata: result.metadata ?? null,
+                        },
+                    };
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    api.logger.warn?.(`openviking: openviking_tool_result_read failed: ${msg}`);
+                    return {
+                        content: [{ type: "text", text: `Failed to read tool result: ${msg}` }],
+                        details: { error: msg, tool_output_ref: parsed.ref },
+                    };
+                }
+            },
+        }), { name: "openviking_tool_result_read" });
+        api.registerTool((ctx) => ({
+            name: "openviking_tool_result_search",
+            label: "Tool Result Search (OpenViking)",
+            description: "Search inside an externalized tool result for a keyword. " +
+                "Use when you need to find specific content in a large externalized result, " +
+                "before reading it with openviking_tool_result_read. " +
+                "Returns matching snippets with their character offsets.",
+            parameters: Type.Object({
+                tool_output_ref: Type.String({
+                    description: "Exact OV URI from the preview, e.g. viking://session/<session_id>/tool-results/<tool_result_id>",
+                }),
+                query: Type.String({ description: "Keyword or exact text to search for" }),
+                limit: Type.Optional(Type.Number({ description: "Maximum matches. Default: 20" })),
+                context_chars: Type.Optional(Type.Number({ description: "Characters around each match. Default: 300" })),
+            }),
+            async execute(_toolCallId, params) {
+                if (isBypassedSession(ctx)) {
+                    return makeBypassedToolResult("openviking_tool_result_search");
+                }
+                const session = resolvePluginSessionRouting(ctx);
+                if (!session.ovSessionId) {
+                    return {
+                        content: [{ type: "text", text: "Error: no active session." }],
+                        details: { error: "no_session" },
+                    };
+                }
+                const parsed = parseToolResultRef(params.tool_output_ref ?? params.ref ?? params.uri);
+                if (!parsed) {
+                    return {
+                        content: [{ type: "text", text: "Error: tool_output_ref must be a viking://session/.../tool-results/... URI." }],
+                        details: { error: "invalid_tool_output_ref" },
+                    };
+                }
+                if (parsed.sessionId !== session.ovSessionId) {
+                    return {
+                        content: [{ type: "text", text: "Error: refusing to search a tool result from another session." }],
+                        details: {
+                            error: "session_mismatch",
+                            requestedSessionId: parsed.sessionId,
+                            currentSessionId: session.ovSessionId,
+                        },
+                    };
+                }
+                const query = String(params.query ?? "").trim();
+                if (!query) {
+                    return {
+                        content: [{ type: "text", text: "Error: query is required." }],
+                        details: { error: "missing_param", param: "query" },
+                    };
+                }
+                const limit = getPositiveInteger(params.limit, 20);
+                const contextChars = Math.max(0, getOptionalInteger(params.context_chars ?? params.contextChars, 300));
+                try {
+                    const client = await getClient();
+                    const result = await client.searchToolResult(session.ovSessionId, parsed.toolResultId, query, { limit, contextChars }, session.agentId);
+                    const matches = result.matches ?? [];
+                    const text = matches.length
+                        ? [
+                            `Found ${matches.length} match(es) for "${query}" in ${parsed.ref}:`,
+                            "",
+                            ...matches.map((match, index) => `## Match ${index + 1} (offset ${match.offset})\n${match.snippet}`),
+                        ].join("\n")
+                        : `No matches found for "${query}" in ${parsed.ref}.`;
+                    return {
+                        content: [{ type: "text", text }],
+                        details: {
+                            action: "searched",
+                            tool_output_ref: parsed.ref,
+                            tool_result_id: result.tool_result_id,
+                            query,
+                            match_count: matches.length,
+                            matches,
+                        },
+                    };
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    api.logger.warn?.(`openviking: openviking_tool_result_search failed: ${msg}`);
+                    return {
+                        content: [{ type: "text", text: `Failed to search tool result: ${msg}` }],
+                        details: { error: msg, tool_output_ref: parsed.ref, query },
+                    };
+                }
+            },
+        }), { name: "openviking_tool_result_search" });
+        api.registerTool((ctx) => ({
+            name: "openviking_tool_result_list",
+            label: "Tool Result List (OpenViking)",
+            description: "List externalized tool results for the current session. " +
+                "Use to discover available refs before calling openviking_tool_result_read. " +
+                "Optionally filter by tool_name to narrow down results.",
+            parameters: Type.Object({
+                tool_name: Type.Optional(Type.String({ description: "Optional exact tool name filter" })),
+                limit: Type.Optional(Type.Number({ description: "Maximum results. Default: 50" })),
+            }),
+            async execute(_toolCallId, params) {
+                if (isBypassedSession(ctx)) {
+                    return makeBypassedToolResult("openviking_tool_result_list");
+                }
+                const session = resolvePluginSessionRouting(ctx);
+                if (!session.ovSessionId) {
+                    return {
+                        content: [{ type: "text", text: "Error: no active session." }],
+                        details: { error: "no_session" },
+                    };
+                }
+                const toolName = typeof params.tool_name === "string" && params.tool_name.trim()
+                    ? params.tool_name.trim()
+                    : typeof params.toolName === "string" && params.toolName.trim()
+                        ? params.toolName.trim()
+                        : undefined;
+                const limit = getPositiveInteger(params.limit, 50);
+                try {
+                    const client = await getClient();
+                    const result = await client.listToolResults(session.ovSessionId, { toolName, limit }, session.agentId);
+                    const items = result.tool_results ?? [];
+                    const text = items.length
+                        ? [
+                            `Found ${items.length} externalized tool result(s) in current session:`,
+                            "",
+                            ...items.map((item, index) => {
+                                const ref = typeof item.storage_uri === "string" ? item.storage_uri : "(missing ref)";
+                                const name = typeof item.tool_name === "string" ? item.tool_name : "tool";
+                                const chars = typeof item.original_chars === "number" ? item.original_chars : "unknown";
+                                const created = typeof item.created_at === "string" ? ` created_at=${item.created_at}` : "";
+                                return `${index + 1}. ${name} original_chars=${chars}${created}\nref: ${ref}`;
+                            }),
+                        ].join("\n")
+                        : toolName
+                            ? `No externalized tool results found for tool "${toolName}" in current session.`
+                            : "No externalized tool results found in current session.";
+                    return {
+                        content: [{ type: "text", text }],
+                        details: {
+                            action: "listed",
+                            session_id: session.ovSessionId,
+                            tool_name: toolName ?? null,
+                            count: items.length,
+                            tool_results: items,
+                        },
+                    };
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    api.logger.warn?.(`openviking: openviking_tool_result_list failed: ${msg}`);
+                    return {
+                        content: [{ type: "text", text: `Failed to list tool results: ${msg}` }],
+                        details: { error: msg, session_id: session.ovSessionId, tool_name: toolName ?? null },
+                    };
+                }
+            },
+        }), { name: "openviking_tool_result_list" });
         let contextEngineRef = null;
         const sessionAgentResolver = createSessionAgentResolver(cfg.agent_prefix);
         const rememberSessionAgentId = (ctx) => {

package/dist/process-manager.js

@@ -1,66 +1,3 @@
-import { Socket } from "node:net";
-export function waitForHealth(baseUrl, timeoutMs, intervalMs) {
-    const deadline = Date.now() + timeoutMs;
-    return new Promise((resolve, reject) => {
-        const tick = () => {
-            if (Date.now() > deadline) {
-                reject(new Error(`OpenViking health check timeout at ${baseUrl}`));
-                return;
-            }
-            fetch(`${baseUrl}/health`)
-                .then((r) => r.json())
-                .then((body) => {
-                if (body?.status === "ok") {
-                    resolve();
-                    return;
-                }
-                setTimeout(tick, intervalMs);
-            })
-                .catch(() => setTimeout(tick, intervalMs));
-        };
-        tick();
-    });
-}
-export function waitForHealthOrExit(baseUrl, timeoutMs, intervalMs, child) {
-    const exited = child.killed || child.exitCode !== null || child.signalCode !== null;
-    if (exited) {
-        return Promise.reject(new Error(`OpenViking subprocess exited before health check ` +
-            `(code=${child.exitCode}, signal=${child.signalCode})`));
-    }
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const cleanup = () => {
-            child.off?.("error", onError);
-            child.off?.("exit", onExit);
-        };
-        const finishResolve = () => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            cleanup();
-            resolve();
-        };
-        const finishReject = (err) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            cleanup();
-            reject(err instanceof Error ? err : new Error(String(err)));
-        };
-        const onError = (err) => {
-            finishReject(err);
-        };
-        const onExit = (code, signal) => {
-            finishReject(new Error(`OpenViking subprocess exited before health check ` +
-                `(code=${code}, signal=${signal})`));
-        };
-        child.once("error", onError);
-        child.once("exit", onExit);
-        waitForHealth(baseUrl, timeoutMs, intervalMs).then(finishResolve, finishReject);
-    });
-}
 export function withTimeout(promise, timeoutMs, timeoutMessage) {
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
@@ -73,30 +10,6 @@ export function withTimeout(promise, timeoutMs, timeoutMessage) {
         });
     });
 }
-export function quickTcpProbe(host, port, timeoutMs) {
-    return new Promise((resolve) => {
-        const socket = new Socket();
-        let done = false;
-        const finish = (ok) => {
-            if (done) {
-                return;
-            }
-            done = true;
-            socket.destroy();
-            resolve(ok);
-        };
-        socket.setTimeout(timeoutMs);
-        socket.once("connect", () => finish(true));
-        socket.once("timeout", () => finish(false));
-        socket.once("error", () => finish(false));
-        try {
-            socket.connect(port, host);
-        }
-        catch {
-            finish(false);
-        }
-    });
-}
 export async function quickHealthCheck(baseUrl, timeoutMs) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);

package/dist/runtime-utils.js

@@ -1,7 +1,4 @@
 const _env = globalThis["process"];
-export function sysEnv() {
-    return _env.env;
-}
 export function getEnv(key) {
     return _env.env[key];
 }