@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.512

package/dist/integrations/pi/components/upstream/components/skill-invocation-message.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/components/skill-invocation-message.ts.
+ * Modifications: Mechanical port uses A1's public pi-tui instance, owned theme boundary, and
+ * root-instance keybinding registry because the public coding-agent component closes over a second
+ * nested pi-tui singleton and cannot observe A1's keybindings.
+ * Deviations: none.
+ */
+import { Box, type MarkdownTheme } from "@earendil-works/pi-tui";
+export interface SkillInvocationBlock {
+    readonly name: string;
+    readonly content: string;
+}
+export declare class SkillInvocationMessageComponent extends Box {
+    #private;
+    private readonly skillBlock;
+    private readonly markdownTheme;
+    constructor(skillBlock: SkillInvocationBlock, markdownTheme: MarkdownTheme);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/integrations/pi/components/upstream/components/skill-invocation-message.js

@@ -0,0 +1,46 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/components/skill-invocation-message.ts.
+ * Modifications: Mechanical port uses A1's public pi-tui instance, owned theme boundary, and
+ * root-instance keybinding registry because the public coding-agent component closes over a second
+ * nested pi-tui singleton and cannot observe A1's keybindings.
+ * Deviations: none.
+ */
+import { Box, getKeybindings, Markdown, Text } from "@earendil-works/pi-tui";
+import { piTheme } from "../theme/theme.js";
+export class SkillInvocationMessageComponent extends Box {
+    #expanded = false;
+    skillBlock;
+    markdownTheme;
+    constructor(skillBlock, markdownTheme) {
+        super(1, 1, text => piTheme().bg("customMessageBg", text));
+        this.skillBlock = skillBlock;
+        this.markdownTheme = markdownTheme;
+        this.#updateDisplay();
+    }
+    setExpanded(expanded) {
+        this.#expanded = expanded;
+        this.#updateDisplay();
+    }
+    invalidate() {
+        super.invalidate();
+        this.#updateDisplay();
+    }
+    #updateDisplay() {
+        this.clear();
+        if (this.#expanded) {
+            const label = piTheme().fg("customMessageLabel", "\x1b[1m[skill]\x1b[22m");
+            this.addChild(new Text(label, 0, 0));
+            const header = `**${this.skillBlock.name}**\n\n`;
+            this.addChild(new Markdown(header + this.skillBlock.content, 0, 0, this.markdownTheme, {
+                color: text => piTheme().fg("customMessageText", text),
+            }));
+            return;
+        }
+        const expandKey = getKeybindings().getKeys("app.tools.expand")[0] ?? "";
+        const line = piTheme().fg("customMessageLabel", "\x1b[1m[skill]\x1b[22m ")
+            + piTheme().fg("customMessageText", this.skillBlock.name)
+            + piTheme().fg("dim", ` (${expandKey} to expand)`);
+        this.addChild(new Text(line, 0, 0));
+    }
+}

package/dist/integrations/pi/components/upstream/components/status-indicator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/components/status-indicator.ts.
+ * Modifications: Mechanical source port with public package-root keybinding, Loader, and owned
+ * theme/countdown imports plus ECMAScript private fields.
+ * Deviations: status-indicator-public-boundaries.
+ */
+import { type Component, Loader, type LoaderIndicatorOptions, type TUI } from "@earendil-works/pi-tui";
+export type StatusIndicatorKind = "working" | "retry" | "compaction" | "branchSummary";
+export declare class StatusIndicator extends Loader {
+    readonly kind: StatusIndicatorKind;
+    constructor(kind: StatusIndicatorKind, ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message: string, indicator?: LoaderIndicatorOptions);
+    dispose(): void;
+}
+export declare class WorkingStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI, message: string, indicator?: LoaderIndicatorOptions, colorFn?: (text: string) => string);
+    renderInBorder(width: number): string;
+    renderSpinnerInBorder(width: number): string;
+}
+export declare class RetryStatusIndicator extends StatusIndicator {
+    #private;
+    constructor(ui: TUI, attempt: number, maxAttempts: number, delayMs: number);
+    dispose(): void;
+}
+export type CompactionStatusReason = "manual" | "threshold" | "overflow";
+export declare class CompactionStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI, reason: CompactionStatusReason);
+}
+export declare class BranchSummaryStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI);
+}
+export declare class IdleStatus implements Component {
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/integrations/pi/components/upstream/components/status-indicator.js

@@ -0,0 +1,69 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/components/status-indicator.ts.
+ * Modifications: Mechanical source port with public package-root keybinding, Loader, and owned
+ * theme/countdown imports plus ECMAScript private fields.
+ * Deviations: status-indicator-public-boundaries.
+ */
+import { Loader, truncateToWidth } from "@earendil-works/pi-tui";
+import { keyText } from "../../../startup-public.js";
+import { piTheme } from "../theme/theme.js";
+import { CountdownTimer } from "./countdown-timer.js";
+export class StatusIndicator extends Loader {
+    kind;
+    constructor(kind, ui, spinnerColorFn, messageColorFn, message, indicator) {
+        super(ui, spinnerColorFn, messageColorFn, message, indicator);
+        this.kind = kind;
+    }
+    dispose() {
+        this.stop();
+    }
+}
+export class WorkingStatusIndicator extends StatusIndicator {
+    constructor(ui, message, indicator, colorFn) {
+        super("working", ui, colorFn ?? (spinner => piTheme().fg("accent", spinner)), colorFn ?? (text => piTheme().fg("muted", text)), message, indicator);
+    }
+    renderInBorder(width) {
+        const line = super.render(width + 2)[1] ?? "";
+        return truncateToWidth(line.startsWith(" ") ? line.slice(1).trimEnd() : line.trimEnd(), width, "");
+    }
+    renderSpinnerInBorder(width) {
+        return truncateToWidth(this.getRenderedIndicator(), width, "");
+    }
+}
+export class RetryStatusIndicator extends StatusIndicator {
+    #countdown;
+    constructor(ui, attempt, maxAttempts, delayMs) {
+        const retryMessage = (seconds) => `Retrying (${attempt}/${maxAttempts}) in ${seconds}s... (${keyText("app.interrupt")} to cancel)`;
+        super("retry", ui, spinner => piTheme().fg("warning", spinner), text => piTheme().fg("muted", text), retryMessage(Math.ceil(delayMs / 1000)));
+        this.#countdown = new CountdownTimer(delayMs, ui, seconds => this.setMessage(retryMessage(seconds)), () => {
+            this.#countdown = undefined;
+        });
+    }
+    dispose() {
+        this.#countdown?.dispose();
+        this.#countdown = undefined;
+        super.dispose();
+    }
+}
+export class CompactionStatusIndicator extends StatusIndicator {
+    constructor(ui, reason) {
+        const cancelHint = `(${keyText("app.interrupt")} to cancel)`;
+        const label = reason === "manual"
+            ? `Compacting context... ${cancelHint}`
+            : `${reason === "overflow" ? "Context overflow detected, " : ""}Auto-compacting... ${cancelHint}`;
+        super("compaction", ui, spinner => piTheme().fg("accent", spinner), text => piTheme().fg("muted", text), label);
+    }
+}
+export class BranchSummaryStatusIndicator extends StatusIndicator {
+    constructor(ui) {
+        super("branchSummary", ui, spinner => piTheme().fg("accent", spinner), text => piTheme().fg("muted", text), `Summarizing branch... (${keyText("app.interrupt")} to cancel)`);
+    }
+}
+export class IdleStatus {
+    invalidate() { }
+    render(width) {
+        const emptyLine = " ".repeat(width);
+        return [emptyLine, emptyLine];
+    }
+}

package/dist/integrations/pi/components/upstream/components/tool-execution.d.ts

@@ -0,0 +1,67 @@
+import { Container, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+type ToolPresentationResult = Parameters<NonNullable<ToolDefinition["renderResult"]>>[0] & {
+    isError: boolean;
+};
+/** The caller-side merge 0.85.1 performs before handing a definition to the component: built-in renderers fill the gaps. */
+export declare function mergeBuiltInRenderers(definition: ToolDefinition<any, any, any> | undefined, builtIn: ToolDefinition<any, any, any> | undefined): ToolDefinition<any, any, any> | undefined;
+export interface ToolExecutionOptions {
+    showImages?: boolean;
+    imageWidthCells?: number;
+}
+export declare class ToolExecutionComponent extends Container {
+    private contentBox;
+    private contentText;
+    private contentTextRegion;
+    private selfRenderContainer;
+    private selfRenderHeight;
+    private callRendererComponent;
+    private resultRendererComponent;
+    private rendererState;
+    private imageComponents;
+    private readonly images;
+    private disposed;
+    private updatingDisplay;
+    private imageSpacers;
+    private toolName;
+    private toolCallId;
+    private args;
+    private expanded;
+    private showImages;
+    private imageWidthCells;
+    private isPartial;
+    private toolDefinition;
+    private builtInToolDefinition;
+    private ui;
+    private cwd;
+    private executionStarted;
+    private argsComplete;
+    private result;
+    private hideComponent;
+    constructor(toolName: string, toolCallId: string, args: any, options: ToolExecutionOptions | undefined, toolDefinition: ToolDefinition<any, any, any> | undefined, ui: TUI, cwd: string);
+    private getCallRenderer;
+    private getResultRenderer;
+    private hasRendererDefinition;
+    private getRenderShell;
+    private getRenderContext;
+    private createCallFallback;
+    private createResultFallback;
+    private createResultRegion;
+    updateArgs(args: any): void;
+    markExecutionStarted(): void;
+    setArgsComplete(): void;
+    updateResult(result: ToolPresentationResult, isPartial?: boolean): void;
+    /** End mount ownership without letting an obsolete conversion or extension callback repaint. */
+    dispose(): void;
+    setExpanded(expanded: boolean): void;
+    setShowImages(show: boolean): void;
+    setImageWidthCells(width: number): void;
+    invalidate(): void;
+    render(width: number): string[];
+    handleMouse(event: TuiMouseEvent): ReturnType<Container["handleMouse"]>;
+    private updateDisplay;
+    private composeDisplay;
+    private getTextOutput;
+    private formatToolExecution;
+}
+export {};

package/dist/integrations/pi/components/upstream/components/tool-execution.js

@@ -0,0 +1,365 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/components/tool-execution.ts.
+ * Modifications: Retain pinned shell and actual public tool-definition renderers. Replace private
+ * index-keyed image conversion with current-source ownership, serial conversion, visible fallback, and
+ * disposal; guard reentrant invalidation. Remap private types, definition factories, theme, and
+ * generic text helpers to public or locally attributed equivalents. See
+ * docs/architecture/tool-image-presentation.md.
+ * Deviations: current-tool-image-conversion-ownership.
+ */
+import { stripVTControlCharacters } from "node:util";
+import { Box, Container, getCapabilities, getImageDimensions, imageFallback, MouseRegion, Spacer, Text } from "@earendil-works/pi-tui";
+import { createReadToolDefinition, createBashToolDefinition, createEditToolDefinition, createWriteToolDefinition, createGrepToolDefinition, createFindToolDefinition, createLsToolDefinition, keyHint, } from "../../../startup-public.js";
+import { piTheme } from "../theme/theme.js";
+import { ToolImagePresentation } from "../../tool-image-presentation.js";
+/** The caller-side merge 0.85.1 performs before handing a definition to the component: built-in renderers fill the gaps. */
+export function mergeBuiltInRenderers(definition, builtIn) {
+    if (definition === undefined)
+        return builtIn;
+    if (builtIn === undefined)
+        return definition;
+    const merged = { ...definition };
+    if (definition.renderCall === undefined && builtIn.renderCall !== undefined)
+        merged.renderCall = builtIn.renderCall;
+    if (definition.renderResult === undefined && builtIn.renderResult !== undefined)
+        merged.renderResult = builtIn.renderResult;
+    return merged;
+}
+const definitions = { read: createReadToolDefinition, bash: createBashToolDefinition, edit: createEditToolDefinition,
+    write: createWriteToolDefinition, grep: createGrepToolDefinition, find: createFindToolDefinition, ls: createLsToolDefinition };
+const FALLBACK_PREVIEW_LINES = 10;
+export class ToolExecutionComponent extends Container {
+    contentBox;
+    contentText;
+    contentTextRegion;
+    selfRenderContainer;
+    selfRenderHeight = 0;
+    callRendererComponent;
+    resultRendererComponent;
+    rendererState = {};
+    imageComponents = [];
+    images;
+    disposed = false;
+    updatingDisplay = false;
+    imageSpacers = [];
+    toolName;
+    toolCallId;
+    args;
+    expanded = false;
+    showImages;
+    imageWidthCells;
+    isPartial = true;
+    toolDefinition;
+    builtInToolDefinition;
+    ui;
+    cwd;
+    executionStarted = false;
+    argsComplete = false;
+    result;
+    hideComponent = false;
+    constructor(toolName, toolCallId, args, options = {}, toolDefinition, ui, cwd) {
+        super();
+        this.toolName = toolName;
+        this.toolCallId = toolCallId;
+        this.args = args;
+        this.builtInToolDefinition = Object.hasOwn(definitions, toolName)
+            ? definitions[toolName](cwd) : undefined;
+        // Rationale: 0.85.1 moved the built-in renderer fallback to the caller; A1 keeps it here so every caller of
+        // the owned component gets the built-in edit/read/bash renderers without reaching into the tool registry.
+        this.toolDefinition = mergeBuiltInRenderers(toolDefinition, this.builtInToolDefinition);
+        this.showImages = options.showImages ?? true;
+        this.imageWidthCells = options.imageWidthCells ?? 60;
+        this.ui = ui;
+        this.cwd = cwd;
+        this.images = new ToolImagePresentation(() => {
+            if (this.disposed)
+                return;
+            this.updateDisplay();
+            this.ui.requestRender();
+        });
+        this.addChild(new Spacer(1));
+        // Always create all shell variants. contentBox is used for default renderer-based composition.
+        // selfRenderContainer is used when the tool renders its own framing.
+        // contentText is reserved for generic fallback rendering when no tool definition exists.
+        this.contentBox = new Box(1, 1, (text) => piTheme().bg("toolPendingBg", text));
+        this.contentText = new Text("", 1, 1, (text) => piTheme().bg("toolPendingBg", text));
+        this.contentTextRegion = this.createResultRegion(this.contentText);
+        this.selfRenderContainer = new Container();
+        if (this.hasRendererDefinition()) {
+            this.addChild(this.getRenderShell() === "self" ? this.selfRenderContainer : this.contentBox);
+        }
+        else {
+            this.addChild(this.contentTextRegion);
+        }
+        this.updateDisplay();
+    }
+    getCallRenderer() {
+        return this.toolDefinition?.renderCall;
+    }
+    getResultRenderer() {
+        return this.toolDefinition?.renderResult;
+    }
+    hasRendererDefinition() {
+        return this.toolDefinition !== undefined;
+    }
+    getRenderShell() {
+        return this.toolDefinition?.renderShell ?? "default";
+    }
+    getRenderContext(lastComponent) {
+        return {
+            args: this.args,
+            toolCallId: this.toolCallId,
+            invalidate: () => {
+                if (this.disposed || this.updatingDisplay)
+                    return;
+                this.invalidate();
+                this.ui.requestRender();
+            },
+            lastComponent,
+            state: this.rendererState,
+            cwd: this.cwd,
+            executionStarted: this.executionStarted,
+            argsComplete: this.argsComplete,
+            isPartial: this.isPartial,
+            expanded: this.expanded,
+            showImages: this.showImages,
+            isError: this.result?.isError ?? false,
+        };
+    }
+    createCallFallback() {
+        const theme = piTheme();
+        return new Text(theme.fg("toolTitle", theme.bold(this.toolName)), 0, 0);
+    }
+    createResultFallback() {
+        const theme = piTheme();
+        const output = this.getTextOutput();
+        if (!output) {
+            return undefined;
+        }
+        const lines = output.split("\n");
+        const displayLines = this.expanded ? lines : lines.slice(0, FALLBACK_PREVIEW_LINES);
+        const remaining = lines.length - displayLines.length;
+        let text = displayLines.map((line) => theme.fg("toolOutput", line)).join("\n");
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+        }
+        return new Text(text, 0, 0);
+    }
+    createResultRegion(component) {
+        return new MouseRegion(component, (event) => {
+            if (!this.result || event.type !== "click" || event.button !== "left")
+                return undefined;
+            this.setExpanded(!this.expanded);
+            return { handled: true };
+        });
+    }
+    updateArgs(args) {
+        this.args = args;
+        this.updateDisplay();
+    }
+    markExecutionStarted() {
+        this.executionStarted = true;
+        this.updateDisplay();
+        this.ui.requestRender();
+    }
+    setArgsComplete() {
+        this.argsComplete = true;
+        this.updateDisplay();
+        this.ui.requestRender();
+    }
+    updateResult(result, isPartial = false) {
+        this.result = result;
+        this.isPartial = isPartial;
+        this.updateDisplay();
+    }
+    /** End mount ownership without letting an obsolete conversion or extension callback repaint. */
+    dispose() {
+        this.disposed = true;
+        this.images.dispose();
+        this.result = undefined;
+        this.callRendererComponent = undefined;
+        this.resultRendererComponent = undefined;
+        this.rendererState = {};
+        this.imageComponents = [];
+        this.imageSpacers = [];
+        this.clear();
+    }
+    setExpanded(expanded) {
+        this.expanded = expanded;
+        this.updateDisplay();
+    }
+    setShowImages(show) {
+        this.showImages = show;
+        this.updateDisplay();
+    }
+    setImageWidthCells(width) {
+        this.imageWidthCells = Math.max(1, Math.floor(width));
+        this.updateDisplay();
+    }
+    invalidate() {
+        super.invalidate();
+        this.updateDisplay();
+    }
+    render(width) {
+        if (this.hideComponent) {
+            return [];
+        }
+        if (this.hasRendererDefinition() && this.getRenderShell() === "self") {
+            const contentLines = this.selfRenderContainer.render(width);
+            this.selfRenderHeight = contentLines.length;
+            if (contentLines.length === 0 && this.imageComponents.length === 0) {
+                return [];
+            }
+            const lines = [];
+            if (contentLines.length > 0) {
+                lines.push("");
+                lines.push(...contentLines);
+            }
+            for (let i = 0; i < this.imageComponents.length; i++) {
+                const spacer = this.imageSpacers[i];
+                if (spacer) {
+                    lines.push(...spacer.render(width));
+                }
+                const imageComponent = this.imageComponents[i];
+                if (imageComponent) {
+                    lines.push(...imageComponent.render(width));
+                }
+            }
+            return lines;
+        }
+        return super.render(width);
+    }
+    handleMouse(event) {
+        if (!this.hasRendererDefinition() || this.getRenderShell() !== "self")
+            return super.handleMouse(event);
+        if (event.y <= 0 || event.y > this.selfRenderHeight)
+            return undefined;
+        return this.selfRenderContainer.handleMouse({
+            ...event,
+            y: event.y - 1,
+            height: this.selfRenderHeight,
+        });
+    }
+    updateDisplay() {
+        if (this.disposed || this.updatingDisplay)
+            return;
+        this.updatingDisplay = true;
+        try {
+            this.composeDisplay();
+        }
+        finally {
+            this.updatingDisplay = false;
+        }
+    }
+    composeDisplay() {
+        const theme = piTheme();
+        const bgFn = this.isPartial
+            ? (text) => theme.bg("toolPendingBg", text)
+            : this.result?.isError
+                ? (text) => theme.bg("toolErrorBg", text)
+                : (text) => theme.bg("toolSuccessBg", text);
+        let hasContent = false;
+        this.hideComponent = false;
+        if (this.hasRendererDefinition()) {
+            const renderContainer = this.getRenderShell() === "self" ? this.selfRenderContainer : this.contentBox;
+            if (renderContainer instanceof Box) {
+                renderContainer.setBgFn(bgFn);
+            }
+            renderContainer.clear();
+            const callRenderer = this.getCallRenderer();
+            if (!callRenderer) {
+                renderContainer.addChild(this.createResultRegion(this.createCallFallback()));
+                hasContent = true;
+            }
+            else {
+                try {
+                    const component = callRenderer(this.args, theme, this.getRenderContext(this.callRendererComponent));
+                    this.callRendererComponent = component;
+                    renderContainer.addChild(this.createResultRegion(component));
+                    hasContent = true;
+                }
+                catch {
+                    this.callRendererComponent = undefined;
+                    renderContainer.addChild(this.createResultRegion(this.createCallFallback()));
+                    hasContent = true;
+                }
+            }
+            if (this.result) {
+                const resultRenderer = this.getResultRenderer();
+                if (!resultRenderer) {
+                    const component = this.createResultFallback();
+                    if (component) {
+                        renderContainer.addChild(this.createResultRegion(component));
+                        hasContent = true;
+                    }
+                }
+                else {
+                    try {
+                        const component = resultRenderer({ content: this.result.content, details: this.result.details }, { expanded: this.expanded, isPartial: this.isPartial }, theme, this.getRenderContext(this.resultRendererComponent));
+                        this.resultRendererComponent = component;
+                        renderContainer.addChild(this.createResultRegion(component));
+                        hasContent = true;
+                    }
+                    catch {
+                        this.resultRendererComponent = undefined;
+                        const component = this.createResultFallback();
+                        if (component) {
+                            renderContainer.addChild(this.createResultRegion(component));
+                            hasContent = true;
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            this.contentText.setCustomBgFn(bgFn);
+            this.contentText.setText(this.formatToolExecution());
+            hasContent = true;
+        }
+        for (const img of this.imageComponents) {
+            this.removeChild(img);
+        }
+        this.imageComponents = [];
+        for (const spacer of this.imageSpacers) {
+            this.removeChild(spacer);
+        }
+        this.imageSpacers = [];
+        this.images.update(this.result?.content ?? [], this.showImages);
+        for (const imageComponent of this.images.components(this.imageWidthCells)) {
+            const spacer = new Spacer(1);
+            this.addChild(spacer);
+            this.imageSpacers.push(spacer);
+            this.imageComponents.push(imageComponent);
+            this.addChild(imageComponent);
+        }
+        if (this.hasRendererDefinition() && !hasContent && this.imageComponents.length === 0) {
+            this.hideComponent = true;
+        }
+    }
+    getTextOutput() {
+        if (!this.result)
+            return "";
+        const text = this.result.content.filter(part => part.type === "text").map(part => Array.from(stripVTControlCharacters(part.text ?? "")).filter(char => {
+            const code = char.codePointAt(0);
+            return code === 9 || code === 10 || code > 31 && (code < 0xfff9 || code > 0xfffb);
+        }).join("")).join("\n");
+        if (getCapabilities().images && this.showImages)
+            return text;
+        const indicators = this.result.content.filter(part => part.type === "image").map(part => imageFallback(part.mimeType ?? "image/unknown", part.data && part.mimeType ? getImageDimensions(part.data, part.mimeType) ?? undefined : undefined)).join("\n");
+        return text && indicators ? `${text}\n${indicators}` : text || indicators;
+    }
+    formatToolExecution() {
+        const theme = piTheme();
+        let text = theme.fg("toolTitle", theme.bold(this.toolName));
+        const content = JSON.stringify(this.args, null, 2);
+        if (content) {
+            text += `\n\n${content}`;
+        }
+        const output = this.getTextOutput();
+        if (output) {
+            text += `\n${output}`;
+        }
+        return text;
+    }
+}