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

package/dist/text-utils.js

@@ -21,7 +21,6 @@ const NON_CONTENT_TEXT_RE = /^[\p{P}\p{S}\s]+$/u;
 const SUBAGENT_CONTEXT_RE = /^\s*\[Subagent Context\]/i;
 const MEMORY_INTENT_RE = /记住|记下|remember|save|store|偏好|preference|规则|rule|事实|fact/i;
 const QUESTION_CUE_RE = /[?？]|\b(?:what|when|where|who|why|how|which|can|could|would|did|does|is|are)\b|^(?:请问|能否|可否|怎么|如何|什么时候|谁|什么|哪|是否)/i;
-export const CAPTURE_LIMIT = 3;
 function resolveCaptureMinLength(text) {
     return CJK_CHAR_REGEX.test(text) ? 4 : 10;
 }
@@ -232,21 +231,6 @@ export function extractTextsFromUserMessages(messages) {
     }
     return texts;
 }
-function formatToolUseBlock(b) {
-    const name = typeof b.name === "string" ? b.name : "unknown";
-    let inputStr = "";
-    if (b.input !== undefined && b.input !== null) {
-        try {
-            inputStr = typeof b.input === "string" ? b.input : JSON.stringify(b.input);
-        }
-        catch {
-            inputStr = String(b.input);
-        }
-    }
-    return inputStr
-        ? `[toolUse: ${name}]\n${inputStr}`
-        : `[toolUse: ${name}]`;
-}
 function formatToolResultContent(content) {
     if (typeof content === "string")
         return content.trim();
@@ -270,40 +254,6 @@ function formatToolResultContent(content) {
     }
     return "";
 }
-/**
- * Extract text from a single message without a `[role]:` prefix.
- * Used by afterTurn to send messages with their actual role.
- */
-export function extractSingleMessageText(msg) {
-    if (!msg || typeof msg !== "object")
-        return "";
-    const m = msg;
-    const role = m.role;
-    if (!role || role === "system")
-        return "";
-    if (role === "toolResult") {
-        const toolName = typeof m.toolName === "string" ? m.toolName : "tool";
-        const resultText = formatToolResultContent(m.content);
-        return resultText ? `[${toolName} result]: ${resultText}` : "";
-    }
-    const content = m.content;
-    if (typeof content === "string")
-        return content.trim();
-    if (Array.isArray(content)) {
-        const parts = [];
-        for (const block of content) {
-            const b = block;
-            if (b?.type === "text" && typeof b.text === "string") {
-                parts.push(b.text.trim());
-            }
-            else if (b?.type === "toolUse") {
-                parts.push(formatToolUseBlock(b));
-            }
-        }
-        return parts.join("\n");
-    }
-    return "";
-}
 /**
  * 提取消息中的一个 part 的文本内容，并清理时间戳等噪音
  */
@@ -394,7 +344,6 @@ export function extractNewTurnMessages(messages, startIndex) {
             continue;
         }
         // user/assistant -> type: "text"
-        // 统一 role 为 user
         const content = msg.content;
         const text = extractPartText(content);
         if (text) {
@@ -412,6 +361,37 @@ export function extractNewTurnMessages(messages, startIndex) {
                 });
             }
         }
+        else {
+            /// 如果原始消息有 toolCall，提取所有工具名并生成占位符
+            if (role === "assistant" && Array.isArray(content)) {
+                const toolNames = [];
+                // 收集所有 toolCall 的 tool_name
+                for (const block of content) {
+                    const b = block;
+                    const blockType = b?.type;
+                    if (blockType === "toolCall" ||
+                        blockType === "toolUse" ||
+                        blockType === "tool_use" ||
+                        blockType === "tool_call") {
+                        const name = b?.name || b?.toolName;
+                        if (name && typeof name === "string" && name.trim()) {
+                            toolNames.push(name.trim());
+                        }
+                    }
+                }
+                // 只有找到 toolCall 时才添加占位符
+                if (toolNames.length > 0) {
+                    const toolNamesStr = toolNames.join(", ");
+                    result.push({
+                        role: "assistant",
+                        parts: [{
+                                type: "text",
+                                text: `[tool: ${toolNamesStr}]`,
+                            }],
+                    });
+                }
+            }
+        }
     }
     return { messages: result, newCount: count };
 }

package/index.ts

@@ -22,7 +22,7 @@ import {
 import {
   clampScore,
   postProcessMemories,
-  formatMemoryLines,
+  pickMemoriesForInjection,
 } from "./memory-ranking.js";
 import { withTimeout } from "./process-manager.js";
 import {
@@ -150,6 +150,44 @@ type MemorySearchInput = {
   limit?: number;
 };
 
+type ToolResultRef = {
+  sessionId: string;
+  toolResultId: string;
+  ref: string;
+};
+
+function parseToolResultRef(value: unknown): ToolResultRef | null {
+  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: unknown, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+
+function getPositiveInteger(value: unknown, fallback: number): number {
+  return Math.max(1, getOptionalInteger(value, fallback));
+}
+
 type OpenClawPluginApi = {
   pluginConfig?: unknown;
   logger: PluginLogger;
@@ -1090,29 +1128,58 @@ const contextEnginePlugin = {
             };
           }
 
-          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,
             },
           };
         },
@@ -1531,6 +1598,285 @@ const contextEnginePlugin = {
       },
     }), { name: "ov_archive_expand" });
 
+    api.registerTool(
+      (ctx: ToolContext) => ({
+        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: string, params: Record<string, unknown>) {
+          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: ToolContext) => ({
+        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: string, params: Record<string, unknown>) {
+          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: ToolContext) => ({
+        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: string, params: Record<string, unknown>) {
+          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: ContextEngineWithCommit | null = null;
     const sessionAgentResolver = createSessionAgentResolver(cfg.agent_prefix);
     const rememberSessionAgentId = (ctx: SessionAgentLookup) => {

package/openclaw.plugin.json

@@ -19,7 +19,10 @@
       "memory_store",
       "memory_forget",
       "ov_archive_search",
-      "ov_archive_expand"
+      "ov_archive_expand",
+      "openviking_tool_result_read",
+      "openviking_tool_result_search",
+      "openviking_tool_result_list"
     ]
   },
   "commandAliases": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openviking/openclaw-plugin",
-  "version": "2026.5.10-dev.3",
+  "version": "2026.5.21",
   "displayName": "OpenViking",
   "description": "OpenClaw context-engine plugin — OpenViking AI memory, long-term memory, knowledge base, semantic search, RAG, context engine. 长期记忆 · 知识库 · 语义检索 · 上下文引擎",
   "type": "module",
@@ -30,6 +30,7 @@
     "INSTALL.md",
     "INSTALL-ZH.md",
     "INSTALL-AGENT.md",
+    "images/",
     "skills/"
   ],
   "scripts": {
@@ -48,7 +49,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/volcengine/OpenViking.git"
+    "url": "https://github.com/volcengine/OpenViking"
   },
   "homepage": "https://github.com/volcengine/OpenViking/tree/main/examples/openclaw-plugin",
   "license": "MIT",