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

package/src/tools/vibe.ts

@@ -1,6 +1,12 @@
 import type { Component } from "../tui";
 import { Text } from "../components/text";
-import { shimmerEnabled, shimmerText } from "../theme/shimmer";
+import { describeShimmer, shimmerEnabled, shimmerText } from "../theme/shimmer";
+import type { TspCardStatus, TspSpan, TspTone } from "@oh-my-pi/pi-wire";
+import { compact, elapsed, node, row, span, text } from "../native/describe";
+import type { NativeChild, NativeNode } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorView, noteText, resultText, toolHead } from "./native-view";
 import type { Theme } from "../theme/theme";
 import { oneLineLabel } from "./task";
 import { renderStatusLine } from "../render/index";
@@ -14,7 +20,7 @@ import {
 	type ToolUIStatus,
 	truncateToWidth,
 } from "../render/render-utils";
-import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import type { NativeToolView, RenderResultOptions, ToolRenderer, ToolRenderResult } from "./renderer";
 /** Operation represented by a worker-session tool result. */
 export type VibeOp = "spawn" | "send" | "wait" | "kill" | "list";
 
@@ -294,9 +300,206 @@ function describeCall(op: VibeOp, args: VibeRenderArgs | undefined): string {
 	}
 }
 
+// =============================================================================
+// Native (TSP) Description — the terminal clocks spinners, shimmer and timers
+// =============================================================================
+
+/** Untruncated head detail for a vibe call (native twin of the ANSI call label). */
+function vibeNativeLabel(op: VibeOp, args: VibeRenderArgs | undefined): string {
+	switch (op) {
+		case "spawn":
+			return `spawn ${args?.cli ?? "?"}${args?.name ? ` · ${args.name}` : ""}`;
+		case "send":
+			return `send → ${args?.session ?? "?"}`;
+		case "wait":
+			return args?.sessions?.length ? `wait on ${args.sessions.join(", ")}` : "wait on running sessions";
+		case "kill":
+			return `kill ${args?.session ?? "?"}`;
+		case "list":
+			return "sessions";
+	}
+}
+
+/** The director's composed message as `>`-prefixed wrapped text, or undefined when empty. */
+function vibeComposer(message: string): NativeNode | undefined {
+	const trimmed = plainText(message).trim();
+	if (!trimmed) return undefined;
+	return text([span("> ", "accent"), span(trimmed, "toolOutput")], { wrap: "word", role: "omp.vibe.composer" });
+}
+
+function vibeScreenStatus(
+	screen: VibeScreenSnapshot,
+	settled: "completed" | "failed" | "cancelled" | undefined,
+): [TspCardStatus, TspTone] {
+	if (settled === "failed") return ["error", "error"];
+	if (settled === "cancelled") return ["cancelled", "warning"];
+	if (settled === "completed") return ["done", "success"];
+	switch (screen.state) {
+		case "running":
+			return ["running", "accent"];
+		case "starting":
+			return ["pending", "accent"];
+		case "idle":
+			return ["done", "success"];
+		case "dead":
+			return ["cancelled", "muted"];
+	}
+}
+
+/** One worker "TV" as a nested card: identity head, roster meta, live trace, output tail. */
+function describeVibeScreen(
+	screen: VibeScreenSnapshot,
+	settled: "completed" | "failed" | "cancelled" | undefined,
+	nowMs: number,
+): NativeNode {
+	const live = screen.state === "running" || screen.state === "starting";
+	const [status, tone] = vibeScreenStatus(screen, settled);
+	const head: TspSpan[] = [
+		live && shimmerEnabled()
+			? span(screen.id, "accent", { fx: "shimmer" })
+			: span(screen.id, live ? "accent" : "toolOutput"),
+		span(` ${settled ?? screen.state}`, "dim"),
+		span(` ${screen.turns}t${screen.queued > 0 ? `+${screen.queued}q` : ""}`, "muted"),
+	];
+	if (screen.model) head.push(span(` ${plainText(screen.model)}`, "muted"));
+	const body: NativeChild[] = [
+		row(
+			compact([
+				node("badge", { text: screen.cli, tone }),
+				screen.turnStartedAt !== undefined ? elapsed(nowMs - screen.turnStartedAt, !live) : undefined,
+			]),
+			{ gap: "sm" },
+		),
+	];
+	if (live) {
+		if (screen.turnMessage) {
+			body.push(text([span("> ", "accent"), span(plainText(screen.turnMessage), "dim")], { truncate: "end" }));
+		}
+		for (const line of screen.trace.slice(-TV_TRACE_EXPANDED)) {
+			body.push(text([span(plainText(line), "dim")], { truncate: "end" }));
+		}
+		const detail = screen.lastIntent ?? screen.currentToolArgs;
+		if (screen.currentTool) {
+			body.push(describeShimmer([{ text: plainText(`${screen.currentTool}${detail ? `: ${detail}` : ""}`) }]));
+		} else if (screen.lastIntent) {
+			body.push(text([span(plainText(screen.lastIntent), "muted")], { truncate: "end" }));
+		}
+		for (const line of screen.outputTail.slice(-TV_OUTPUT_EXPANDED)) {
+			if (line.trim().length > 0) body.push(text([span(plainText(line), "muted")], { truncate: "end" }));
+		}
+	} else if (screen.lastActivity) {
+		body.push(text([span(plainText(screen.lastActivity), "muted")], { truncate: "end" }));
+	}
+	if (settled) {
+		body.push(
+			text([
+				span(
+					`turn ${settled} — result delivered`,
+					settled === "completed" ? "success" : settled === "failed" ? "error" : "warning",
+				),
+			]),
+		);
+	}
+	return node(
+		"card",
+		{
+			role: "omp.vibe.screen",
+			status,
+			tone,
+			head,
+			collapsible: true,
+			preview: { lines: 1 + TV_TRACE_COLLAPSED + TV_OUTPUT_COLLAPSED + 1 },
+			inset: true,
+		},
+		body,
+		screen.id,
+	);
+}
+
+function describeVibeResult(
+	op: VibeOp,
+	result: ToolRenderResult<VibeToolDetails>,
+	args: VibeRenderArgs | undefined,
+): NativeToolView {
+	const details = result.details;
+	const label = vibeNativeLabel(op, args);
+	if (result.isError) return { ...errorView("Vibe", resultText(result) || "vibe failed", label), inline: true };
+	if (!details) {
+		const fallback = resultText(result).trim();
+		return { head: toolHead("Vibe", label), inline: true, body: fallback ? [noteText(fallback)] : [] };
+	}
+
+	if (op === "spawn" || op === "send") {
+		const message = op === "spawn" ? (args?.prompt ?? "") : (args?.message ?? "");
+		const head: TspSpan[] =
+			op === "spawn"
+				? [
+						...toolHead("Vibe", "spawn"),
+						span(" "),
+						span(details.spawned?.cli ?? args?.cli ?? "?", "accent strong"),
+						span(" "),
+						span(plainText(details.spawned?.id ?? args?.name ?? ""), "accent"),
+					]
+				: [...toolHead("Vibe", "send →"), span(" "), span(plainText(args?.session ?? "?"), "accent")];
+		const ack: TspSpan =
+			op === "spawn"
+				? span(`turn started${details.spawned ? ` (job ${details.spawned.jobId})` : ""}`, "success")
+				: details.send?.mode === "steered"
+					? span("steered into the running turn", "success")
+					: details.send?.mode === "queued"
+						? span("mid-turn — queued as the next turn", "warning")
+						: span(`turn started${details.send?.jobId ? ` (job ${details.send.jobId})` : ""}`, "success");
+		return {
+			head,
+			inline: true,
+			tone: details.send?.mode === "queued" ? "warning" : undefined,
+			body: compact([vibeComposer(message), text([ack], { wrap: "word" })]),
+			preview: { lines: 3 },
+		};
+	}
+
+	if (op === "kill") {
+		const note = details.killed?.cancelledTurn ? "in-flight turn cancelled" : undefined;
+		return { head: toolHead("Vibe", `kill ${details.killed?.id ?? args?.session ?? "?"}`, note), inline: true };
+	}
+
+	const screens = details.screens;
+	const hiddenKilled = details.hiddenKilled?.length ?? 0;
+	const killedMeta = hiddenKilled > 0 ? span(` · ${hiddenKilled} killed hidden`, "dim") : undefined;
+	if (screens.length === 0) {
+		const gist = hiddenKilled > 0 ? "no live sessions" : resultText(result).trim() || "no sessions";
+		const head = toolHead("Vibe", op, gist);
+		if (killedMeta) head.push(killedMeta);
+		return { head, tone: "warning", inline: true };
+	}
+	const settledById = new Map(details.wait?.settled.map(entry => [entry.id, entry.status] as const) ?? []);
+	const running = screens.filter(screen => screen.state === "running" || screen.state === "starting").length;
+	const title =
+		op === "wait"
+			? details.wait?.waiting === true
+				? "wait — watching the wall"
+				: "wait"
+			: `sessions (${screens.length})`;
+	const head: TspSpan[] = toolHead("Vibe", title);
+	if (running > 0) head.push(span(` · ${running} on air`, "accent"));
+	if (settledById.size > 0) head.push(span(` · ${settledById.size} settled`, "success"));
+	if (details.wait?.timedOut) head.push(span(" · timed out", "warning"));
+	if (killedMeta) head.push(killedMeta);
+	const nowMs = Date.now();
+	return {
+		head,
+		inline: true,
+		tone: details.wait?.timedOut ? "warning" : undefined,
+		body: screens.map(screen => describeVibeScreen(screen, settledById.get(screen.id), nowMs)),
+		preview: "auto",
+	};
+}
+
 /** Build the shared vibe renderer for one tool name. */
 export function createVibeToolRenderer(op: VibeOp) {
 	const composerOp = op === "spawn" || op === "send";
+	const callMemo = new OwnerMemo<NativeToolView | undefined>();
+	const resultMemo = new OwnerMemo<NativeToolView | undefined>();
 	return {
 		inline: true,
 		mergeCallAndResult: true,
@@ -429,5 +632,30 @@ export function createVibeToolRenderer(op: VibeOp) {
 				return lines;
 			});
 		},
+
+		describeCall(args: VibeRenderArgs): NativeToolView | undefined {
+			const message = op === "spawn" ? (args?.prompt ?? "") : op === "send" ? (args?.message ?? "") : "";
+			return callMemo.get(args, [vibeNativeLabel(op, args), message], () => {
+				const head = toolHead("Vibe", vibeNativeLabel(op, args));
+				if (!composerOp) return { head, inline: true };
+				return {
+					head,
+					inline: true,
+					body: compact([
+						vibeComposer(message),
+						node("spinner", { label: [span(op === "spawn" ? "booting CLI…" : "delivering…", "dim")] }),
+					]),
+					preview: { lines: 3 },
+				};
+			});
+		},
+
+		describeResult(
+			result: ToolRenderResult<VibeToolDetails>,
+			_options: RenderResultOptions,
+			args?: VibeRenderArgs,
+		): NativeToolView | undefined {
+			return resultMemo.get(result, [], () => describeVibeResult(op, result, args));
+		},
 	} satisfies ToolRenderer<VibeRenderArgs, VibeToolDetails>;
 }

package/src/tools/wait.ts

@@ -26,6 +26,13 @@ import {
 import type { StructuredSubagentOutput } from "./task";
 import type { RenderResultOptions, ToolRenderer, ToolActivitySummary } from "./renderer";
 import type { IrcDeliveryReceipt, IrcMessage } from "./irc";
+import type { TspSpan } from "@oh-my-pi/pi-wire";
+import { card as cardNode, compact, elapsed, md, node, row, span, text } from "../native/describe";
+import type { NativeNode } from "../native/node";
+import { OwnerMemo } from "../native/memo";
+import { plainText } from "../native/spans";
+import { errorView, resultText, toolHead } from "./native-view";
+import type { NativeToolView, ToolRenderResult } from "./renderer";
 
 /** Whether a wait snapshot contains only running jobs and no cancellations. */
 export function isWaitingPollDetails(details: unknown): boolean {
@@ -541,7 +548,7 @@ export function createIrcMessageCard(
 	if (card.replyTo) meta.push("reply");
 	const age = messageAge(card.timestamp);
 	if (age) meta.push(age);
-	return createCachedComponent(
+	const component = createCachedComponent(
 		getExpanded,
 		(width, expanded) => {
 			const lines = [renderStatusLine({ iconOverride: ircGlyph(uiTheme), title, meta }, uiTheme)];
@@ -552,8 +559,163 @@ export function createIrcMessageCard(
 		},
 		{ paddingX: 1 },
 	);
+	// Terminal-local collapse replaces `getExpanded`; the node never changes after creation.
+	const described = cardNode(
+		{
+			role: `omp.irc.${card.kind}`,
+			tone: "info",
+			head: [
+				span(plainText(title), "toolTitle strong"),
+				...meta.filter(part => part !== age).map(part => span(` ${part}`, "muted")),
+			],
+			collapsible: body.trim().length > 0,
+			preview: { lines: 3 },
+		},
+		compact([
+			card.timestamp
+				? row([elapsed(Date.now() - card.timestamp), text([span("ago", "dim")])], { gap: "xs" })
+				: undefined,
+			body.trim() ? md(body) : undefined,
+		]),
+	);
+	return Object.assign(component, { describe: () => described });
+}
+
+/** One job row: type badge, id + label, terminal-clocked duration (live while running), preview below. */
+function describeJob(job: JobSnapshot): NativeNode {
+	const running = job.status === "running";
+	const label = job.label.trim() !== job.id ? plainText(job.label.split(/\r?\n/)[0] ?? "") : "";
+	const spans: TspSpan[] = [
+		span(plainText(job.id), running ? "accent" : "toolOutput", running ? { fx: "shimmer" } : undefined),
+	];
+	if (label) spans.push(span(` ${label}`, "toolOutput"));
+	if (job.exitCode !== undefined) spans.push(span(` exit ${job.exitCode}`, job.exitCode === 0 ? "muted" : "error"));
+	const tone =
+		job.status === "completed"
+			? "success"
+			: job.status === "failed"
+				? "error"
+				: job.status === "cancelled"
+					? "warning"
+					: "accent";
+	const artifactError = job.meta?.artifactError ?? job.artifactError;
+	const preview = flattenStructuredPreview(
+		stripTaskResultEnvelope(
+			stripOutputNotice(job.errorText?.trim() || job.resultText?.trim() || "", job.meta).trim(),
+		),
+	);
+	return node(
+		"col",
+		{ role: "omp.wait.job", tone },
+		compact([
+			row(
+				[
+					node("badge", { text: job.type, tone }),
+					text(spans, { truncate: "end", grow: 1 }),
+					elapsed(job.durationMs, !running),
+				],
+				{ gap: "sm" },
+			),
+			artifactError && text([span(formatArtifactErrorNotice(artifactError), "warning")], { wrap: "word" }),
+			preview
+				? text([span(plainText(preview), job.errorText ? "error" : "dim")], {
+						wrap: "word",
+						lines: PREVIEW_LINES_EXPANDED,
+					})
+				: undefined,
+		]),
+		job.id,
+	);
 }
 
+function describeJobsResult(
+	result: ToolRenderResult<CoordinationDetails>,
+	isPartial: boolean,
+): NativeToolView | undefined {
+	let jobs = result.details?.jobs ?? [];
+	const agents = result.details?.agents ?? [];
+	if (jobs.length === 0 && agents.length === 0) {
+		return {
+			head: toolHead("Wait"),
+			tone: "warning",
+			body: [text([span(plainText(resultText(result) || "No jobs to process"), "dim")])],
+		};
+	}
+	if (!isPartial && agents.length === 0) {
+		jobs = jobs.filter(job => job.status !== "running");
+		if (jobs.length === 0) return undefined;
+	}
+	const counts = { completed: 0, failed: 0, cancelled: 0, running: 0 };
+	for (const job of jobs) counts[job.status]++;
+	const noun = jobs.length === 1 ? "job" : "jobs";
+	const title =
+		jobs.length === 0
+			? `${agents.length} running agent${agents.length === 1 ? "" : "s"} — no jobs`
+			: counts.running > 0
+				? counts.running === jobs.length
+					? `waiting on ${jobs.length} ${noun}`
+					: `waiting on ${counts.running} of ${jobs.length} ${noun}`
+				: `${jobs.length} ${noun} settled`;
+	const head: TspSpan[] = [span(title, "toolTitle strong")];
+	if (counts.completed > 0) head.push(span(` ${counts.completed} done`, "success"));
+	if (counts.failed > 0) head.push(span(` ${counts.failed} failed`, "error"));
+	if (counts.cancelled > 0) head.push(span(` ${counts.cancelled} cancelled`, "warning"));
+	const order: Record<JobSnapshot["status"], number> = { running: 0, failed: 1, cancelled: 2, completed: 3 };
+	const sorted = [...jobs].sort((a, b) => order[a.status] - order[b.status] || b.durationMs - a.durationMs);
+	const body: NativeNode[] = sorted.map(describeJob);
+	for (const agent of agents) {
+		const spans: TspSpan[] = [span(plainText(agent.id), "muted")];
+		if (agent.activity) spans.push(span(` ${plainText(agent.activity)}`, "toolOutput"));
+		if (agent.parentId) spans.push(span(` ← ${plainText(agent.parentId)}`, "dim"));
+		body.push(
+			node(
+				"row",
+				{ gap: "sm", role: "omp.wait.agent" },
+				[
+					node("badge", {
+						text: agent.live ? "agent" : "agent · no turn",
+						tone: agent.live ? "accent" : "warning",
+					}),
+					text(spans, { truncate: "end", grow: 1 }),
+					elapsed(agent.ageMs, !agent.live),
+				],
+				`agent:${agent.id}`,
+			),
+		);
+	}
+	return {
+		head,
+		tone: counts.failed > 0 ? "warning" : counts.running > 0 || agents.length > 0 ? "info" : "success",
+		body,
+	};
+}
+
+/** Received-message view: sender head, terminal-clocked age, markdown body. */
+function describeMessage(
+	from: string,
+	ts: number | undefined,
+	bodyText: string,
+	meta: readonly string[],
+): NativeToolView {
+	const head: TspSpan[] = [span(`IRC ← ${plainText(from)}`, "toolTitle strong")];
+	for (const part of meta) head.push(span(` ${part}`, "muted"));
+	return {
+		head,
+		tone: "info",
+		preview: { lines: BODY_LINES_COLLAPSED + 1 },
+		body: compact([
+			ts
+				? row([text([span("received", "dim")]), elapsed(Date.now() - ts), text([span("ago", "dim")])], {
+						gap: "xs",
+					})
+				: undefined,
+			bodyText.trim() ? md(bodyText) : undefined,
+		]),
+	};
+}
+
+const waitResultMemo = new OwnerMemo<NativeToolView | undefined>();
+
 /** Render either a received message or a background-job snapshot. */
 export const waitToolRenderer = {
 	inline: true,
@@ -562,6 +724,24 @@ export const waitToolRenderer = {
 		return { label: "Wait", detail: "Background work or peer message" };
 	},
 	renderCall: waitRenderCall,
+	describeCall(): NativeToolView {
+		return { head: toolHead("Wait"), inline: true };
+	},
+	describeResult(
+		result: ToolRenderResult<CoordinationDetails>,
+		options: RenderResultOptions,
+	): NativeToolView | undefined {
+		return waitResultMemo.get(result, [options.isPartial], () => {
+			if (result.isError) return errorView("Wait", resultText(result));
+			const details = result.details;
+			if (details?.interrupted) {
+				return { head: toolHead("Wait", "interrupted by message"), tone: "info", inline: true };
+			}
+			const waited = details?.waited;
+			if (!waited) return describeJobsResult(result, options.isPartial);
+			return describeMessage(waited.from, waited.ts, waited.body, waited.replyTo ? ["reply"] : []);
+		});
+	},
 	renderResult(
 		result: { content: Array<{ type: string; text?: string }>; details?: CoordinationDetails; isError?: boolean },
 		options: RenderResultOptions,

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
  *
@@ -23,6 +23,11 @@ import {
 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;
 
@@ -241,9 +246,116 @@ export function renderSearchCall(
 	return new Text(text, 0, 0);
 }
 
+type SearchRenderArgs = { query?: string; [key: string]: unknown };
+
+const SEARCH_TITLE = "Web search";
+
+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,
+	};
+}
+
+/** 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}`,
+	);
+}
+
+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")],
+		};
+	}
+
+	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;
+
+	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>;