@hheei/pi-ext-ui 0.0.0-stage → 0.2.0

package/dist/extension.js

@@ -0,0 +1,4 @@
+import { registerCollapsibleToolRenderer } from "./renderer.js";
+export default function (pi) {
+    registerCollapsibleToolRenderer(pi);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { type DiffHunk, type DiffLine, type DiffSource, type DiffStats, DiffView, type DiffViewOptions, diffStats, } from "./diff-view.js";
+export { extractChildToolCopyText, NestedCallsView, type NestedCallsViewProps, } from "./nested-calls-view.js";
+export { type CollapsibleToolRendererOptions, createCollapsibleToolRendererResolver, estimateStreamingTokens, inlinePresentation, type NestedCallRecord, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, type SpecializedToolRendererName, type ToolRenderContext, WEB_ACCESS_TOOLS, type WebAccessToolName, } from "./renderer.js";
+export { type Collapsible, createToolView, type FoldLevel, formatStatusGlyph, formatToolHeaderText, isCollapsible, type RailColorToken, type RailSection, type ToolStatusKind, ToolView, type ToolViewCopySpec, type ToolViewHeaderSpec, type ToolViewSpec, transitionFoldLevel, } from "./tool-view.js";
+export { type CapturedToolCall, clearCapturedNestedCalls, getCapturedNestedCalls, recordToolExecutionEnd, recordToolExecutionStart, } from "./tracker.js";
+export { formatTurnFlow, type TurnFlowData, type TurnToolCallSummary, } from "./turn-copy.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { DiffView, diffStats, } from "./diff-view.js";
+export { extractChildToolCopyText, NestedCallsView, } from "./nested-calls-view.js";
+export { createCollapsibleToolRendererResolver, estimateStreamingTokens, inlinePresentation, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, WEB_ACCESS_TOOLS, } from "./renderer.js";
+export { createToolView, formatStatusGlyph, formatToolHeaderText, isCollapsible, ToolView, transitionFoldLevel, } from "./tool-view.js";
+export { clearCapturedNestedCalls, getCapturedNestedCalls, recordToolExecutionEnd, recordToolExecutionStart, } from "./tracker.js";
+export { formatTurnFlow, } from "./turn-copy.js";

package/dist/nested-calls-view.d.ts

@@ -0,0 +1,28 @@
+import { type Theme, type ToolRenderers } from "@earendil-works/pi-coding-agent";
+import { type Component, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import type { ToolPresentationProvider } from "@hheei/pi-ext-core";
+import { type NestedCallRecord, type ToolRenderContext } from "./renderer.js";
+import { type Collapsible } from "./tool-view.js";
+import type { CapturedToolCall } from "./tracker.js";
+export declare function extractChildToolCopyText(call: CapturedToolCall | NestedCallRecord, full?: boolean): string;
+export interface NestedCallsViewProps {
+    readonly resolvePresentation?: ((toolName: string) => ToolPresentationProvider | undefined) | undefined;
+    readonly calls: readonly (CapturedToolCall | NestedCallRecord)[];
+    readonly theme: Theme;
+    readonly context: ToolRenderContext;
+    readonly resolveChildRenderer?: ((toolName: string) => ToolRenderers | undefined) | undefined;
+    readonly copyToClipboard?: ((text: string) => Promise<void>) | undefined;
+    readonly stateHolder?: Record<string, unknown> | undefined;
+    readonly invalidate?: (() => void) | undefined;
+}
+export declare const NESTED_CALLS_EXPANDED_KEY = "__pi_ext_ui_nested_expanded__";
+export declare const NESTED_CALLS_COPIED_KEY = "__pi_ext_ui_nested_copied__";
+export declare class NestedCallsView implements Component, Collapsible {
+    #private;
+    constructor(props: NestedCallsViewProps);
+    render(width: number): string[];
+    handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+    dispose(): void;
+    collapseAll(): void;
+    invalidate(): void;
+}

package/dist/nested-calls-view.js

@@ -0,0 +1,406 @@
+import { copyToClipboard as copyToSystemClipboard, getLanguageFromPath, highlightCode, } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
+import { inlinePresentation } from "./renderer.js";
+import { formatToolHeaderText, ToolView, toContentRows, transitionFoldLevel, } from "./tool-view.js";
+function truncate(text, width) {
+    return truncateToWidth(text, Math.max(1, width));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function extractChildToolCopyText(call, full) {
+    const toolName = "toolName" in call ? call.toolName : call.name;
+    const result = "result" in call ? call.result : undefined;
+    const args = "args" in call ? call.args : undefined;
+    if (toolName === "write" && isRecord(args) && typeof args.content === "string") {
+        return args.content;
+    }
+    if (toolName === "apply_patch" && isRecord(args) && typeof args.patch === "string") {
+        return args.patch;
+    }
+    const heavyCommand = toolName === "bash" && isRecord(args) && typeof args.command === "string"
+        ? args.command
+        : (toolName === "python_eval" || toolName === "codemode") &&
+            isRecord(args) &&
+            typeof args.code === "string"
+            ? args.code
+            : undefined;
+    if (heavyCommand !== undefined && heavyCommand.trim() !== "") {
+        if (full !== true)
+            return heavyCommand;
+        const output = resultText(result);
+        return output === undefined ? heavyCommand : `${heavyCommand}\n---\n${output}`;
+    }
+    if (toolName === "edit" && result && isRecord(result.details)) {
+        const editView = result.details.__piExtToolsEditView;
+        if (isRecord(editView) && Array.isArray(editView.ops)) {
+            const opsText = editView.ops
+                .map((op) => isRecord(op) && typeof op.newContent === "string" ? op.newContent : "")
+                .filter(Boolean)
+                .join("\n---\n");
+            if (opsText)
+                return opsText;
+        }
+    }
+    if (result && Array.isArray(result.content)) {
+        const texts = result.content
+            .filter((c) => isRecord(c) && c.type === "text" && typeof c.text === "string")
+            .map((c) => c.text);
+        if (texts.length > 0)
+            return texts.join("\n");
+    }
+    if (args !== undefined) {
+        if (typeof args === "string")
+            return args;
+        try {
+            return JSON.stringify(args, null, 2);
+        }
+        catch {
+            return String(args);
+        }
+    }
+    if ("summary" in call && typeof call.summary === "string") {
+        return call.summary;
+    }
+    return "";
+}
+function resultText(result) {
+    if (result === undefined || !Array.isArray(result.content))
+        return undefined;
+    const texts = result.content
+        .filter((c) => isRecord(c) && c.type === "text" && typeof c.text === "string")
+        .map((c) => c.text);
+    return texts.length === 0 ? undefined : texts.join("\n");
+}
+function formatDuration(ms) {
+    if (ms === undefined || !Number.isFinite(ms))
+        return "";
+    return ms < 1000 ? `${String(Math.round(ms))}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+export const NESTED_CALLS_EXPANDED_KEY = "__pi_ext_ui_nested_expanded__";
+export const NESTED_CALLS_COPIED_KEY = "__pi_ext_ui_nested_copied__";
+export class NestedCallsView {
+    #props;
+    #inMemoryLevels = new Map();
+    #copiedIndex = undefined;
+    #copiedTimer = undefined;
+    #lineMapping = [];
+    #renderCache;
+    constructor(props) {
+        this.#props = props;
+        const state = props.stateHolder;
+        if (state !== undefined) {
+            const stored = state[NESTED_CALLS_EXPANDED_KEY];
+            if (isRecord(stored)) {
+                for (const [k, v] of Object.entries(stored)) {
+                    const idx = Number(k);
+                    if (!Number.isNaN(idx) && (v === 1 || v === 2)) {
+                        this.#inMemoryLevels.set(idx, v);
+                    }
+                }
+            }
+            else if (Array.isArray(stored)) {
+                for (const item of stored) {
+                    if (typeof item === "number") {
+                        this.#inMemoryLevels.set(item, 1);
+                    }
+                }
+            }
+            const copiedState = state[NESTED_CALLS_COPIED_KEY];
+            if (isRecord(copiedState) &&
+                typeof copiedState.index === "number" &&
+                typeof copiedState.until === "number") {
+                const remaining = copiedState.until - Date.now();
+                if (remaining > 0) {
+                    this.#copiedIndex = copiedState.index;
+                    this.#copiedTimer = setTimeout(() => {
+                        this.#copiedIndex = undefined;
+                        this.#renderCache = undefined;
+                        const s = this.#props.stateHolder;
+                        if (s !== undefined) {
+                            delete s[NESTED_CALLS_COPIED_KEY];
+                        }
+                        this.#props.invalidate?.();
+                    }, remaining);
+                    this.#copiedTimer.unref?.();
+                }
+                else {
+                    delete state[NESTED_CALLS_COPIED_KEY];
+                }
+            }
+        }
+    }
+    #getExpansionLevel(index) {
+        const state = this.#props.stateHolder;
+        if (state !== undefined) {
+            const stored = state[NESTED_CALLS_EXPANDED_KEY];
+            if (isRecord(stored)) {
+                const val = stored[String(index)];
+                if (val === 1 || val === 2)
+                    return val;
+            }
+            else if (Array.isArray(stored)) {
+                if (stored.includes(index))
+                    return 1;
+            }
+        }
+        return this.#inMemoryLevels.get(index) ?? 0;
+    }
+    #getLevelsKey() {
+        const parts = [];
+        for (let i = 0; i < this.#props.calls.length; i++) {
+            const level = this.#getExpansionLevel(i);
+            if (level !== 0)
+                parts.push(`${i}:${level}`);
+        }
+        return parts.join(",");
+    }
+    #setExpansionLevel(index, level) {
+        if (level === 0) {
+            this.#inMemoryLevels.delete(index);
+        }
+        else {
+            this.#inMemoryLevels.set(index, level);
+        }
+        this.#renderCache = undefined;
+        const state = this.#props.stateHolder;
+        if (state !== undefined) {
+            const record = {};
+            for (const [k, v] of this.#inMemoryLevels.entries()) {
+                record[String(k)] = v;
+            }
+            state[NESTED_CALLS_EXPANDED_KEY] = record;
+        }
+    }
+    #triggerCopy(callIndex, full) {
+        const call = this.#props.calls[callIndex];
+        if (!call)
+            return;
+        const provider = this.#props.resolvePresentation?.(call.toolName);
+        const presentation = provider?.("args" in call ? call.args : undefined, "result" in call ? call.result : undefined, this.#props.theme);
+        const text = stripTerminalSequences((full ? presentation?.copy?.full : presentation?.copy?.primary) ??
+            extractChildToolCopyText(call, full));
+        if (!text)
+            return;
+        const writeClip = this.#props.copyToClipboard ?? copyToSystemClipboard;
+        void writeClip(text).catch(() => { });
+        const durationMs = 1500;
+        const until = Date.now() + durationMs;
+        this.#copiedIndex = callIndex;
+        this.#renderCache = undefined;
+        const state = this.#props.stateHolder;
+        if (state !== undefined) {
+            state[NESTED_CALLS_COPIED_KEY] = {
+                index: callIndex,
+                until,
+            };
+        }
+        if (this.#copiedTimer !== undefined) {
+            clearTimeout(this.#copiedTimer);
+        }
+        this.#copiedTimer = setTimeout(() => {
+            this.#copiedIndex = undefined;
+            this.#renderCache = undefined;
+            const s = this.#props.stateHolder;
+            if (s !== undefined) {
+                delete s[NESTED_CALLS_COPIED_KEY];
+            }
+            this.#props.invalidate?.();
+        }, durationMs);
+        this.#copiedTimer.unref?.();
+        this.#props.invalidate?.();
+    }
+    render(width) {
+        const safeWidth = Math.max(1, width);
+        const levelsKey = this.#getLevelsKey();
+        if (this.#renderCache !== undefined &&
+            this.#renderCache.width === safeWidth &&
+            this.#renderCache.copiedIndex === this.#copiedIndex &&
+            this.#renderCache.levelsKey === levelsKey) {
+            this.#lineMapping = this.#renderCache.lineMapping;
+            return this.#renderCache.lines;
+        }
+        this.#lineMapping = [];
+        const { calls, theme } = this.#props;
+        const lines = [];
+        const rightMargin = 1;
+        for (let i = 0; i < calls.length; i++) {
+            const call = calls[i];
+            if (!call)
+                continue;
+            const toolName = "toolName" in call ? call.toolName : call.name;
+            const isError = Boolean(call.isError || ("status" in call && call.status === "error"));
+            const isRunning = ("status" in call && call.status === "running") ||
+                (!("status" in call) && call.result === undefined);
+            const expansionLevel = this.#getExpansionLevel(i);
+            const isExpanded = expansionLevel !== 0;
+            const rawSummary = "summary" in call ? call.summary : undefined;
+            const rawArgs = "args" in call ? call.args : undefined;
+            const inline = inlinePresentation(toolName, rawArgs ?? rawSummary, "result" in call ? call.result?.details : undefined, isError);
+            const argText = typeof rawArgs === "string" ? rawArgs : typeof rawSummary === "string" ? rawSummary : "";
+            const provider = this.#props.resolvePresentation?.(toolName);
+            const presentation = provider?.(rawArgs, "result" in call ? call.result : undefined, theme);
+            // The child row is the child's own header minus the fold pin, so it carries the same token
+            // assignment as the row the same call would draw at top level.
+            const childSummary = stripTerminalSequences(presentation?.summary ?? inline?.summary ?? argText);
+            const duration = formatDuration(call.durationMs);
+            const leftContent = formatToolHeaderText({
+                status: isRunning ? "running" : isError ? "error" : "ok",
+                title: toolName,
+                summary: [childSummary, duration].filter(Boolean).join(" · "),
+            }, theme);
+            const isCopied = this.#copiedIndex === i;
+            const copyIcon = isCopied ? theme.fg("success", "✓") : theme.fg("dim", "󰆏");
+            const copySlotWidth = 2 + rightMargin;
+            const maxLeft = Math.max(1, width - copySlotWidth);
+            const truncatedLeft = truncate(leftContent, maxLeft);
+            const leftVis = visibleWidth(truncatedLeft);
+            const gap = " ".repeat(Math.max(1, width - leftVis - rightMargin - 1));
+            const headerLine = truncate(truncatedLeft + gap + copyIcon + " ".repeat(rightMargin), width);
+            const headerLineIdx = lines.length;
+            lines.push(headerLine);
+            this.#lineMapping[headerLineIdx] = {
+                callIndex: i,
+                isHeader: true,
+                copyRegion: { startX: width - copySlotWidth - 1, endX: width },
+            };
+            if (isExpanded) {
+                const bodyLines = this.#renderChildBody(call, Math.max(1, width - 2), expansionLevel);
+                for (const rawLine of bodyLines) {
+                    for (const bodyLine of toContentRows(rawLine)) {
+                        const bodyLineIdx = lines.length;
+                        lines.push(truncate(`  ${bodyLine}`, width));
+                        this.#lineMapping[bodyLineIdx] = {
+                            callIndex: i,
+                            isHeader: false,
+                        };
+                    }
+                }
+            }
+        }
+        this.#renderCache = {
+            width: safeWidth,
+            copiedIndex: this.#copiedIndex,
+            levelsKey,
+            lines,
+            lineMapping: this.#lineMapping,
+        };
+        return lines;
+    }
+    #renderChildBody(call, width, expansionLevel = 1) {
+        const { theme, context, resolveChildRenderer } = this.#props;
+        const toolName = "toolName" in call ? call.toolName : call.name;
+        const result = "result" in call ? call.result : undefined;
+        const args = "args" in call ? call.args : undefined;
+        if (result && resolveChildRenderer) {
+            const renderer = resolveChildRenderer(toolName);
+            if (renderer?.renderResult) {
+                try {
+                    const childContext = {
+                        ...context,
+                        toolCallId: "toolCallId" in call ? call.toolCallId : context.toolCallId,
+                        args,
+                        durationMs: call.durationMs,
+                        isError: Boolean(call.isError || ("status" in call && call.status === "error")),
+                        state: undefined,
+                    };
+                    const comp = renderer.renderResult(result, { expanded: expansionLevel === 2, isPartial: false }, theme, childContext);
+                    if (comp instanceof ToolView) {
+                        comp.setFoldLevel(expansionLevel);
+                        // Render body cleanly via deep headless interface without outer rail or header row
+                        return comp.renderBody(width, { noRail: true });
+                    }
+                    return comp.render(width);
+                }
+                catch {
+                    // Fall through to plain text extraction on renderer failure
+                }
+            }
+        }
+        // Fallback rendering
+        if (result && Array.isArray(result.content)) {
+            const text = result.content
+                .filter((c) => isRecord(c) && c.type === "text" && typeof c.text === "string")
+                .map((c) => c.text)
+                .join("\n")
+                .trim();
+            if (text) {
+                let lines;
+                const filePath = typeof args === "object" &&
+                    args !== null &&
+                    "path" in args &&
+                    typeof args.path === "string"
+                    ? args.path
+                    : "";
+                const lang = filePath ? getLanguageFromPath(filePath) : undefined;
+                if (lang) {
+                    try {
+                        lines = highlightCode(text, lang);
+                    }
+                    catch {
+                        lines = text.split("\n");
+                    }
+                }
+                else {
+                    lines = text.split("\n");
+                }
+                if (expansionLevel === 2 || lines.length <= 20) {
+                    return lines;
+                }
+                return [...lines.slice(0, 20), `... (${lines.length - 20} more lines)`];
+            }
+        }
+        if ("error" in call && typeof call.error === "string" && call.error) {
+            return call.error.split("\n").map((l) => theme.fg("error", l));
+        }
+        if (args !== undefined) {
+            const text = typeof args === "string" ? args : JSON.stringify(args, null, 2);
+            return text.split("\n").map((l) => theme.fg("dim", l));
+        }
+        return [theme.fg("dim", "(no output)")];
+    }
+    handleMouse(event) {
+        if (event.type !== "click" || event.button !== "left")
+            return undefined;
+        const mapping = this.#lineMapping[event.y];
+        if (!mapping)
+            return { handled: true };
+        if (mapping.isHeader) {
+            if (mapping.copyRegion && event.x >= mapping.copyRegion.startX) {
+                this.#triggerCopy(mapping.callIndex, event.shift === true);
+                return { handled: true, render: true };
+            }
+            const isCtrl = event.ctrl === true;
+            const currentLevel = this.#getExpansionLevel(mapping.callIndex);
+            const nextLevel = transitionFoldLevel(currentLevel, isCtrl);
+            this.#setExpansionLevel(mapping.callIndex, nextLevel);
+            this.#props.invalidate?.();
+            return { handled: true, render: true };
+        }
+        return { handled: true };
+    }
+    dispose() {
+        if (this.#copiedTimer !== undefined) {
+            clearTimeout(this.#copiedTimer);
+            this.#copiedTimer = undefined;
+        }
+        this.#renderCache = undefined;
+    }
+    collapseAll() {
+        if (this.#copiedTimer !== undefined) {
+            clearTimeout(this.#copiedTimer);
+            this.#copiedTimer = undefined;
+        }
+        this.#inMemoryLevels.clear();
+        const state = this.#props.stateHolder;
+        if (state !== undefined) {
+            state[NESTED_CALLS_EXPANDED_KEY] = {};
+        }
+        this.#lineMapping = [];
+        this.#renderCache = undefined;
+    }
+    invalidate() {
+        this.#lineMapping = [];
+        this.#renderCache = undefined;
+    }
+}

package/dist/payload-parser.d.ts

@@ -0,0 +1,120 @@
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { type DiffLine, type DiffSource } from "./diff-view.js";
+import type { ToolStatusKind } from "./tool-view.js";
+export declare const APPLY_PATCH_TOOL_NAME = "apply_patch";
+export declare const PYTHON_EVAL_TOOL_NAME = "python_eval";
+export declare const PYTHON_EVAL_DETAILS_FORMAT = "pi-ext-tools-python-eval";
+export declare const EDIT_TOOL_NAME = "edit";
+export declare const WRITE_TOOL_NAME = "write";
+export declare const EDIT_VIEW_KEY = "__piExtToolsEditView";
+export declare const WRITE_VIEW_KEY = "__piExtToolsWriteView";
+export declare const CODEMODE_OPTIONS_PREFIX = "// @options:";
+export declare const CODEMODE_SCRIPT_HEADER: RegExp;
+export interface NestedCallRecord {
+    readonly toolName: string;
+    readonly summary?: string | undefined;
+    readonly status?: "running" | "ok" | "error" | "cancelled" | undefined;
+    readonly isError?: boolean | undefined;
+    readonly isWarning?: boolean | undefined;
+    readonly durationMs?: number | undefined;
+    readonly cost?: number | undefined;
+    readonly error?: string | undefined;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function estimateStreamingTokens(args: unknown): number;
+export declare function formatDurationMs(ms: number | undefined): string;
+export declare function formatCostUsd(cost: number | undefined): string;
+/** One header fact for a deadline, in the same shape codemode's `timeout_ms` renders as. */
+export declare function formatTimeoutFact(timeoutMs: number): string;
+export declare function extractCodemodeHeaderFacts(args: unknown): string;
+export declare function parseCallArgs(raw: unknown): Record<string, unknown> | undefined;
+export declare function extractSummaryArg(toolName: string, args: unknown): string;
+export declare function extractHeavyInputCommand(toolName: string, args: unknown): string | undefined;
+export declare function extractNestedCalls(result: AgentToolResult<unknown> | undefined): readonly NestedCallRecord[];
+export declare function extractResultText(toolName: string, result: AgentToolResult<unknown>): {
+    readonly outputText: string;
+    readonly wallTimeSeconds: number | undefined;
+};
+export declare function callStatsParts(total: number, failCount: number): string[];
+export declare function resolveContainerStatus(params: {
+    readonly isError: boolean;
+    readonly isPartial: boolean;
+    readonly hasChildren: boolean;
+    readonly selfFailed: boolean;
+}): ToolStatusKind;
+export declare function toolPath(args: unknown): string;
+export declare function editPath(args: unknown): string;
+export declare function numericField(value: unknown, key: string): number | undefined;
+export type WritePresentation = {
+    readonly kind: "diff";
+    readonly source: DiffSource;
+    readonly added: number;
+    readonly removed: number;
+} | {
+    readonly kind: "content";
+    readonly label: string;
+    readonly content: string;
+} | {
+    readonly kind: "noChange";
+};
+export declare function writeStoredDiff(lines: readonly unknown[]): DiffSource | undefined;
+/** Uses only the baseline and content already stored by the write tool. */
+export declare function writePresentation(args: unknown, details: unknown): WritePresentation | undefined;
+/** Compact nested-row result: a one-line summary plus the status it reports. */
+export interface InlinePresentation {
+    readonly summary: string;
+    readonly status: ToolStatusKind;
+}
+export declare function fileToolPresentation(toolName: string, args: unknown, details: unknown, isError: boolean): InlinePresentation | undefined;
+/** Pi native edit persists a unified patch plus the same change as a numbered display diff. */
+export declare function editDiffSource(details: unknown): DiffSource | undefined;
+export declare function displayDiffSource(diff: string): DiffSource | undefined;
+export declare function editViewSource(view: unknown): DiffSource | undefined;
+export declare function editViewHunks(view: unknown): readonly {
+    readonly lines: readonly DiffLine[];
+}[];
+export declare function hunksForEditOp(op: Record<string, unknown>): readonly {
+    readonly lines: readonly DiffLine[];
+}[];
+export declare function splitFragment(text: string): readonly string[];
+/** Line LCS of one stored before/after fragment. No file context is invented. */
+export declare function lineHunks(before: string, after: string, startLine: number): readonly {
+    readonly lines: readonly DiffLine[];
+}[];
+export declare function patchTextForCopy(details: unknown): string | undefined;
+export declare function patchSummary(files: number, added: number, removed: number): string;
+/**
+ * One compact nested summary for a tool call. Adopts the tool's standard collapsed
+ * single-line format when recognized, degrading to undefined so callers can use
+ * the default argument rendering.
+ */
+export declare function inlinePresentation(toolName: string, args: unknown, details: unknown, isError: boolean): InlinePresentation | undefined;
+/**
+ * One row of the eval cell transcript: printed text, display value, nested call, the final
+ * value, or the kernel's namespace report.
+ */
+export type EvalRow = {
+    readonly kind: "text";
+    readonly text: string;
+} | {
+    readonly kind: "display";
+    readonly text: string;
+} | {
+    readonly kind: "tool";
+    readonly name: string;
+    readonly args: unknown;
+    readonly durationMs: number | undefined;
+    readonly error: string | undefined;
+} | {
+    readonly kind: "result";
+    readonly text: string;
+} | {
+    readonly kind: "state";
+    readonly text: string;
+};
+export interface EvalFacts {
+    readonly rows: readonly EvalRow[];
+    readonly error: string | undefined;
+}
+/** Reads only the persisted `pi-ext-tools-eval` details; other shapes degrade to plain output. */
+export declare function pythonEvalFacts(details: unknown): EvalFacts | undefined;