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

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
@@ -176,13 +205,13 @@ export function parseAddSkillCommandArgs(args) {
         timeout: getNumberFlag(parsed.flags, "timeout"),
     };
 }
-export function parseMemorySearchCommandArgs(args) {
+export function parseOVSearchCommandArgs(args) {
     const parsed = parseFlagArgs(args);
-    // `/memory-search` only accepts a single query string, so positional segments are
+    // `/ov-search` only accepts a single query string, so positional segments are
     // always re-joined to preserve unquoted multi-word searches.
     const query = parsed.positionals.join(" ").trim();
     if (!query) {
-        throw new Error('Usage: /memory-search "<query>" [--uri URI] [--limit N]');
+        throw new Error('Usage: /ov-search "<query>" [--uri URI] [--limit N]');
     }
     return {
         query,
@@ -453,7 +482,7 @@ const contextEnginePlugin = {
                 total: memories.length + resources.length + skills.length,
             };
         };
-        const formatMemorySearchRows = (result) => {
+        const formatOVSearchRows = (result) => {
             const truncateSummary = (value, maxChars = 220) => {
                 const collapsed = value.replace(/\s+/g, " ").trim();
                 if (collapsed.length <= maxChars) {
@@ -490,7 +519,7 @@ const contextEnginePlugin = {
                 }),
             ];
         };
-        const formatMemorySearchText = (query, uri, result) => {
+        const formatOVSearchText = (query, uri, result) => {
             if ((result.total ?? 0) <= 0) {
                 const scope = uri ? ` under ${uri}` : "";
                 return `No OpenViking resource or skill results found for "${query}"${scope}.`;
@@ -499,11 +528,11 @@ const contextEnginePlugin = {
             const lines = [
                 `Found ${result.total ?? 0} OpenViking results for "${query}"${scope}`,
                 "",
-                ...formatMemorySearchRows(result),
+                ...formatOVSearchRows(result),
             ].filter((line, index, all) => line || (all[index - 1] && all[index + 1]));
             return lines.join("\n");
         };
-        const memorySearchOpenViking = async (input, agentId) => {
+        const searchOpenViking = async (input, agentId) => {
             const query = input.query.trim();
             if (!query) {
                 throw new Error("query is required");
@@ -543,7 +572,7 @@ const contextEnginePlugin = {
                 result = mergeFindResults(successful);
             }
             return {
-                content: [{ type: "text", text: formatMemorySearchText(query, input.uri, result) }],
+                content: [{ type: "text", text: formatOVSearchText(query, input.uri, result) }],
                 details: {
                     action: "searched",
                     query,
@@ -610,8 +639,8 @@ const contextEnginePlugin = {
             },
         }), { name: "add_skill" });
         api.registerTool((ctx) => ({
-            name: "memory_search",
-            label: "Memory Search (OpenViking)",
+            name: "ov_search",
+            label: "Search (OpenViking)",
             description: "Search OpenViking resources and skills. Use after importing, or when the user asks to search OpenViking resources or skills.",
             parameters: Type.Object({
                 query: Type.String({ description: "Search query" }),
@@ -620,16 +649,16 @@ const contextEnginePlugin = {
             }),
             async execute(_toolCallId, params) {
                 if (isBypassedSession(ctx)) {
-                    return makeBypassedToolResult("memory_search");
+                    return makeBypassedToolResult("ov_search");
                 }
                 const session = resolvePluginSessionRouting(ctx);
-                return memorySearchOpenViking({
+                return searchOpenViking({
                     query: String(params.query ?? ""),
                     uri: typeof params.uri === "string" ? params.uri : undefined,
                     limit: typeof params.limit === "number" ? params.limit : undefined,
                 }, session.agentId);
             },
-        }), { name: "memory_search" });
+        }), { name: "ov_search" });
         api.registerCommand?.({
             name: "add-resource",
             description: "Add a resource into OpenViking.",
@@ -671,22 +700,22 @@ const contextEnginePlugin = {
             },
         });
         api.registerCommand?.({
-            name: "memory-search",
+            name: "ov-search",
             description: "Search OpenViking resources and skills.",
             acceptsArgs: true,
             handler: async (ctx) => {
                 try {
                     if (isBypassedSession(ctx)) {
-                        const bypassed = makeBypassedToolResult("memory_search");
+                        const bypassed = makeBypassedToolResult("ov_search");
                         return { text: bypassed.content[0].text, details: bypassed.details };
                     }
                     const session = resolvePluginSessionRouting(ctx);
-                    const input = parseMemorySearchCommandArgs(ctx.args ?? "");
-                    const result = await memorySearchOpenViking(input, session.agentId);
+                    const input = parseOVSearchCommandArgs(ctx.args ?? "");
+                    const result = await searchOpenViking(input, session.agentId);
                     return { text: result.content[0].text, details: result.details };
                 }
                 catch (err) {
-                    return { text: `OpenViking memory search failed: ${err instanceof Error ? err.message : String(err)}` };
+                    return { text: `OpenViking search failed: ${err instanceof Error ? err.message : String(err)}` };
                 }
             },
         });
@@ -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) => {