@oh-my-pi/pi-tui 18.4.2 → 18.4.4

package/src/tools/web-search.ts

@@ -1,4 +1,4 @@
-import type { ToolRenderer } from "./renderer";
+import type { NativeToolView, ToolRenderer, ToolRenderResult } from "./renderer";
 /**
  * Web Search TUI Rendering
  *
@@ -22,6 +22,12 @@ import {
 } from "../render/render-utils";
 import { renderStatusLine, renderTreeList, urlHyperlink } from "../render";
 import { framedToolCard } from "../render/tool-card";
+import { getSearchProviderLabel, type SearchResponse } from "./web-search-types";
+import { compact, md, node, span, text } from "../native/describe";
+import type { NativeChild } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorText, noteText, resultText } from "./native-view";
 
 const MAX_COLLAPSED_ITEMS = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 
@@ -240,181 +246,116 @@ export function renderSearchCall(
 	return new Text(text, 0, 0);
 }
 
-/** Render web search queries, answers, and cited sources. */
-export const webSearchToolRenderer = {
-	renderCall: renderSearchCall,
-	renderResult: renderSearchResult,
-	mergeCallAndResult: true,
-} satisfies ToolRenderer<{ query?: string; [key: string]: unknown }, SearchRenderDetails>;
+type SearchRenderArgs = { query?: string; [key: string]: unknown };
 
-/**
- * Web Search Types
- *
- * Unified types for web search responses across supported providers.
- */
+const SEARCH_TITLE = "Web search";
 
-export const SEARCH_PROVIDER_OPTIONS = [
-	{
-		value: "auto",
-		label: "Auto",
-		description: "Automatically uses the first configured web-search provider",
-	},
-	{
-		value: "parallel",
-		label: "Parallel",
-		description: "Uses API auth when configured; otherwise searches through the keyless public MCP",
-	},
-	{
-		value: "perplexity",
-		label: "Perplexity",
-		description: "Uses auth when configured; explicit selection falls back to anonymous search",
-	},
-	{
-		value: "gemini",
-		label: "Gemini",
-		description: "Google Search grounding via Gemini (uses google-gemini-cli or google-antigravity OAuth)",
-	},
-	{
-		value: "anthropic",
-		label: "Anthropic",
-		description: "Claude's native web_search tool (uses Anthropic OAuth or ANTHROPIC_API_KEY)",
-	},
-	{
-		value: "codex",
-		label: "OpenAI Codex",
-		description: "OpenAI's native web_search (uses ChatGPT OAuth via /login openai-codex)",
-	},
-	{
-		value: "openai",
-		label: "OpenAI API",
-		description:
-			"OpenAI hosted web_search via OPENAI_API_KEY or OpenAI API-key registry credentials; billed by API usage",
-	},
-	{
-		value: "xai",
-		label: "xAI",
-		description:
-			"Grok web search via xAI Responses API (uses SuperGrok/X Premium+ OAuth via /login xai-oauth, or XAI_API_KEY)",
-	},
-	{
-		value: "openrouter",
-		label: "OpenRouter",
-		description: "OpenRouter plugins-based web search with model-selected grounding",
-	},
-	{ value: "zai", label: "Z.AI", description: "Calls Z.AI webSearchPrime MCP" },
-	{ value: "exa", label: "Exa", description: "API via /login exa or EXA_API_KEY; explicit keyless fallback via MCP" },
-	{ value: "tinyfish", label: "TinyFish", description: "Requires TINYFISH_API_KEY" },
-	{ value: "jina", label: "Jina", description: "Requires JINA_API_KEY" },
-	{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY and Kagi Search API beta access" },
-	{ value: "tavily", label: "Tavily", description: "Requires TAVILY_API_KEY" },
-	{
-		value: "firecrawl",
-		label: "Firecrawl",
-		description: "Uses Firecrawl API when FIRECRAWL_API_KEY is set; falls back to keyless mode",
-	},
-	{ value: "brave", label: "Brave", description: "Requires BRAVE_API_KEY" },
-	{
-		value: "kimi",
-		label: "Kimi",
-		description:
-			"Kimi Code search (requires a Kimi Code Console key via KIMI_SEARCH_API_KEY/MOONSHOT_SEARCH_API_KEY or /login kimi-code; not MOONSHOT_API_KEY)",
-	},
-	{ value: "synthetic", label: "Synthetic", description: "Requires SYNTHETIC_API_KEY" },
-	{ value: "ollama", label: "Ollama", description: "Requires OLLAMA_CLOUD_API_KEY" },
-	{ value: "searxng", label: "SearXNG", description: "Requires SEARXNG_ENDPOINT or searxng.endpoint" },
-	{
-		value: "startpage",
-		label: "Startpage",
-		description: "Credential-free scrape of Startpage (Google-backed) results; may be bot-challenged",
-	},
-	{
-		value: "duckduckgo",
-		label: "DuckDuckGo",
-		description: "Credential-free best-effort fallback; may be bot-challenged on datacenter/shared-egress IPs",
-	},
-	{
-		value: "ecosia",
-		label: "Ecosia",
-		description: "Credential-free browser-backed scrape of Ecosia (Google-backed) results",
-	},
-	{
-		value: "google",
-		label: "Google",
-		description: "Credential-free browser-backed fallback; slower and may be bot-challenged",
-	},
-	{
-		value: "mojeek",
-		label: "Mojeek",
-		description: "Credential-free browser-backed scrape of Mojeek's independent index",
-	},
-	{
-		value: "public",
-		label: "Public Web",
-		description: "Queries every credential-free engine in parallel and consolidates deduplicated results",
-	},
-] as const;
-
-/** Supported web search providers (every option except `auto`). */
-export type SearchProviderId = Exclude<(typeof SEARCH_PROVIDER_OPTIONS)[number]["value"], "auto">;
-
-/** Display labels, derived from {@link SEARCH_PROVIDER_OPTIONS}. */
-export const SEARCH_PROVIDER_LABELS = Object.fromEntries(
-	SEARCH_PROVIDER_OPTIONS.flatMap(option => (option.value === "auto" ? [] : [[option.value, option.label] as const])),
-) as Record<SearchProviderId, string>;
-
-/** Source returned by search (all providers) */
-export interface SearchSource {
-	title: string;
-	url: string;
-	snippet?: string;
-	/** ISO date string or relative ("2d ago") */
-	publishedDate?: string;
-	/** Age in seconds for consistent formatting */
-	ageSeconds?: number;
-	author?: string;
+function searchHead(query: string | undefined, meta?: string, badge?: { text: string; title?: string }) {
+	return {
+		title: SEARCH_TITLE,
+		target: query ? plainText(query) : undefined,
+		targetKind: "query" as const,
+		meta: meta ? [meta] : undefined,
+		badges: badge ? [badge] : undefined,
+	};
 }
 
-/** Citation with text reference (LLM-mediated providers) */
-export interface SearchCitation {
-	url: string;
-	title: string;
-	citedText?: string;
+/** One cited source row: domain-initial mark, linked title, muted `domain · age`. */
+function sourceRow(src: SearchResponse["sources"][number], index: number): NativeChild {
+	const url = typeof src.url === "string" ? src.url : "";
+	const title = typeof src.title === "string" && src.title.trim() ? src.title : url.trim() ? url : "Untitled";
+	const domain = url ? getDomain(url) : "";
+	const age =
+		formatAge(src.ageSeconds).replace(/ ago$/, "") ||
+		(typeof src.publishedDate === "string" ? src.publishedDate : "");
+	const meta = [domain, age].filter(Boolean).join(" · ");
+	const initial = (domain.replace(/^www\./, "")[0] ?? "?").toUpperCase();
+	return node(
+		"row",
+		{ gap: "sm", align: "baseline", role: "omp.tool.source", href: url || undefined },
+		compact([
+			node("badge", { text: initial, title: domain || undefined }),
+			text([span(plainText(title), "link", url ? { href: url } : undefined)], { lines: 1, truncate: "end" }),
+			meta ? text([span(plainText(meta), "muted")], { lines: 1 }) : undefined,
+		]),
+		`${index}:${url}`,
+	);
 }
 
-/** Usage metrics */
-export interface SearchUsage {
-	inputTokens?: number;
-	outputTokens?: number;
-	/** Anthropic: number of web search requests made */
-	searchRequests?: number;
-	/** Perplexity: combined token count */
-	totalTokens?: number;
-}
+function describeSearchResult(
+	result: ToolRenderResult<SearchRenderDetails>,
+	args: SearchRenderArgs | undefined,
+): NativeToolView {
+	const details = result.details;
+	const argQuery = typeof args?.query === "string" ? args.query : undefined;
+	if (details?.error) {
+		const provider = details.response?.provider;
+		const label = provider && provider !== "none" ? getSearchProviderLabel(provider) : undefined;
+		return {
+			tool: searchHead(argQuery, label),
+			tone: "error",
+			body: [errorText(plainText(details.error).trim() || "Web search failed")],
+		};
+	}
 
-/** Unified response across providers */
-export interface SearchResponse {
-	provider: SearchProviderId | "none";
-	/** Synthesized answer text (LLM-mediated providers) */
-	answer?: string;
-	/** Search result sources */
-	sources: SearchSource[];
-	/** Text citations with context */
-	citations?: SearchCitation[];
-	/** Intermediate search queries (anthropic) */
-	searchQueries?: string[];
-	/** Follow-up question suggestions (provider-dependent) */
-	relatedQuestions?: string[];
-	/** Token usage metrics */
-	usage?: SearchUsage;
-	/** Model used */
-	model?: string;
-	/** Request ID for debugging */
-	requestId?: string;
-	/** Authentication mode used by the provider (e.g. oauth, api-key) */
-	authMode?: string;
-}
+	const rawText = resultText(result).trim();
+	const response = details?.response;
+	if (!response) {
+		return {
+			tool: searchHead(argQuery),
+			tone: "warning",
+			body: [noteText(rawText || "No response data")],
+		};
+	}
+
+	const sources = Array.isArray(response.sources) ? response.sources : [];
+	const searchQueries = Array.isArray(response.searchQueries)
+		? response.searchQueries.filter(entry => typeof entry === "string")
+		: [];
+	const providerLabel = response.provider !== "none" ? getSearchProviderLabel(response.provider) : "None";
+	const query = argQuery || searchQueries[0];
+	const answer = (typeof response.answer === "string" ? response.answer.trim() : "") || rawText;
 
-/** Cheap, sync metadata accessor — never triggers a provider load. */
-export function getSearchProviderLabel(id: SearchProviderId): string {
-	return SEARCH_PROVIDER_LABELS[id] ?? id;
+	const authShort =
+		response.authMode === "oauth" ? "OAuth" : response.authMode === "api_key" ? "API" : response.authMode;
+	let providerInfo = response.model ? `${response.model} @ ${providerLabel}` : providerLabel;
+	if (authShort) providerInfo += ` (${authShort})`;
+	const usage = response.usage;
+	const usageParts: string[] = [];
+	if (usage?.inputTokens !== undefined) usageParts.push(`in ${usage.inputTokens}`);
+	if (usage?.outputTokens !== undefined) usageParts.push(`out ${usage.outputTokens}`);
+	if (usage?.totalTokens !== undefined) usageParts.push(`total ${usage.totalTokens}`);
+	if (usage?.searchRequests !== undefined) usageParts.push(`search ${usage.searchRequests}`);
+	const tooltip = plainText([providerInfo, usageParts.join(" · ")].filter(Boolean).join("\n"));
+	const badge = response.model ? { text: plainText(response.model), title: tooltip } : undefined;
+
+	return {
+		tool: searchHead(query, `${providerLabel} · ${formatCount("source", sources.length)}`, badge),
+		tone: sources.length > 0 ? undefined : "warning",
+		body: compact([
+			answer ? { ...md(plainText(answer), { title: tooltip }), key: "answer" } : noteText("No answer text returned"),
+			sources.length > 0
+				? node("col", { role: "omp.tool.files" }, sources.map(sourceRow), "sources")
+				: noteText("No sources returned"),
+		]),
+	};
 }
+
+const searchResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
+/** Render web search queries, answers, and cited sources. */
+export const webSearchToolRenderer = {
+	renderCall: renderSearchCall,
+	renderResult: renderSearchResult,
+	describeCall(args: SearchRenderArgs): NativeToolView {
+		return { tool: searchHead(typeof args.query === "string" ? args.query : undefined), inline: true };
+	},
+	describeResult(
+		result: ToolRenderResult<SearchRenderDetails>,
+		_options: RenderResultOptions,
+		args?: SearchRenderArgs,
+	): NativeToolView | undefined {
+		return searchResultMemo.get(result, [args?.query ?? ""], () => describeSearchResult(result, args));
+	},
+	mergeCallAndResult: true,
+} satisfies ToolRenderer<{ query?: string; [key: string]: unknown }, SearchRenderDetails>;

package/src/tools/write.ts

@@ -22,23 +22,47 @@ import {
 	truncateToWidth,
 } from "../render/render-utils";
 import type { CoordinationDetails } from "./wait";
-import { renderAgentWrite, renderProcWrite, type ProcWriteAction, type ProcWriteDetails } from "./proc-render";
-import { renderCfgWrite, type CfgWriteDetails } from "./cfg-render";
+import {
+	describeAgentWrite,
+	describeProcWrite,
+	renderAgentWrite,
+	renderProcWrite,
+	type ProcWriteAction,
+	type ProcWriteDetails,
+} from "./proc-render";
+import type { TspTone } from "@oh-my-pi/pi-wire";
+import { code, compact, node, span } from "../native/describe";
+import type { NativeChild } from "../native/node";
+import { diagnosticsBadge, diagnosticsSection, displayPath, errorText, fileHref, resultText } from "./native-view";
+import { describeCfgWrite, renderCfgWrite, type CfgWriteDetails } from "./cfg-render";
 import type { FileDiagnosticsResult } from "./lsp";
 import type { OutputMeta } from "./output-meta";
 import type { CardToolResult } from "./result-card";
-import type { RenderResultOptions, ToolActivityContext, ToolActivitySummary, ToolRenderer } from "./renderer";
+import type {
+	NativeToolHead,
+	NativeToolView,
+	RenderResultOptions,
+	ToolActivityContext,
+	ToolActivitySummary,
+	ToolRenderer,
+} from "./renderer";
 import { splitUrlScheme } from "./url-scheme-host";
 import { couldBecomeXdUrl, parseXdUrl } from "./xd-url";
 import {
+	describeXdevCall,
+	describeXdevResult,
 	renderXdevCall,
 	renderXdevResult,
 	xdevActivitySummary,
 	type XdevRenderDispatch,
 	type XdevMountedRenderer,
 } from "./xdev";
-import { isResolutionDeviceName, renderResolutionDeviceCall } from "./resolve";
-import { REPORT_ISSUE_DEVICE_NAME, renderReportIssueDeviceCall } from "./report-tool-issue";
+import { describeResolutionDeviceCall, isResolutionDeviceName, renderResolutionDeviceCall } from "./resolve";
+import {
+	describeReportIssueDeviceCall,
+	REPORT_ISSUE_DEVICE_NAME,
+	renderReportIssueDeviceCall,
+} from "./report-tool-issue";
 import { pendingFileLinkPath } from "./read";
 
 /** Details returned by the write tool for transcript rendering. */
@@ -64,6 +88,8 @@ interface WriteRenderArgs {
 }
 
 const WRITE_PREVIEW_LINES = 6;
+/** Collapsed native write body: the first lines of the file (§7.3). */
+const NATIVE_WRITE_PREVIEW = { lines: 8 } as const;
 
 function countLines(text: string): number {
 	if (!text) return 0;
@@ -416,6 +442,48 @@ function couldBecomeWriteCardUrl(lowerPath: string): boolean {
 	return false;
 }
 
+/** Native view of a `proc://`, `agent://` or `cfg://` write. */
+function describeWriteUrl(
+	routed: { card: WriteUrlCard; target: string },
+	url: string,
+	content: unknown,
+	result: CardToolResult | undefined,
+	details: WriteToolDetails | undefined,
+): NativeToolView {
+	const body = typeof content === "string" ? content : undefined;
+	switch (routed.card.detailsKey) {
+		case "message":
+			return describeAgentWrite(routed.target, body ?? "", result, details?.message);
+		case "proc": {
+			const { id, action } = procWriteTarget(routed.target);
+			return describeProcWrite(id, action, body, result, details?.proc);
+		}
+		case "cfg":
+			return describeCfgWrite(url, body, result, details?.cfg);
+	}
+}
+
+/** Native write head shared by the call and result: `Write · path · 22 lines`, executable/diagnostics chips. */
+function writeToolHead(
+	rawPath: string,
+	content: string,
+	details?: Pick<WriteToolDetails, "madeExecutable" | "resolvedPath" | "diagnostics">,
+): NativeToolHead {
+	const lineCount = countLines(content);
+	const badges: { text: string; tone?: TspTone }[] = [];
+	if (details?.madeExecutable) badges.push({ text: "executable", tone: "success" });
+	const diagnostics = diagnosticsBadge([details?.diagnostics]);
+	if (diagnostics) badges.push(diagnostics);
+	return {
+		title: "Write",
+		target: rawPath ? displayPath(rawPath) : undefined,
+		targetKind: "path",
+		href: fileHref(details?.resolvedPath),
+		meta: lineCount > 0 ? [`${lineCount} line${lineCount === 1 ? "" : "s"}`] : undefined,
+		badges: badges.length > 0 ? badges : undefined,
+	};
+}
+
 /** Render file writes and delegated tool-device calls. */
 export const writeToolRenderer = {
 	/** Compact one-line activity: device writes read as the mounted tool (`LSP · references foo`), file writes as `Write · <path>`. */
@@ -618,6 +686,77 @@ export const writeToolRenderer = {
 			};
 		});
 	},
+	describeCall(
+		args: WriteRenderArgs,
+		options: RenderResultOptions & { renderContext?: WriteRenderContext },
+	): NativeToolView | undefined {
+		const rawPath =
+			typeof args.file_path === "string" ? args.file_path : typeof args.path === "string" ? args.path : "";
+		// Same gating as renderCall: nothing until the path provably is not a device/card URL.
+		if (args.path === undefined && args.file_path === undefined) return undefined;
+		const pathSettled = args.content !== undefined || options.argsComplete === true;
+		const hasStringPath = typeof args.file_path === "string" || typeof args.path === "string";
+		if (hasStringPath && !pathSettled && couldBecomeWriteCardUrl(rawPath.toLowerCase())) return undefined;
+		const routed = writeUrlCard(rawPath);
+		if (routed) return describeWriteUrl(routed, rawPath, args.content, undefined, undefined);
+		if (rawPath && couldBecomeXdUrl(rawPath)) {
+			const xdev = parseXdUrl(rawPath);
+			if (!xdev?.name || args.content === undefined) return undefined;
+			if (isResolutionDeviceName(xdev.name)) return describeResolutionDeviceCall(xdev.name, args.content);
+			if (xdev.name === REPORT_ISSUE_DEVICE_NAME) return describeReportIssueDeviceCall(args.content);
+			return describeXdevCall(xdev.name, args.content, options, options.renderContext?.resolveXdevMounted);
+		}
+		const content = normalizeDisplayText(args.content);
+		return {
+			tool: writeToolHead(rawPath, content),
+			body: content
+				? [
+						code(content, {
+							lang: rawPath ? getLanguageFromPath(rawPath) : undefined,
+							numbers: true,
+						}),
+					]
+				: [],
+			preview: NATIVE_WRITE_PREVIEW,
+		};
+	},
+
+	describeResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: WriteToolDetails; isError?: boolean },
+		options: RenderResultOptions & { renderContext?: WriteRenderContext },
+		args?: WriteRenderArgs,
+	): NativeToolView | undefined {
+		const cardPath =
+			typeof args?.path === "string" ? args.path : typeof args?.file_path === "string" ? args.file_path : "";
+		const routed = writeUrlCard(cardPath, result.details);
+		if (routed) return describeWriteUrl(routed, cardPath, args?.content, result, result.details);
+		const xdev = result.details?.xdev;
+		if (xdev) return describeXdevResult(xdev, result, options, options.renderContext?.resolveXdevMounted);
+		const rawPath =
+			typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
+		const fileContent = normalizeDisplayText(args?.content);
+		const isPartial = options.isPartial === true;
+		const diagnostics = isPartial ? undefined : result.details?.diagnostics;
+		const tool = writeToolHead(rawPath, fileContent, {
+			madeExecutable: !isPartial && result.details?.madeExecutable === true,
+			resolvedPath: result.details?.resolvedPath,
+			diagnostics,
+		});
+		if (result.isError) return { tool, tone: "error", body: [errorText(resultText(result))] };
+		const progressText = resultText(result);
+		const body = compact<NativeChild>([
+			isPartial &&
+				progressText.length > 0 &&
+				node("text", { spans: [span(progressText, "muted")], truncate: "end" }),
+			fileContent.length > 0 &&
+				code(fileContent, {
+					lang: rawPath ? getLanguageFromPath(rawPath) : undefined,
+					numbers: true,
+				}),
+			diagnosticsSection(diagnostics),
+		]);
+		return { tool, body, preview: NATIVE_WRITE_PREVIEW };
+	},
 	mergeCallAndResult: true,
 	// The collapsed pending preview follows the streaming edge with a tail
 	// window once the content outgrows it (`… (N earlier lines)` + last rows);

package/src/tools/xdev.ts

@@ -4,12 +4,16 @@ import { type Component, Container, Text } from "../index";
 import type { Theme } from "../theme/theme";
 import { replaceTabs } from "../render/render-utils";
 import type { RenderResultOptions, ToolActivitySummary, ToolRenderer } from "./renderer";
-import { renderDefaultToolExecution } from "./default-renderer";
+import { describeDefaultToolExecution, renderDefaultToolExecution } from "./default-renderer";
+import type { NativeToolView } from "./renderer";
+import { text } from "../native/describe";
 import { parseMCPToolName } from "./mcp";
 
 /** Mounted device display callbacks, independent of tool execution state. */
 export interface XdevMountedRenderer {
 	label?: string;
+	describeCall?: ToolRenderer["describeCall"];
+	describeResult?: ToolRenderer["describeResult"];
 	renderCall?(...args: Parameters<ToolRenderer["renderCall"]>): unknown;
 	renderResult?(...args: Parameters<ToolRenderer["renderResult"]>): unknown;
 	mergeCallAndResult?: boolean;
@@ -162,6 +166,65 @@ export function renderXdevCall(
 	return renderDefaultToolExecution({ label: mounted?.label ?? name, args, options }, theme);
 }
 
+/** Native form of {@link resolveDeviceRenderer}: the first renderer that can describe. */
+function resolveDeviceDescriber(
+	name: string,
+	mounted: XdevMountedRenderer | undefined,
+): XdevMountedRenderer | undefined {
+	if (mounted && (mounted.describeCall || mounted.describeResult)) return mounted;
+	return rendererLookup?.(name);
+}
+
+/** TSP call view for an `xd://` write: queued card until execution, then the device renderer's own view. */
+export function describeXdevCall(
+	name: string,
+	content: unknown,
+	options: RenderResultOptions,
+	resolveMounted?: (name: string) => XdevMountedRenderer | undefined,
+): NativeToolView | undefined {
+	const mounted = resolveMounted?.(name);
+	const args = decodeInnerArgs(content);
+	if (!options.executionStarted) {
+		return describeDefaultToolExecution({
+			label: `queued ${displayDeviceLabel(name, mounted)}`,
+			args: displayDeviceArgs(args),
+			options: { ...options, isPartial: true, spinnerFrame: undefined },
+		});
+	}
+	const renderer = resolveDeviceDescriber(name, mounted);
+	if (renderer?.describeCall) return renderer.describeCall(args, options);
+	return describeDefaultToolExecution({ label: mounted?.label ?? name, args, options });
+}
+
+/** TSP result view for an `xd://` dispatch, forwarded to the device renderer. */
+export function describeXdevResult(
+	dispatch: XdevRenderDispatch,
+	result: { content: Array<{ type: string; text?: string }>; isError?: boolean },
+	options: RenderResultOptions,
+	resolveMounted?: (name: string) => XdevMountedRenderer | undefined,
+): NativeToolView | undefined {
+	const output = result.content
+		.map(block => (block.type === "text" ? block.text : ""))
+		.filter(Boolean)
+		.join("\n");
+	if (dispatch.mode === "help") return output ? { body: [text(output, { wrap: "word" })] } : undefined;
+	const mounted = resolveMounted?.(dispatch.tool);
+	const renderer = resolveDeviceDescriber(dispatch.tool, mounted);
+	if (renderer?.describeResult) {
+		const innerResult = { content: result.content, details: dispatch.inner, isError: result.isError };
+		const view = renderer.describeResult(innerResult, options, dispatch.args ?? {});
+		if (!view || renderer.mergeCallAndResult || !renderer.describeCall) return view;
+		const call = renderer.describeCall(dispatch.args ?? {}, { ...options, isPartial: false });
+		return { ...view, head: view.head ?? call?.head, body: [...(call?.body ?? []), ...(view.body ?? [])] };
+	}
+	return describeDefaultToolExecution({
+		label: mounted?.label ?? dispatch.tool,
+		args: dispatch.args ?? {},
+		result: { output, isError: result.isError },
+		options,
+	});
+}
+
 /** Forward an `xd://` dispatch result to the mounted tool's renderer. */
 export function renderXdevResult(
 	dispatch: XdevRenderDispatch,