@hheei/pi-ext-ui 0.6.0 → 0.7.1

package/dist/renderer.js

@@ -1,43 +1,34 @@
-import { getLanguageFromPath, highlightCode, } from "@earendil-works/pi-coding-agent";
+import { highlightCode, } from "@earendil-works/pi-coding-agent";
 import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { agentResultText, getRegisteredToolPresentationProvider, getRegisteredToolRenderers, getToolPresentationProvider, hasOptionalToolRenderers, } from "@hheei/pi-ext-core";
 import { DiffView } from "./diff-view.js";
 import { NestedCallsView } from "./nested-calls-view.js";
 import { formatToolHeaderText, ToolView, } from "./tool-view.js";
-import { getCapturedNestedCalls, recordToolExecutionEnd, recordToolExecutionStart, } from "./tracker.js";
 /**
  * Upstream tools whose call and result views pi-ext-ui still frames itself. Concrete tool packages
  * own their own presentation through ext-core's optional renderer point, so their names never
  * appear here.
  */
 export const SPECIALIZED_TOOL_RENDERERS = ["codemode"];
-import { callStatsParts, estimateStreamingTokens, extractCodemodeHeaderFacts, extractHeavyInputCommand, extractNestedCalls, extractResultText, extractSummaryArg, formatCostUsd, formatDurationMs, inlinePresentation, isRecord, resolveContainerStatus, } from "./payload-parser.js";
-export { estimateStreamingTokens, inlinePresentation, } from "./payload-parser.js";
+import { inlinePresentation, nativeHeaderSummary, nativeHeavyRequest, nativeOutputLanguage, nativeRequestBlock, nativeResultText, nativeTimeoutFact, } from "./native-tools.js";
+import { callStatsParts, estimateStreamingTokens, extractNestedCalls, formatCostUsd, formatDurationMs, isRecord, RESOLVED_CALLS_KEY, resolveContainerStatus, } from "./payload-parser.js";
+export { extractChildToolCopyText, inlinePresentation } from "./native-tools.js";
+export { estimateStreamingTokens, } from "./payload-parser.js";
 const SPECIALIZED_TOOL_SET = new Set(SPECIALIZED_TOOL_RENDERERS);
 const CALL_VIEW_STATE_KEY = "__piExtUiCallView";
-function detectCodeLanguage(toolName) {
-    if (toolName === "bash")
-        return "bash";
-    if (toolName === "codemode")
-        return "javascript";
-    if (toolName === "python_eval")
-        return "python";
-    return undefined;
-}
 function createInputCodeSection(toolName, args, theme, railToken = "muted") {
-    const raw = extractHeavyInputCommand(toolName, args);
-    if (raw === undefined || raw === "")
+    const block = nativeRequestBlock(toolName, args);
+    if (block === undefined)
         return undefined;
-    const isShell = toolName === "bash";
-    const clean = raw.replace(/\r/g, "").replace(/\t/g, "  ");
-    const lang = detectCodeLanguage(toolName);
+    // Display only: the request is model-controlled input, while its copy stays byte-exact.
+    const clean = stripTerminalSequences(block.text.trim()).replace(/\r/g, "").replace(/\t/g, "  ");
     let lines;
-    if (isShell) {
+    if (block.shell) {
         lines = clean.split("\n").map((line, i) => (i === 0 ? `$ ${line}` : `  ${line}`));
     }
     else {
         try {
-            lines = highlightCode(clean, lang);
+            lines = highlightCode(clean, block.language);
         }
         catch {
             lines = clean.split("\n").map((line) => theme.fg("mdCode", line));
@@ -45,44 +36,97 @@ function createInputCodeSection(toolName, args, theme, railToken = "muted") {
     }
     return { railToken, content: lines };
 }
-function resolveToolCallSummary(params) {
-    const { toolName, args, originalRenderCall, theme, context } = params;
-    if (toolName === "codemode") {
-        return extractCodemodeHeaderFacts(args);
-    }
-    // Tier 1: Host Native RenderCall Delegation
-    if (originalRenderCall !== undefined) {
-        try {
-            const upstreamContext = { ...context, lastComponent: undefined };
-            const upstreamLines = originalRenderCall(args, theme, upstreamContext).render(120);
-            const firstNonEmpty = upstreamLines
-                .map((line) => stripTerminalSequences(line).trim())
-                .find((line) => line !== "");
-            if (firstNonEmpty !== undefined) {
-                if (firstNonEmpty.startsWith("$ ")) {
-                    return firstNonEmpty.slice(2).trim();
-                }
-                if (firstNonEmpty === toolName) {
-                    return "";
-                }
-                if (firstNonEmpty.startsWith(toolName) &&
-                    /^[\s(:=/[]/.test(firstNonEmpty.slice(toolName.length))) {
-                    return firstNonEmpty.slice(toolName.length).trim();
-                }
-                return firstNonEmpty;
-            }
-        }
-        catch {
-            // Upstream threw, fall through to fallback
-        }
+/**
+ * The one-row argument line a native generic tool row shows. It states the arguments as given, so a
+ * tool with no vocabulary of its own keeps the information its native row carried without this
+ * frame rendering and parsing that row.
+ */
+function genericArgsLine(args) {
+    if (typeof args === "string")
+        return stripTerminalSequences(args.trim());
+    if (!isRecord(args))
+        return "";
+    const pairs = Object.entries(args)
+        .map(([key, value]) => `${key}=${JSON.stringify(value) ?? String(value)}`)
+        .join(" ");
+    return pairs.length > 100 ? `${pairs.slice(0, 97)}...` : pairs;
+}
+/**
+ * The header facts of one tool row. The tool's own layer states its summary and whether it absorbs the
+ * secondary facts; a tool with no vocabulary of its own states its arguments as given.
+ */
+function toolHeaderFacts(params) {
+    const { toolName, args, theme, cwd, facts, nativeArgsLine } = params;
+    const secondary = facts.filter(Boolean);
+    const meta = secondary.join(" · ");
+    const withMeta = (summary, styled) => ({
+        summary,
+        ...(styled ? { summaryStyled: true } : {}),
+        ...(meta === "" ? {} : { meta }),
+    });
+    const native = nativeHeaderSummary(toolName, args, theme, cwd);
+    if (native !== undefined) {
+        return native.factsInSummary
+            ? { summary: [native.summary, ...secondary].filter(Boolean).join(" · ") }
+            : withMeta(native.summary, native.styled);
     }
-    // Tier 2: Contractual Fallback for built-in tools
-    return extractSummaryArg(toolName, args);
+    const summary = nativeArgsLine === true ? genericArgsLine(args) : "";
+    return { summary: [summary, ...secondary].filter(Boolean).join(" · ") };
 }
 function isCapturedCall(call) {
     return "args" in call || "result" in call;
 }
-/** Nested facts for a consumer that lists children outside the container's own body. */
+/**
+ * The request a persisted child row can still show. A live capture already carries it; otherwise the
+ * host's saved nested-call record for the same id does, as long as it kept the arguments at all.
+ */
+function withSessionArgs(calls, runtime) {
+    return calls.map((call) => {
+        if (isCapturedCall(call))
+            return call;
+        if (call.args !== undefined || call.argsTruncated === true)
+            return call;
+        const fact = runtime.nestedCalls.args(call.id);
+        if (fact === undefined)
+            return call;
+        return {
+            ...call,
+            ...(fact.args === undefined ? {} : { args: fact.args }),
+            ...(fact.truncated
+                ? {
+                    argsTruncated: true,
+                    ...(fact.bytes === undefined ? {} : { argsBytes: fact.bytes }),
+                }
+                : {}),
+        };
+    });
+}
+/** A call counts only when the host proved it resolved; an absent fact is not a negative one. */
+function callResolved(call, live) {
+    if (call.resolved === true)
+        return true;
+    return call.id !== undefined && live?.has(call.id) === true;
+}
+/** The container's own child facts, in the shape the nested board draws and copies. */
+function presentationChildCalls(children) {
+    return children.map((child) => {
+        const status = child.status === "running" || child.status === "streaming"
+            ? "running"
+            : child.status === "warn"
+                ? "cancelled"
+                : child.status === "error"
+                    ? "error"
+                    : "ok";
+        return {
+            toolName: child.title,
+            ...(child.id === undefined ? {} : { id: child.id }),
+            ...(child.summary === undefined ? {} : { summary: child.summary }),
+            status,
+            ...(child.durationMs === undefined ? {} : { durationMs: child.durationMs }),
+        };
+    });
+}
+/** Nested call facts for a consumer that counts or aggregates them outside the container's body. */
 function nestedChildren(calls) {
     return calls.map((call) => {
         if (isCapturedCall(call)) {
@@ -99,9 +143,6 @@ function nestedChildren(calls) {
                         ? "running"
                         : "ok",
                 ...(call.durationMs === undefined ? {} : { durationMs: call.durationMs }),
-                ...(call.result === undefined
-                    ? {}
-                    : { detail: extractResultText(call.toolName, call.result).outputText }),
             };
         }
         return {
@@ -116,7 +157,6 @@ function nestedChildren(calls) {
                         ? "error"
                         : "ok",
             ...(call.durationMs === undefined ? {} : { durationMs: call.durationMs }),
-            ...(call.error === undefined ? {} : { detail: call.error }),
         };
     });
 }
@@ -156,7 +196,7 @@ function hideCallView(context) {
     if (view instanceof ToolView)
         view.hide();
 }
-function formatNestedCallRow(call, theme) {
+function formatNestedCallRow(call, theme, cwd) {
     const inline = inlinePresentation(call.toolName, call.summary, undefined, call.isError === true);
     const status = call.status === "running"
         ? "running"
@@ -167,13 +207,20 @@ function formatNestedCallRow(call, theme) {
         ? ""
         : stripTerminalSequences(call.summary.trim());
     const truncatedArgs = cleanArgs.length > 72 ? `${cleanArgs.slice(0, 69)}…` : cleanArgs;
-    const costText = formatCostUsd(call.cost);
+    const header = toolHeaderFacts({
+        toolName: call.toolName,
+        args: call.summary,
+        theme,
+        cwd,
+        facts: [formatDurationMs(call.durationMs), formatCostUsd(call.cost)],
+    });
+    // A record's arguments may be a summary the container already flattened; fall back to it rather
+    // than drop the only text the row has.
     return formatToolHeaderText({
         status,
         title: call.toolName,
-        summary: [inline?.summary ?? truncatedArgs, formatDurationMs(call.durationMs), costText]
-            .filter(Boolean)
-            .join(" · "),
+        ...header,
+        summary: header.summary || (inline?.summary ?? truncatedArgs),
     }, theme);
 }
 export function isMcpTool(toolName) {
@@ -196,25 +243,34 @@ function shouldInterceptTool(toolName, options) {
     return true;
 }
 function renderGenericResult(params) {
-    const { toolName, theme, context, result, renderOptions, defaultLevel, originalRenderCall, originalRenderResult, resolvePresentation, resolveNativeRenderer, options, } = params;
-    const heavyCmd = extractHeavyInputCommand(toolName, context.args);
+    const { runtime, toolName, theme, context, result, renderOptions, defaultLevel, nativeArgsLine, originalRenderResult, resolvePresentation, resolveNativeRenderer, options, } = params;
+    const heavyCmd = nativeHeavyRequest(toolName, context.args);
     const nestedCalls = extractNestedCalls(result);
     const captured = toolName === "codemode"
-        ? (getCapturedNestedCalls(context.toolCallId) ??
+        ? (runtime.tracker.getCaptured(context.toolCallId) ??
             (isRecord(result.details) &&
                 Array.isArray(result.details.__piExtUiCapturedCalls)
                 ? result.details
                     .__piExtUiCapturedCalls
                 : undefined))
         : undefined;
-    const childCalls = captured ?? nestedCalls;
+    const childCalls = withSessionArgs(captured ?? nestedCalls, runtime);
+    const liveResolved = runtime.tracker.getResolved(context.toolCallId);
+    const resolvedCalls = childCalls.filter((call) => callResolved(call, liveResolved));
+    const unknownCallCount = childCalls.length - resolvedCalls.length;
     const isMetaTool = toolName === "codemode" || toolName === "subagent" || childCalls.length > 0;
-    const { outputText: rawOutput, wallTimeSeconds } = extractResultText(toolName, result);
+    const { outputText: rawOutput, wallTimeSeconds } = nativeResultText(toolName, result);
     const isError = (context.isError ?? false) || (result.isError ?? false);
     const status = toolName === "codemode"
-        ? childCalls.length === 0 && isError
-            ? "error"
-            : "none"
+        ? childCalls.length > 0
+            ? "none"
+            : isError
+                ? "error"
+                : renderOptions.isPartial === true
+                    ? context.argsComplete
+                        ? "running"
+                        : "streaming"
+                    : "none"
         : isMetaTool
             ? resolveContainerStatus({
                 isError,
@@ -227,42 +283,47 @@ function renderGenericResult(params) {
                 : renderOptions.isPartial
                     ? "running"
                     : "ok";
-    const summaryParts = [];
-    const argSummary = resolveToolCallSummary({
-        toolName,
-        args: context.args,
-        originalRenderCall,
-        theme,
-        context,
-    });
-    if (argSummary !== "")
-        summaryParts.push(argSummary);
+    const facts = [];
     if (isMetaTool && childCalls.length > 0) {
-        const failCount = childCalls.filter((c) => Boolean(c.isError || ("status" in c && c.status === "error"))).length;
-        summaryParts.push(...callStatsParts(childCalls.length, failCount));
+        // Only a proven resolution is a call; the rest stay visible as unknown instead of counting.
+        const failCount = resolvedCalls.filter((c) => Boolean(c.isError || ("status" in c && c.status === "error"))).length;
+        facts.push(...callStatsParts(resolvedCalls.length, failCount));
+        if (unknownCallCount > 0)
+            facts.push(`${String(unknownCallCount)} unknown`);
     }
     if (context.durationMs !== undefined) {
-        summaryParts.push(formatDurationMs(context.durationMs));
+        facts.push(formatDurationMs(context.durationMs));
     }
     else if (wallTimeSeconds !== undefined && Number.isFinite(wallTimeSeconds)) {
-        summaryParts.push(formatDurationMs(wallTimeSeconds * 1000));
+        facts.push(formatDurationMs(wallTimeSeconds * 1000));
     }
     const totalCost = childCalls.reduce((sum, c) => sum + (c.cost ?? 0), 0);
-    if (totalCost > 0) {
-        summaryParts.push(formatCostUsd(totalCost));
-    }
-    const summary = summaryParts.join(" · ");
+    if (totalCost > 0)
+        facts.push(formatCostUsd(totalCost));
+    const timeout = nativeTimeoutFact(toolName, context.args);
+    if (timeout !== undefined)
+        facts.unshift(timeout);
+    const header = toolHeaderFacts({
+        toolName,
+        args: context.args,
+        theme,
+        cwd: context.cwd,
+        facts,
+        nativeArgsLine,
+    });
     const codemodeNestedView = toolName === "codemode" && childCalls.length > 0
         ? new NestedCallsView({
             calls: childCalls,
             theme,
             context,
+            headerSummary: (childName, childArgs, childTheme) => nativeHeaderSummary(childName, childArgs, childTheme, context.cwd)?.summary,
             resolveChildRenderer: (childName) => {
                 return {
                     renderResult: (childResult, childOptions, childTheme, childCtx) => {
                         const provider = resolvePresentation?.(childName);
                         if (provider !== undefined) {
                             return renderOwnedPresentation({
+                                runtime,
                                 toolName: childName,
                                 presentation: provider(childCtx.args, childResult, childTheme, childCtx),
                                 result: childResult,
@@ -276,13 +337,14 @@ function renderGenericResult(params) {
                         }
                         const registered = resolveNativeRenderer?.(childName);
                         return renderGenericResult({
+                            runtime,
                             toolName: childName,
                             theme: childTheme,
                             context: childCtx,
                             result: childResult,
                             renderOptions: childOptions,
                             defaultLevel: childOptions.expanded ? 2 : 1,
-                            originalRenderCall: registered?.renderCall,
+                            nativeArgsLine: registered?.renderCall !== undefined,
                             originalRenderResult: registered?.renderResult,
                             resolvePresentation,
                             resolveNativeRenderer,
@@ -301,7 +363,7 @@ function renderGenericResult(params) {
     const collapsedRows = codemodeNestedView !== undefined
         ? codemodeNestedView
         : isMetaTool && nestedCalls.length > 0
-            ? nestedCalls.map((call) => formatNestedCallRow(call, theme))
+            ? nestedCalls.map((call) => formatNestedCallRow(call, theme, context.cwd))
             : undefined;
     const toolRailToken = isError
         ? "error"
@@ -335,6 +397,7 @@ function renderGenericResult(params) {
     }
     else if (originalRenderResult !== undefined) {
         const viewProbe = new ToolView({
+            background: () => runtime.backgrounds,
             theme,
             header: { title: toolName },
             stateHolder: context.state,
@@ -349,18 +412,13 @@ function renderGenericResult(params) {
         let lastUpstreamComponent;
         const lazyUpstreamComponent = {
             render(w) {
-                try {
-                    const upstreamContext = {
-                        ...context,
-                        lastComponent: lastUpstreamComponent,
-                    };
-                    const comp = originalRenderResult(result, effectiveOptions, theme, upstreamContext);
-                    lastUpstreamComponent = comp;
-                    return comp.render(w);
-                }
-                catch {
-                    return rawOutput !== "" ? rawOutput.split("\n") : [];
-                }
+                const upstreamContext = {
+                    ...context,
+                    lastComponent: lastUpstreamComponent,
+                };
+                const comp = originalRenderResult(result, effectiveOptions, theme, upstreamContext);
+                lastUpstreamComponent = comp;
+                return comp.render(w);
             },
             invalidate() { },
         };
@@ -384,7 +442,7 @@ function renderGenericResult(params) {
     if (toolName === "codemode") {
         copy = undefined;
     }
-    else if (heavyCmd !== undefined && heavyCmd !== "") {
+    else if (heavyCmd !== undefined) {
         const cleanOutput = stripTerminalSequences(rawOutput);
         copy = {
             primary: heavyCmd,
@@ -400,15 +458,15 @@ function renderGenericResult(params) {
         };
     }
     return new ToolView({
+        background: () => runtime.backgrounds,
         theme,
-        header: {
-            title: toolName,
-            status,
-            summary,
-        },
+        header: { title: toolName, status, ...header },
         railToken: toolRailToken,
         collapsedRows,
         ...(children.length === 0 ? {} : { children }),
+        // A container with child facts states its effective count, including zero: a container whose
+        // children all failed to resolve is not one call.
+        ...(childCalls.length === 0 ? {} : { childCount: resolvedCalls.length }),
         sections,
         copy,
         outputPad: context.outputPad,
@@ -424,7 +482,7 @@ function renderGenericResult(params) {
  * pass never asks the tool to rebuild its rows.
  */
 function renderOwnedPresentation(params) {
-    const { toolName, presentation, result, theme, context, defaultLevel, resolvePresentation, resolveNativeRenderer, options, } = params;
+    const { runtime, toolName, presentation, result, theme, context, defaultLevel, resolvePresentation, resolveNativeRenderer, options, } = params;
     const isError = context.isError || result?.isError === true;
     const pending = result === undefined || context.isPartial;
     const isDiff = !isError && !pending && presentation.kind === "diff";
@@ -465,26 +523,16 @@ function renderOwnedPresentation(params) {
     }
     else if (output !== "") {
         const rawLines = stripTerminalSequences(output).split("\n");
+        const lang = nativeOutputLanguage(toolName, context.args);
         let styledLines;
         if (isError) {
             styledLines = rawLines.map((line) => theme.fg("error", line));
         }
-        else if (toolName === "read") {
-            const rawPath = isRecord(context.args) && typeof context.args.path === "string"
-                ? context.args.path
-                : isRecord(context.args) && typeof context.args.file_path === "string"
-                    ? context.args.file_path
-                    : "";
-            const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
-            if (lang !== undefined) {
-                try {
-                    styledLines = highlightCode(output.replace(/\t/g, "  "), lang);
-                }
-                catch {
-                    styledLines = rawLines.map((line) => theme.fg("toolOutput", line));
-                }
+        else if (lang !== undefined) {
+            try {
+                styledLines = highlightCode(output.replace(/\t/g, "  "), lang);
             }
-            else {
+            catch {
                 styledLines = rawLines.map((line) => theme.fg("toolOutput", line));
             }
         }
@@ -497,22 +545,18 @@ function renderOwnedPresentation(params) {
         });
     }
     const duration = result === undefined ? "" : formatDurationMs(context.durationMs);
-    const summary = [stripTerminalSequences(presentation.summary), duration]
-        .filter(Boolean)
-        .join(" · ");
-    const copy = presentation.copy === undefined
-        ? isDiff && presentation.diff.trim() !== ""
-            ? { primary: presentation.diff }
-            : undefined
-        : {
-            primary: stripTerminalSequences(presentation.copy.primary),
-            ...(presentation.copy.full === undefined
-                ? {}
-                : { full: stripTerminalSequences(presentation.copy.full) }),
-        };
+    // The provider owns the request/output boundary; cleaning its payload here corrupts raw input.
+    const copy = presentation.copy ??
+        (isDiff && presentation.diff.trim() !== "" ? { primary: presentation.diff } : undefined);
     return new ToolView({
+        background: () => runtime.backgrounds,
         theme,
-        header: { title: toolName, status, summary },
+        header: {
+            title: toolName,
+            status,
+            summary: stripTerminalSequences(presentation.summary),
+            ...(duration === "" ? {} : { meta: duration }),
+        },
         railToken,
         // The tool owns the folded rows and their tones; the frame only sanitizes them for the host.
         collapsedRows: (() => {
@@ -520,23 +564,29 @@ function renderOwnedPresentation(params) {
                 return presentation.collapsedRows;
             }
             const captured = result !== undefined
-                ? (getCapturedNestedCalls(context.toolCallId) ??
+                ? (runtime.tracker.getCaptured(context.toolCallId) ??
                     (isRecord(result.details) && Array.isArray(result.details.__piExtUiCapturedCalls)
                         ? result.details.__piExtUiCapturedCalls
                         : undefined))
                 : undefined;
             const nestedCalls = extractNestedCalls(result);
-            const childCalls = captured ?? nestedCalls;
+            // The owner's own child facts win over parsing another package's details.
+            const ownCalls = presentation.children === undefined
+                ? nestedCalls
+                : presentationChildCalls(presentation.children);
+            const childCalls = withSessionArgs(captured ?? ownCalls, runtime);
             if (childCalls.length > 0) {
                 return new NestedCallsView({
                     calls: childCalls,
                     theme,
                     context,
+                    headerSummary: (childName, childArgs, childTheme) => nativeHeaderSummary(childName, childArgs, childTheme, context.cwd)?.summary,
                     resolveChildRenderer: (childName) => ({
                         renderResult: (childResult, childOptions, childTheme, childCtx) => {
                             const childProvider = resolvePresentation?.(childName);
                             if (childProvider !== undefined) {
                                 return renderOwnedPresentation({
+                                    runtime,
                                     toolName: childName,
                                     presentation: childProvider(childCtx.args, childResult, childTheme, childCtx),
                                     result: childResult,
@@ -550,13 +600,14 @@ function renderOwnedPresentation(params) {
                             }
                             const registered = resolveNativeRenderer?.(childName);
                             return renderGenericResult({
+                                runtime,
                                 toolName: childName,
                                 theme: childTheme,
                                 context: childCtx,
                                 result: childResult,
                                 renderOptions: childOptions,
                                 defaultLevel: childOptions.expanded ? 2 : 1,
-                                originalRenderCall: registered?.renderCall,
+                                nativeArgsLine: registered?.renderCall !== undefined,
                                 originalRenderResult: registered?.renderResult,
                                 resolvePresentation,
                                 resolveNativeRenderer,
@@ -589,10 +640,10 @@ function renderOwnedPresentation(params) {
         copyToClipboard: options?.copyToClipboard,
     });
 }
-export function createCollapsibleToolRendererResolver(options) {
-    return createRendererResolver(options);
+export function createCollapsibleToolRendererResolver(runtime, options) {
+    return createRendererResolver(runtime, options);
 }
-function createRendererResolver(options, resolvePresentation, resolveNativeRenderer) {
+function createRendererResolver(runtime, options, resolvePresentation, resolveNativeRenderer) {
     const defaultLevel = options?.defaultCollapsed === false ? 1 : 0;
     return (toolName, next) => {
         const upstream = next();
@@ -603,7 +654,7 @@ function createRendererResolver(options, resolvePresentation, resolveNativeRende
             return upstream;
         }
         const registeredNative = resolveNativeRenderer?.(toolName);
-        const originalRenderCall = upstream?.renderCall ?? registeredNative?.renderCall;
+        const nativeArgsLine = upstream?.renderCall !== undefined || registeredNative?.renderCall !== undefined;
         const originalRenderResult = upstream?.renderResult ?? registeredNative?.renderResult;
         return {
             renderShell: "self",
@@ -611,6 +662,7 @@ function createRendererResolver(options, resolvePresentation, resolveNativeRende
                 if (provider !== undefined) {
                     const callContext = { ...context, args };
                     const view = renderOwnedPresentation({
+                        runtime,
                         toolName,
                         presentation: provider(args, undefined, theme, callContext),
                         theme,
@@ -626,26 +678,14 @@ function createRendererResolver(options, resolvePresentation, resolveNativeRende
                 const isStreamingArgs = context.isPartial && !context.argsComplete;
                 const status = context.isError
                     ? "error"
-                    : toolName === "codemode"
-                        ? "none"
-                        : isStreamingArgs
-                            ? "streaming"
-                            : "running";
-                let summary = "";
-                if (isStreamingArgs) {
-                    const tokens = estimateStreamingTokens(args);
-                    summary = tokens > 0 ? `· ${String(tokens)} tokens` : "";
-                }
-                else {
-                    summary = resolveToolCallSummary({
-                        toolName,
-                        args,
-                        originalRenderCall,
-                        theme,
-                        context,
-                    });
-                }
-                const heavyCmd = extractHeavyInputCommand(toolName, args);
+                    : isStreamingArgs
+                        ? "streaming"
+                        : "running";
+                const streamedTokens = isStreamingArgs ? estimateStreamingTokens(args) : 0;
+                const header = isStreamingArgs
+                    ? { summary: streamedTokens > 0 ? `· ${String(streamedTokens)} tokens` : "" }
+                    : toolHeaderFacts({ toolName, args, theme, cwd: context.cwd, facts: [], nativeArgsLine });
+                const heavyCmd = nativeHeavyRequest(toolName, args);
                 const sections = [];
                 const inputSection = createInputCodeSection(toolName, args, theme);
                 if (inputSection !== undefined) {
@@ -660,18 +700,15 @@ function createRendererResolver(options, resolvePresentation, resolveNativeRende
                         });
                     }
                 }
-                const copy = heavyCmd !== undefined && heavyCmd !== ""
+                const copy = heavyCmd !== undefined
                     ? { primary: heavyCmd }
                     : formatArgsPreview(args) !== ""
                         ? { primary: formatArgsPreview(args) }
                         : undefined;
                 const view = new ToolView({
+                    background: () => runtime.backgrounds,
                     theme,
-                    header: {
-                        title: toolName,
-                        status,
-                        summary,
-                    },
+                    header: { title: toolName, status, ...header },
                     sections,
                     copy,
                     outputPad: context.outputPad,
@@ -698,6 +735,7 @@ function createRendererResolver(options, resolvePresentation, resolveNativeRende
                 hideCallView(context);
                 if (presentation !== undefined) {
                     return renderOwnedPresentation({
+                        runtime,
                         toolName,
                         presentation,
                         result,
@@ -709,13 +747,14 @@ function createRendererResolver(options, resolvePresentation, resolveNativeRende
                     });
                 }
                 return renderGenericResult({
+                    runtime,
                     toolName,
                     theme,
                     context,
                     result,
                     renderOptions,
                     defaultLevel,
-                    originalRenderCall,
+                    nativeArgsLine,
                     originalRenderResult,
                     resolvePresentation,
                     resolveNativeRenderer,
@@ -726,24 +765,50 @@ function createRendererResolver(options, resolvePresentation, resolveNativeRende
     };
 }
 /** UI factory consumed by package-owned direct renderers, independently of host resolver precedence. */
-export function createOptionalToolRendererFactory(pi, options) {
-    return (name, native) => createRendererResolver({ ...options, tools: [name] }, (toolName) => getRegisteredToolPresentationProvider(pi, toolName), (toolName) => getRegisteredToolRenderers(pi, toolName))(name, () => native) ?? native;
+export function createOptionalToolRendererFactory(pi, runtime, options) {
+    return (name, native) => createRendererResolver(runtime, { ...options, tools: [name] }, (toolName) => getRegisteredToolPresentationProvider(pi, toolName), (toolName) => getRegisteredToolRenderers(pi, toolName))(name, () => native) ?? native;
 }
-export function registerCollapsibleToolRenderer(pi, options) {
-    const disposers = [];
-    if (typeof pi.on === "function") {
-        const unbindStart = pi.on("tool_execution_start", (event) => {
-            recordToolExecutionStart(event);
-        });
-        if (typeof unbindStart === "function")
-            disposers.push(unbindStart);
-        const unbindEnd = pi.on("tool_execution_end", (event) => {
-            recordToolExecutionEnd(event);
-        });
-        if (typeof unbindEnd === "function")
-            disposers.push(unbindEnd);
-    }
-    pi.registerToolRenderer(createRendererResolver(options, (name) => getRegisteredToolPresentationProvider(pi, name), (name) => getRegisteredToolRenderers(pi, name)));
+/**
+ * Save the resolution facts of one model-issued call on its own tool result. The host emits
+ * `tool_call` only after the tool resolved and its arguments validated, so these ids are proof;
+ * writing them into the details keeps the fact with the call through resume, fork and reload.
+ */
+function withResolvedCallFacts(event, runtime) {
+    if (event.parentToolCallId !== undefined)
+        return undefined;
+    const ids = runtime.tracker.getResolved(event.toolCallId);
+    if (ids === undefined || ids.size === 0)
+        return undefined;
+    if (!isRecord(event.details))
+        return undefined;
+    return { ...event.details, [RESOLVED_CALLS_KEY]: [...ids] };
+}
+export function registerCollapsibleToolRenderer(pi, runtime, options) {
+    const disposers = [
+        pi.on("tool_execution_start", (event) => {
+            runtime.tracker.recordStart(event);
+        }),
+        pi.on("tool_execution_end", (event) => {
+            runtime.tracker.recordEnd(event);
+        }),
+        pi.on("tool_call", (event) => {
+            runtime.tracker.recordResolved(event);
+        }),
+        pi.on("tool_result", (event) => {
+            const details = withResolvedCallFacts(event, runtime);
+            if (details === undefined)
+                return undefined;
+            // The hook replaces the whole result, so the fields it does not own pass through.
+            return {
+                details,
+                ...(event.structuredContent === undefined
+                    ? {}
+                    : { structuredContent: event.structuredContent }),
+                ...(event.usage === undefined ? {} : { usage: event.usage }),
+            };
+        }),
+    ];
+    pi.registerToolRenderer(createRendererResolver(runtime, options, (name) => getRegisteredToolPresentationProvider(pi, name), (name) => getRegisteredToolRenderers(pi, name)));
     return () => {
         for (const dispose of disposers)
             dispose();