@oh-my-pi/pi-tui 18.2.4 → 18.2.6

package/dist/types/tools/lsp.d.ts

@@ -0,0 +1,72 @@
+/**
+ * LSP Tool TUI Rendering
+ *
+ * Renders LSP tool calls and results in the TUI with:
+ * - Syntax-highlighted hover information
+ * - Color-coded diagnostics by severity
+ * - Grouped references and symbols
+ * - Collapsible/expandable views
+ */
+import type { RenderResultOptions } from "./renderer.js";
+import type { Component } from "../tui.js";
+import { Text } from "../components/text.js";
+import { type Theme } from "../theme/theme.js";
+/** Display arguments for an LSP tool request. */
+export interface LspParams {
+    action: "diagnostics" | "definition" | "references" | "hover" | "symbols" | "rename" | "rename_file" | "code_actions" | "type_definition" | "implementation" | "status" | "reload" | "capabilities" | "request";
+    file?: string;
+    line?: number;
+    symbol?: string;
+    query?: string;
+    new_name?: string;
+    apply?: boolean;
+    timeout?: number;
+    payload?: string;
+}
+/** Details accompanying an LSP tool response. */
+export interface LspToolDetails {
+    serverName?: string;
+    action: string;
+    success: boolean;
+    request?: LspParams;
+}
+/** Diagnostics and formatting status for one file. */
+export interface FileDiagnosticsResult {
+    /** Name of the LSP server used (if available) */
+    server?: string;
+    /** Formatted diagnostic messages */
+    messages: string[];
+    /** Summary string (e.g., "2 error(s), 1 warning(s)") */
+    summary: string;
+    /** Whether there are any errors (severity 1) */
+    errored: boolean;
+    /** Whether the file was formatted */
+    formatter?: FileFormatResult;
+}
+/** Outcome of automatic file formatting. */
+export declare enum FileFormatResult {
+    UNCHANGED = "unchanged",
+    FORMATTED = "formatted",
+    FAILED = "failed",
+    UNSUPPORTED = "unsupported"
+}
+export declare function renderCall(args: LspParams, _options: RenderResultOptions, theme: Theme): Text;
+/**
+ * Render LSP tool result with intelligent formatting based on result type.
+ * Detects hover, diagnostics, references, symbols, etc. and formats accordingly.
+ */
+export declare function renderResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: LspToolDetails;
+    isError?: boolean;
+}, options: RenderResultOptions, theme: Theme, args?: LspParams): Component;
+/** Render LSP requests and responses in the transcript. */
+export declare const lspToolRenderer: {
+    renderCall: typeof renderCall;
+    renderResult: typeof renderResult;
+    mergeCallAndResult: true;
+    inline: true;
+};

package/dist/types/tools/match-line-format.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Format a single line of match output for grep/ast-grep style results.
+ *
+ * Matched lines are prefixed with `*`; context lines are prefixed with a single
+ * space so line numbers align in column. In hashline mode the line uses the
+ * editable `LINE:content` shape under a snapshot-tag header; in plain mode it
+ * keeps the legacy `LINE|content` display-only shape. Line numbers are never padded.
+ */
+export declare function formatMatchLine(lineNumber: number, line: string, isMatch: boolean, options: {
+    useHashLines: boolean;
+}): string;

package/dist/types/tools/mcp.d.ts

@@ -0,0 +1,81 @@
+/**
+ * TUI rendering for MCP tools.
+ *
+ * Provides structured display of MCP tool calls and results,
+ * showing args and output in JSON tree format similar to task tool.
+ */
+import { type Component } from "../index.js";
+import type { RenderResultOptions } from "./renderer.js";
+import { type Theme } from "../theme/theme.js";
+/**
+ * Render MCP tool call.
+ */
+export declare function renderMCPCall(args: Record<string, unknown>, theme: Theme, label: string): Component;
+/**
+ * Render MCP tool result.
+ */
+export declare function renderMCPResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: MCPToolDetails;
+    isError?: boolean;
+}, options: RenderResultOptions, theme: Theme, args?: Record<string, unknown>): Component;
+import type { OutputMeta } from "./output-meta.js";
+/** Set whether plain MCP text results render as Markdown. */
+export declare function setMcpRenderMarkdownResults(enabled: boolean): void;
+/** Content types in tool results */
+export interface MCPTextContent {
+    type: "text";
+    text: string;
+}
+/** Base64-encoded image returned by an MCP tool. */
+export interface MCPImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+/** Embedded text or binary resource returned by an MCP tool. */
+export interface MCPResourceContent {
+    type: "resource";
+    resource: {
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+    };
+}
+/** Supported MCP result content blocks retained in display metadata. */
+export type MCPContent = MCPTextContent | MCPImageContent | MCPResourceContent;
+/** Details included in MCP tool results for rendering */
+export interface MCPToolDetails {
+    /** Server name */
+    serverName: string;
+    /** Original MCP tool name */
+    mcpToolName: string;
+    /** Whether the call resulted in an error */
+    isError?: boolean;
+    /** Raw content from MCP response */
+    rawContent?: MCPContent[];
+    /** Structured metadata from the MCP response */
+    mcpMeta?: Record<string, unknown>;
+    /** Provider ID (e.g., "claude", "mcp-json") */
+    provider?: string;
+    /** Provider display name (e.g., "Claude Code", "MCP Config") */
+    providerName?: string;
+    /** Structured output metadata (set by the spill wrapper when output is truncated to an artifact). */
+    meta?: OutputMeta;
+}
+/** Registry prefix every minted MCP tool name carries. */
+export declare const MCP_TOOL_NAME_PREFIX = "mcp__";
+/**
+ * Parse an MCP tool name back to server and tool components.
+ *
+ * Note: This returns the normalized tool name (with server prefix stripped).
+ * The original MCP tool name may have had the server name as a prefix.
+ */
+export declare function parseMCPToolName(name: string): {
+    serverName: string;
+    toolName: string;
+} | null;

package/dist/types/tools/memory.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Inline TUI renderers for the long-term memory tools (`retain`, `recall`,
+ * `reflect`).
+ *
+ * These keep the transcript terse — one status line plus, for `retain`, one
+ * `Remember: …` line per stored item — instead of the generic JSON arg tree,
+ * which exploded multi-line memory blobs into an unreadable wall. The tool
+ * container is a transparent passthrough, so these renderers stay frameless:
+ * a status line with a couple of dim bullets reads far cleaner than boxing a
+ * one-line memory note.
+ */
+import type { Component } from "../index.js";
+import type { RenderResultOptions } from "./renderer.js";
+import type { Theme } from "../theme/theme.js";
+interface RetainRenderArgs {
+    items?: unknown;
+}
+interface QueryRenderArgs {
+    query?: string;
+}
+/** Render retained memory items and their storage summary. */
+export declare const retainToolRenderer: {
+    inline: true;
+    mergeCallAndResult: true;
+    renderCall(args: RetainRenderArgs, options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: {
+            count?: number;
+        };
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: RetainRenderArgs): Component;
+};
+/** Render recalled memories with an expandable body. */
+export declare const recallToolRenderer: {
+    inline: true;
+    mergeCallAndResult: true;
+    renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: QueryRenderArgs): Component;
+};
+/** Render synthesized memory reflections. */
+export declare const reflectToolRenderer: {
+    inline: true;
+    mergeCallAndResult: true;
+    renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: QueryRenderArgs): Component;
+};
+/** Number of memories accepted by retain. */
+export interface MemoryRetainDetails {
+    count: number;
+}
+export {};

package/dist/types/tools/output-meta.d.ts

@@ -0,0 +1,151 @@
+import type { Theme } from "../theme/theme.js";
+import type { OutputArtifactError } from "./streaming-output.js";
+/**
+ * Truncation metadata for the output notice.
+ */
+export interface TruncationMeta {
+    direction: "head" | "tail" | "middle";
+    truncatedBy: "lines" | "bytes" | "middle";
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    maxBytes?: number;
+    /** Line range shown (1-indexed, inclusive). Omitted for middle elision. */
+    shownRange?: {
+        start: number;
+        end: number;
+    };
+    /** Head/tail line ranges shown when direction === "middle". */
+    headRange?: {
+        start: number;
+        end: number;
+    };
+    tailRange?: {
+        start: number;
+        end: number;
+    };
+    /** Bytes elided from the middle. */
+    elidedBytes?: number;
+    /** Lines elided from the middle. */
+    elidedLines?: number;
+    /** Artifact ID if full output was saved */
+    artifactId?: string;
+    /** Next offset for pagination (head truncation only) */
+    nextOffset?: number;
+    /**
+     * The single shown line is a byte-capped preview of one oversized line, not
+     * a complete line. `outputBytes`/`totalBytes` are the preview vs full line
+     * size; renders a distinct "partial" notice instead of a line range.
+     */
+    partialLine?: boolean;
+}
+/**
+ * Source resolution info for the output.
+ */
+export type SourceMeta = {
+    type: "path";
+    value: string;
+} | {
+    type: "url";
+    value: string;
+} | {
+    type: "internal";
+    value: string;
+}
+/** A complete aggregate report, whose entries may contain incomplete source captures. */
+ | {
+    type: "report";
+    value: string;
+};
+/**
+ * LSP diagnostic info (for edit/write tools).
+ */
+export interface DiagnosticMeta {
+    summary: string;
+    messages: string[];
+}
+/**
+ * Limit-specific notices.
+ */
+export interface LimitsMeta {
+    matchLimit?: {
+        reached: number;
+        suggestion: number;
+    };
+    resultLimit?: {
+        reached: number;
+        suggestion: number;
+    };
+    headLimit?: {
+        reached: number;
+        suggestion: number;
+    };
+    /** `unit` may be absent in sessions persisted before it was recorded. */
+    columnTruncated?: {
+        maxColumn: number;
+        unit?: "bytes" | "chars";
+        artifactId?: string;
+    };
+}
+/**
+ * Structured metadata for tool outputs.
+ */
+export interface OutputMeta {
+    truncation?: TruncationMeta;
+    /** Capture failure of this output itself; aggregate reports keep source failures on their entries. */
+    artifactError?: OutputArtifactError;
+    source?: SourceMeta;
+    diagnostics?: DiagnosticMeta;
+    limits?: LimitsMeta;
+}
+/**
+ * Reformat pre-formatted diagnostic messages into a multi-level, prefix-folded
+ * directory/file grouping (see `formatGroupedFiles`).
+ * Input:  ["path:line:col [sev] msg", ...]
+ * Output: "# pkg/src/\n## file.ts\n  line:col [sev] msg"
+ *
+ * Messages that don't match the expected format are appended ungrouped at the end.
+ */
+export declare function formatGroupedDiagnosticMessages(messages: string[]): string;
+/** Format a recoverable output artifact link. */
+export declare function formatFullOutputReference(artifactId: string): string;
+/** Strip the last literal notice or a matching final line; optionally preserve surrounding whitespace. */
+export declare function stripTrailingNotice(text: string, notice: string | ((line: string) => boolean), trimResult?: boolean): string;
+/** Remove the trailing bash raw-output artifact footer while preserving its artifact id. */
+export declare function stripRawOutputArtifactNotice(text: string): {
+    text: string;
+    artifactId?: string;
+};
+/** Remove a trailing generated output notice when metadata is unavailable. */
+export declare function stripGeneratedOutputNotice(text: string): string;
+/** Format truncation ranges and recovery hints. */
+export declare function formatTruncationMetaNotice(truncation: TruncationMeta, source?: SourceMeta): string;
+/**
+ * Format styled artifact reference with warning color and brackets.
+ * For TUI rendering of truncation warnings.
+ */
+export declare function formatStyledArtifactReference(artifactId: string, theme: Theme): string;
+/** Describe an incomplete artifact capture. */
+export declare function formatArtifactErrorNotice(error: OutputArtifactError): string;
+/**
+ * Format notices from OutputMeta for LLM consumption.
+ * Returns empty string if no notices needed.
+ */
+export declare function formatOutputNotice(meta: OutputMeta | undefined): string;
+/**
+ * Format styled truncation and artifact capture warnings.
+ * Returns null if neither warning is present.
+ */
+export declare function formatStyledTruncationWarning(meta: OutputMeta | undefined, theme: Theme): string | null;
+/**
+ * Strip the trailing notice that {@link appendOutputNotice} bakes into the
+ * LLM-facing content body. Renderers should call this before printing
+ * `result.content` text in the TUI, because they emit a styled warning line of
+ * their own; without this, users see the same `[Showing lines …]` string twice
+ * (once verbatim from the body, once as the styled `⟨…⟩` warning).
+ *
+ * Safe to call eagerly: returns the input unchanged when no notice is present
+ * (e.g. during streaming, before {@link wrappedExecute} runs).
+ */
+export declare function stripOutputNotice(text: string, meta: OutputMeta | undefined): string;

package/dist/types/tools/read.d.ts

@@ -0,0 +1,139 @@
+import type { SummaryResult } from "@oh-my-pi/pi-natives";
+import type { Component } from "../tui.js";
+import type { RenderResultOptions } from "./renderer.js";
+import type { Theme } from "../theme/theme.js";
+import type { OutputMeta } from "./output-meta.js";
+import type { TruncationResult } from "./streaming-output.js";
+/** Read result metadata retains truncation statistics, not a second copy of the body. */
+export type ReadTruncationStats = Omit<TruncationResult, "content">;
+/** Display metadata for file and URL reads. */
+export interface ReadToolDetails {
+    kind?: "file" | "url";
+    /** Filesystem hyperlink target resolved by the executing tool. */
+    displayTarget?: string;
+    truncation?: ReadTruncationStats;
+    isDirectory?: boolean;
+    resolvedPath?: string;
+    suffixResolution?: {
+        from: string;
+        to: string;
+    };
+    url?: string;
+    finalUrl?: string;
+    contentType?: string;
+    method?: string;
+    notes?: string[];
+    meta?: OutputMeta;
+    /** Full on-disk byte size recorded before applying a file range. */
+    fileSize?: number;
+    /** Full source line count when the read reached EOF and the count is exact. */
+    totalLines?: number;
+    /** Raw text + start line for user-visible TUI rendering, set when content is text-like.
+     * Mirrors the same lines the model receives but without hashline/line-number prefixes,
+     * so the TUI can render the file content with its own gutter without re-parsing the formatted text. */
+    displayContent?: {
+        text: string;
+        startLine: number;
+        lineNumbers?: Array<number | null>;
+    };
+    summary?: {
+        lines: number;
+        elidedSpans: number;
+        elidedLines: number;
+    };
+    /** Number of unresolved git conflicts surfaced by this read (TUI uses for inline `⚠ N` badge). */
+    conflictCount?: number;
+    /** Paths recovered from a delimited read argument; used only by the TUI to render one call as multiple read rows. */
+    displayReadTargets?: string[];
+    /**
+     * Resolved filesystem link target for each {@link displayReadTargets} entry, aligned by index; `null` when a
+     * delimited part has no linkable fs path. Lets the TUI hyperlink each grouped row the same way a standalone read row is.
+     */
+    displayReadTargetLinks?: Array<string | null>;
+}
+/** Split a filesystem path from its trailing read selector. */
+export declare function splitPathAndSel(rawPath: string): {
+    path: string;
+    sel?: string;
+};
+/**
+ * Variant of {@link splitPathAndSel} for internal URLs (`scheme://...`).
+ *
+ * The filesystem-path splitter is intentionally conservative: it refuses to
+ * peel a trailing `:<chunk>` unless that chunk matches the strict selector
+ * grammar. That rule is right for filesystem paths (a file named `a:1-50` is
+ * legal) but wrong for internal URLs, where any trailing `:<chunk>` after the
+ * scheme is unambiguously a read-tool selector — even if malformed (e.g.
+ * `artifact://3:raw:-100-5`).
+ *
+ * This function iteratively peels selector-shaped chunks (well-formed plus
+ * common malformed shapes like `:-N-M`) so the rest of the read tool can pass a
+ * clean URL to the protocol handler and surface selector errors via parseSel
+ * instead of as misleading "host invalid" errors from the handler. Schemes
+ * whose resource URIs may legitimately contain colons (`mcp://`) are skipped.
+ *
+ * Falls back to the input unchanged when nothing matches.
+ */
+export declare function splitInternalUrlSel(rawPath: string): {
+    path: string;
+    sel?: string;
+};
+/** Recognize HTTP URLs and www-prefixed external read targets. */
+export declare function isReadableUrlPath(value: string): boolean;
+/** Return the first selected line when every range has valid one-based bounds. */
+export declare function readSelectorRangeStart(selector: string): number | undefined;
+export interface ReadRenderArgs {
+    path?: unknown;
+    file_path?: unknown;
+    offset?: number;
+    limit?: number;
+    raw?: boolean;
+}
+/** Absolute fs path the read result actually resolved to, used as the OSC 8 link
+ * target when the structured `resolvedPath` isn't set (the common plain-file and
+ * image reads only record the path in `meta.source`). URL/internal sources are
+ * not fs paths, so only `type: "path"` qualifies. */
+export declare function readSourceFsPath(details: ReadToolDetails | undefined): string | undefined;
+/** Render file, image, and URL reads in the transcript. */
+export declare const readToolRenderer: {
+    renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: ReadToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: ReadRenderArgs): Component;
+    mergeCallAndResult: true;
+};
+/** Inclusive line range describing one elided span in a structural summary. */
+export interface ElidedRange {
+    start: number;
+    end: number;
+}
+/**
+ * Decide whether the kept lines surrounding an elided range collapse to a
+ * single brace-pair line in the rendered summary. Returns true when the head
+ * line ends with `{` / `(` / `[` and the tail line is the matching closer
+ * (optionally followed by terminating punctuation like `;`, `,`, or further
+ * closers — e.g. `};`, `})`, `]);`).
+ */
+export declare function canMergeBracePair(headLine: string, tailLine: string): boolean;
+/** Format one summary line with the selected line-prefix mode. */
+export declare function formatSingleLine(line: number, text: string, shouldAddHashLines: boolean, shouldAddLineNumbers: boolean): string;
+/** Format the boundary lines around an elided brace-pair body. */
+export declare function formatMergedBraceLine(startLine: number, endLine: number, headText: string, tailText: string, shouldAddHashLines: boolean, shouldAddLineNumbers: boolean): {
+    model: string;
+    display: string;
+};
+/** Format a structural summary using the supplied file-display preferences. */
+export declare function formatReadSummary(displayMode: {
+    hashLines: boolean;
+    lineNumbers: boolean;
+}, summary: SummaryResult): {
+    text: string;
+    displayText: string;
+    elidedRanges: ElidedRange[];
+    elidedLines: number;
+};

package/dist/types/tools/renderer.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Tool renderer contract: how a tool call and its result are turned into
+ * transcript components. Built-in renderers live beside this file; the
+ * coding-agent tools implement the matching `*Details` payloads.
+ */
+import type { Component } from "../tui.js";
+import type { Theme } from "../theme/theme.js";
+/** Display state handed to `renderCall`/`renderResult`. */
+export interface RenderResultOptions {
+    /** Whether the result view is expanded */
+    expanded: boolean;
+    /** Whether this is a partial/streaming result */
+    isPartial: boolean;
+    /** Current spinner frame index for animated elements (0-9, only provided during partial results) */
+    spinnerFrame?: number;
+    /**
+     * True once arguments are final (`message_end` / `setArgsComplete`).
+     * Exclusive tools can sit here while an earlier call still runs.
+     */
+    argsComplete?: boolean;
+    /**
+     * True once this specific call has begun executing (`tool_execution_start`).
+     * Streamed `xd://` previews stay queued until this is set.
+     */
+    executionStarted?: boolean;
+}
+/** Render options for a result, plus the tool-specific context the transcript threads through. */
+export type RenderResultContextOptions = RenderResultOptions & {
+    renderContext?: Record<string, unknown>;
+};
+/** Tool result shape a renderer receives: content blocks plus the tool's typed `details`. */
+export interface ToolRenderResult<TDetails = unknown> {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: TDetails;
+    isError?: boolean;
+}
+/**
+ * Per-renderer opt-in for a full viewport replay when the first result
+ * replaces a painted pending-call render. A predicate receives the painted
+ * call args and render options so the repaint stays scoped to the pending
+ * shapes that actually re-anchor (an over-eager replay wipes native
+ * scrollback on direct terminals).
+ */
+export type FirstResultViewportRepaint<TArgs = unknown> = boolean | ((args: TArgs, options: RenderResultOptions) => boolean);
+/** Semantic activity text consumed by the transcript's generic compact card. */
+export interface ToolActivitySummary {
+    label: string;
+    detail?: string;
+}
+/** Live execution fields that are safe for compact transcript presentation. */
+export interface ToolActivityContext {
+    readonly expanded: boolean;
+    readonly isPartial: boolean;
+    readonly spinnerFrame?: number;
+    /** Tool-specific render context (same shape `renderCall` receives), when available. */
+    readonly renderContext?: Record<string, unknown>;
+}
+/**
+ * A tool's transcript presentation: call preview, result view, and repaint/animation hints.
+ * Method signatures are intentionally bivariant so a renderer typed over its own
+ * `TArgs`/`TDetails` is assignable to the untyped registry entry. Either render
+ * hook may return `undefined` to paint nothing for that phase.
+ */
+export interface ToolRenderer<TArgs = unknown, TDetails = unknown> {
+    renderCall(args: TArgs, options: RenderResultOptions, theme: Theme): Component | undefined;
+    renderResult(result: ToolRenderResult<TDetails>, options: RenderResultContextOptions, theme: Theme, args?: TArgs): Component | undefined;
+    mergeCallAndResult?: boolean;
+    /** Describes current activity without coupling a renderer to terminal layout. */
+    activitySummary?(args: TArgs, context: ToolActivityContext): ToolActivitySummary;
+    /** Render without background box, inline in the response flow */
+    inline?: boolean;
+    /**
+     * Whether the renderer's pending-call path visibly consumes
+     * `options.spinnerFrame`. Used to avoid scheduling repaint ticks for live
+     * partial calls whose bytes cannot change between spinner frames.
+     */
+    animatedPendingPreview?: boolean | ((args: TArgs) => boolean);
+    /**
+     * Whether the renderer's partial-result path visibly consumes
+     * `options.spinnerFrame`.
+     */
+    animatedPartialResult?: boolean | ((args: TArgs) => boolean);
+    /**
+     * Whether replacing a pending call render with the first result requires a
+     * full viewport repaint. Use for merged renderers whose pending rows can be
+     * re-anchored instead of preserved by the result render.
+     */
+    forceFirstResultViewportRepaint?: FirstResultViewportRepaint<TArgs>;
+    /**
+     * Whether settling a provisional partial result into the final render requires
+     * a full viewport repaint. Use when the result renderer changes chrome or
+     * frame topology at `options.isPartial: true -> false`.
+     */
+    forceResultViewportRepaintOnSettle?: boolean;
+}

package/dist/types/tools/report-tool-issue.d.ts

@@ -0,0 +1,8 @@
+import type { Component } from "../index.js";
+import type { Theme } from "../theme/theme.js";
+/** Call preview for an `xd://report_issue` write. */
+export declare function renderReportIssueDeviceCall(content: unknown, uiTheme: Theme): Component;
+/** Device name for automatic tool issue reports. */
+export declare const REPORT_ISSUE_DEVICE_NAME = "report_issue";
+/** Internal device URL for automatic tool issue reports. */
+export declare const REPORT_ISSUE_DEVICE_PATH = "xd://report_issue";

package/dist/types/tools/resolve.d.ts

@@ -0,0 +1,47 @@
+import type { Component } from "../index.js";
+import type { RenderResultOptions } from "./renderer.js";
+import type { Theme } from "../theme/theme.js";
+import { Ellipsis } from "../render/index.js";
+/** Device name for applying a staged action. */
+export declare const RESOLVE_DEVICE_NAME = "resolve";
+/** Device name for discarding a staged action. */
+export declare const REJECT_DEVICE_NAME = "reject";
+/** Device name for submitting a plan. */
+export declare const PROPOSE_DEVICE_NAME = "propose";
+/** Plain-text staged-action device names. */
+export type ResolutionDeviceName = typeof RESOLVE_DEVICE_NAME | typeof REJECT_DEVICE_NAME | typeof PROPOSE_DEVICE_NAME;
+/** Resolution applied to a staged action. */
+export type ResolveAction = "apply" | "discard";
+/** Details payload carried on a resolve/reject dispatch result (`XdevDispatch.inner`). */
+export interface ResolveDetails {
+    action: ResolveAction;
+    reason: string;
+    sourceToolName?: string;
+    label?: string;
+    sourceResultDetails?: unknown;
+}
+/** Invoker input for queued pending-preview handlers. */
+export interface ResolveInvocation {
+    action: ResolveAction;
+    reason: string;
+}
+/** Streaming-safe call preview for a resolution-device write: `Resolve/Reject/Propose: <text>`. */
+export declare function renderResolutionDeviceCall(device: ResolutionDeviceName, content: unknown, uiTheme: Theme): Component;
+/** Render the first content line of a pending device write. */
+export declare function renderDeviceCallPreview(title: string, content: unknown, uiTheme: Theme, ellipsis?: Ellipsis): Component;
+/** Render staged-action acceptance or rejection. */
+export declare const resolveRenderer: {
+    renderCall(args: Partial<ResolveInvocation>, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: ResolveDetails;
+        isError?: boolean;
+    }, _options: RenderResultOptions, uiTheme: Theme): Component;
+    inline: true;
+    mergeCallAndResult: true;
+};
+/** Whether an xd:// device name is one of the plain-text resolution devices. */
+export declare function isResolutionDeviceName(name: string): name is ResolutionDeviceName;