@oh-my-pi/pi-coding-agent 3.14.0 → 3.15.0

package/src/core/tools/web-fetch.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
 import { parse as parseHtml } from "node-html-parser";
+import webFetchDescription from "../../prompts/tools/web-fetch.md" with { type: "text" };
 import { logger } from "../logger";
 
 // =============================================================================
@@ -1492,10 +1493,25 @@ async function handleNpm(url: string, timeout: number): Promise<RenderResult | n
 
 		// Fetch from npm registry - use /latest endpoint for smaller response
 		const latestUrl = `https://registry.npmjs.org/${packageName}/latest`;
-		const result = await loadPage(latestUrl, { timeout });
+		const downloadsUrl = `https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(packageName)}`;
+
+		// Fetch package info and download stats in parallel
+		const [result, downloadsResult] = await Promise.all([
+			loadPage(latestUrl, { timeout }),
+			loadPage(downloadsUrl, { timeout: Math.min(timeout, 5) }),
+		]);
 
 		if (!result.ok) return null;
 
+		// Parse download stats
+		let weeklyDownloads: number | null = null;
+		if (downloadsResult.ok) {
+			try {
+				const dlData = JSON.parse(downloadsResult.content) as { downloads?: number };
+				weeklyDownloads = dlData.downloads ?? null;
+			} catch {}
+		}
+
 		let pkg: {
 			name: string;
 			version: string;
@@ -1520,7 +1536,17 @@ async function handleNpm(url: string, timeout: number): Promise<RenderResult | n
 
 		md += `**Latest:** ${pkg.version || "unknown"}`;
 		if (pkg.license) md += ` · **License:** ${typeof pkg.license === "string" ? pkg.license : pkg.license}`;
-		md += "\n\n";
+		md += "\n";
+		if (weeklyDownloads !== null) {
+			const formatted =
+				weeklyDownloads >= 1_000_000
+					? `${(weeklyDownloads / 1_000_000).toFixed(1)}M`
+					: weeklyDownloads >= 1_000
+						? `${(weeklyDownloads / 1_000).toFixed(1)}K`
+						: String(weeklyDownloads);
+			md += `**Weekly Downloads:** ${formatted}\n`;
+		}
+		md += "\n";
 
 		if (pkg.homepage) md += `**Homepage:** ${pkg.homepage}\n`;
 		const repoUrl = typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
@@ -1555,6 +1581,118 @@ async function handleNpm(url: string, timeout: number): Promise<RenderResult | n
 	return null;
 }
 
+// =============================================================================
+// Crates.io Special Handling
+// =============================================================================
+
+/**
+ * Handle crates.io URLs via API
+ */
+async function handleCratesIo(url: string, timeout: number): Promise<RenderResult | null> {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "crates.io" && parsed.hostname !== "www.crates.io") return null;
+
+		// Extract crate name from /crates/name or /crates/name/version
+		const match = parsed.pathname.match(/^\/crates\/([^/]+)/);
+		if (!match) return null;
+
+		const crateName = decodeURIComponent(match[1]);
+		const fetchedAt = new Date().toISOString();
+
+		// Fetch from crates.io API
+		const apiUrl = `https://crates.io/api/v1/crates/${crateName}`;
+		const result = await loadPage(apiUrl, {
+			timeout,
+			headers: { "User-Agent": "omp-web-fetch/1.0 (https://github.com/anthropics)" },
+		});
+
+		if (!result.ok) return null;
+
+		let data: {
+			crate: {
+				name: string;
+				description: string | null;
+				downloads: number;
+				recent_downloads: number;
+				max_version: string;
+				repository: string | null;
+				homepage: string | null;
+				documentation: string | null;
+				categories: string[];
+				keywords: string[];
+				created_at: string;
+				updated_at: string;
+			};
+			versions: Array<{
+				num: string;
+				downloads: number;
+				created_at: string;
+				license: string | null;
+				rust_version: string | null;
+			}>;
+		};
+
+		try {
+			data = JSON.parse(result.content);
+		} catch {
+			return null;
+		}
+
+		const crate = data.crate;
+		const latestVersion = data.versions?.[0];
+
+		// Format download counts
+		const formatDownloads = (n: number): string =>
+			n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : n >= 1_000 ? `${(n / 1_000).toFixed(1)}K` : String(n);
+
+		let md = `# ${crate.name}\n\n`;
+		if (crate.description) md += `${crate.description}\n\n`;
+
+		md += `**Latest:** ${crate.max_version}`;
+		if (latestVersion?.license) md += ` · **License:** ${latestVersion.license}`;
+		if (latestVersion?.rust_version) md += ` · **MSRV:** ${latestVersion.rust_version}`;
+		md += "\n";
+		md += `**Downloads:** ${formatDownloads(crate.downloads)} total · ${formatDownloads(crate.recent_downloads)} recent\n\n`;
+
+		if (crate.repository) md += `**Repository:** ${crate.repository}\n`;
+		if (crate.homepage && crate.homepage !== crate.repository) md += `**Homepage:** ${crate.homepage}\n`;
+		if (crate.documentation) md += `**Docs:** ${crate.documentation}\n`;
+		if (crate.keywords?.length) md += `**Keywords:** ${crate.keywords.join(", ")}\n`;
+		if (crate.categories?.length) md += `**Categories:** ${crate.categories.join(", ")}\n`;
+
+		// Show recent versions
+		if (data.versions?.length > 0) {
+			md += `\n## Recent Versions\n\n`;
+			for (const ver of data.versions.slice(0, 5)) {
+				const date = ver.created_at.split("T")[0];
+				md += `- **${ver.num}** (${date}) - ${formatDownloads(ver.downloads)} downloads\n`;
+			}
+		}
+
+		// Try to fetch README from docs.rs or repository
+		const docsRsUrl = `https://docs.rs/crate/${crateName}/${crate.max_version}/source/README.md`;
+		const readmeResult = await loadPage(docsRsUrl, { timeout: Math.min(timeout, 5) });
+		if (readmeResult.ok && readmeResult.content.length > 100 && !looksLikeHtml(readmeResult.content)) {
+			md += `\n---\n\n## README\n\n${readmeResult.content}\n`;
+		}
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/markdown",
+			method: "crates.io",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via crates.io API"],
+		};
+	} catch {}
+
+	return null;
+}
+
 // =============================================================================
 // arXiv Special Handling
 // =============================================================================
@@ -1803,6 +1941,7 @@ async function handleSpecialUrls(url: string, timeout: number): Promise<RenderRe
 		(await handleWikipedia(url, timeout)) ||
 		(await handleReddit(url, timeout)) ||
 		(await handleNpm(url, timeout)) ||
+		(await handleCratesIo(url, timeout)) ||
 		(await handleArxiv(url, timeout)) ||
 		(await handleIacr(url, timeout))
 	);
@@ -2131,30 +2270,7 @@ export function createWebFetchTool(_cwd: string): AgentTool<typeof webFetchSchem
 	return {
 		name: "web_fetch",
 		label: "web_fetch",
-		description: `Fetches content from a specified URL and processes it using an AI model
-- Takes a URL and a prompt as input
-- Fetches the URL content, converts HTML to markdown
-- Processes the content with the prompt using a small, fast model
-- Returns the model's response about the content
-- Use this tool when you need to retrieve and analyze web content
-
-Features:
-- Site-specific handlers for GitHub (issues, PRs, repos, gists), Stack Overflow, Wikipedia, Reddit, NPM, arXiv, IACR, and Twitter/X
-- Automatic detection and use of LLM-friendly endpoints (llms.txt, .md suffixes)
-- Binary file conversion (PDF, DOCX, etc.) via markitdown if available
-- HTML to text rendering via lynx if available
-- RSS/Atom feed parsing
-- JSON pretty-printing
-
-Usage notes:
-- IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions.
-- The URL must be a fully-formed valid URL
-- HTTP URLs will be automatically upgraded to HTTPS
-- The prompt should describe what information you want to extract from the page
-- This tool is read-only and does not modify any files
-- Results may be summarized if the content is very large
-- Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL
-- When a URL redirects to a different host, the tool will inform you and provide the redirect URL in a special format. You should then make a new WebFetch request with the redirect URL to fetch the content.`,
+		description: webFetchDescription,
 		parameters: webFetchSchema,
 		execute: async (
 			_toolCallId: string,
@@ -2205,19 +2321,14 @@ export const webFetchTool = createWebFetchTool(process.cwd());
 
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import type { Theme } from "../../modes/interactive/theme/theme";
+import { type Theme, theme } from "../../modes/interactive/theme/theme";
 import type { CustomTool, CustomToolContext, RenderResultOptions } from "../custom-tools/types";
 
-// Tree formatting constants
-const TREE_MID = "├─";
-const TREE_END = "└─";
-const TREE_PIPE = "│";
-const TREE_HOOK = "⎿";
-
 /** Truncate text to max length with ellipsis */
-function truncate(text: string, maxLen: number): string {
+function truncate(text: string, maxLen: number, ellipsis: string): string {
 	if (text.length <= maxLen) return text;
-	return `${text.slice(0, maxLen - 1)}…`;
+	const sliceLen = Math.max(0, maxLen - ellipsis.length);
+	return `${text.slice(0, sliceLen)}${ellipsis}`;
 }
 
 /** Extract domain from URL */
@@ -2231,16 +2342,25 @@ function getDomain(url: string): string {
 }
 
 /** Get first N lines of text as preview */
-function getPreviewLines(text: string, maxLines: number, maxLineLen: number): string[] {
+function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis: string): string[] {
 	const lines = text.split("\n").filter((l) => l.trim());
-	return lines.slice(0, maxLines).map((l) => truncate(l.trim(), maxLineLen));
+	return lines.slice(0, maxLines).map((l) => truncate(l.trim(), maxLineLen, ellipsis));
+}
+
+/** Count non-empty lines */
+function countNonEmptyLines(text: string): number {
+	return text.split("\n").filter((l) => l.trim()).length;
 }
 
 /** Render web fetch call (URL preview) */
-export function renderWebFetchCall(args: { url: string; timeout?: number; raw?: boolean }, theme: Theme): Component {
+export function renderWebFetchCall(
+	args: { url: string; timeout?: number; raw?: boolean },
+	uiTheme: Theme = theme,
+): Component {
 	const domain = getDomain(args.url);
-	const path = truncate(args.url.replace(/^https?:\/\/[^/]+/, ""), 50);
-	const text = `${theme.fg("toolTitle", "Web Fetch")} ${theme.fg("accent", domain)}${theme.fg("dim", path)}`;
+	const path = truncate(args.url.replace(/^https?:\/\/[^/]+/, ""), 50, uiTheme.format.ellipsis);
+	const icon = uiTheme.styledSymbol("status.pending", "muted");
+	const text = `${icon} ${uiTheme.fg("toolTitle", "Web Fetch")} ${uiTheme.fg("accent", domain)}${uiTheme.fg("dim", path)}`;
 	return new Text(text, 0, 0);
 }
 
@@ -2248,26 +2368,23 @@ export function renderWebFetchCall(args: { url: string; timeout?: number; raw?:
 export function renderWebFetchResult(
 	result: { content: Array<{ type: string; text?: string }>; details?: WebFetchToolDetails },
 	options: RenderResultOptions,
-	theme: Theme,
+	uiTheme: Theme = theme,
 ): Component {
 	const { expanded } = options;
 	const details = result.details;
 
 	if (!details) {
-		return new Text(theme.fg("error", "No response data"), 0, 0);
+		return new Text(uiTheme.fg("error", "No response data"), 0, 0);
 	}
 
 	const domain = getDomain(details.finalUrl);
 	const hasRedirect = details.url !== details.finalUrl;
 	const hasNotes = details.notes.length > 0;
-
-	// Build header: ● Web Fetch (domain) · method
-	const icon = details.truncated ? theme.fg("warning", "●") : theme.fg("success", "●");
-	const expandHint = expanded ? "" : theme.fg("dim", " (Ctrl+O to expand)");
-	let text = `${icon} ${theme.fg("toolTitle", "Web Fetch")} ${theme.fg("accent", `(${domain})`)} · ${theme.fg(
-		"dim",
-		details.method,
-	)}${expandHint}`;
+	const statusIcon = details.truncated
+		? uiTheme.styledSymbol("status.warning", "warning")
+		: uiTheme.styledSymbol("status.success", "success");
+	const expandHint = expanded ? "" : uiTheme.fg("dim", " (Ctrl+O to expand)");
+	let text = `${statusIcon} ${uiTheme.fg("toolTitle", "Web Fetch")} ${uiTheme.fg("accent", `(${domain})`)}${uiTheme.sep.dot}${uiTheme.fg("dim", details.method)}${expandHint}`;
 
 	// Get content text
 	const contentText = result.content[0]?.text ?? "";
@@ -2275,68 +2392,90 @@ export function renderWebFetchResult(
 	const contentBody = contentText.includes("---\n\n")
 		? contentText.split("---\n\n").slice(1).join("---\n\n")
 		: contentText;
+	const lineCount = countNonEmptyLines(contentBody);
+	const charCount = contentBody.trim().length;
 
 	if (!expanded) {
-		// Collapsed view: show metadata + 3 preview lines
+		// Collapsed view: metadata + preview
+		const metaLines: string[] = [
+			`${uiTheme.fg("muted", "Content-Type:")} ${details.contentType || "unknown"}`,
+			`${uiTheme.fg("muted", "Method:")} ${details.method}`,
+		];
 		if (hasRedirect) {
-			text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("muted", "→")} ${theme.fg("mdLinkUrl", details.finalUrl)}`;
+			metaLines.push(`${uiTheme.fg("muted", "Final URL:")} ${uiTheme.fg("mdLinkUrl", details.finalUrl)}`);
 		}
 		if (details.truncated) {
-			text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("warning", "⚠ truncated")}`;
+			metaLines.push(uiTheme.fg("warning", `${uiTheme.status.warning} Output truncated`));
+		}
+		if (hasNotes) {
+			metaLines.push(`${uiTheme.fg("muted", "Notes:")} ${details.notes.join("; ")}`);
 		}
 
-		const previewLines = getPreviewLines(contentBody, 3, 100);
-		for (const line of previewLines) {
-			text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("dim", line)}`;
+		const previewLines = getPreviewLines(contentBody, 3, 100, uiTheme.format.ellipsis);
+		const detailLines: string[] = [...metaLines];
+
+		if (previewLines.length === 0) {
+			detailLines.push(uiTheme.fg("dim", "(no content)"));
+		} else {
+			for (const line of previewLines) {
+				detailLines.push(uiTheme.fg("dim", line));
+			}
 		}
-		const totalLines = contentBody.split("\n").filter((l) => l.trim()).length;
-		if (totalLines > 3) {
-			text += `\n ${theme.fg("dim", TREE_END)} ${theme.fg("muted", `… ${totalLines - 3} more lines`)}`;
+
+		const remaining = Math.max(0, lineCount - previewLines.length);
+		if (remaining > 0) {
+			detailLines.push(uiTheme.fg("muted", `${uiTheme.format.ellipsis} ${remaining} more lines`));
 		} else {
-			text += `\n ${theme.fg("dim", TREE_END)} ${theme.fg("muted", details.contentType)}`;
+			const lineLabel = `${lineCount} line${lineCount === 1 ? "" : "s"}`;
+			detailLines.push(uiTheme.fg("muted", `${lineLabel}${uiTheme.sep.dot}${charCount} chars`));
+		}
+
+		for (let i = 0; i < detailLines.length; i++) {
+			const isLast = i === detailLines.length - 1;
+			const branch = isLast ? uiTheme.tree.last : uiTheme.tree.vertical;
+			text += `\n ${uiTheme.fg("dim", branch)}  ${detailLines[i]}`;
 		}
 	} else {
-		// Expanded view: full metadata tree + content
-		const hasMeta = hasRedirect || hasNotes || details.truncated;
-
-		if (hasMeta) {
-			// Metadata section
-			text += `\n ${theme.fg("dim", TREE_MID)} ${theme.fg("accent", "Metadata")}`;
-			text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("dim", TREE_MID)} ${theme.fg("muted", "Content-Type:")} ${
-				details.contentType
-			}`;
-			if (hasRedirect) {
-				text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("dim", TREE_MID)} ${theme.fg(
-					"muted",
-					"Redirected from:",
-				)} ${theme.fg("mdLinkUrl", details.url)}`;
-				text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("dim", `${TREE_PIPE}  ${TREE_HOOK} `)}${theme.fg(
-					"mdLinkUrl",
-					details.finalUrl,
-				)}`;
-			}
-			if (details.truncated) {
-				text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("dim", TREE_MID)} ${theme.fg(
-					"warning",
-					"⚠ Output was truncated",
-				)}`;
-			}
-			if (hasNotes) {
-				const notesBranch = TREE_END;
-				text += `\n ${theme.fg("dim", TREE_PIPE)}  ${theme.fg("dim", notesBranch)} ${theme.fg(
-					"muted",
-					"Notes:",
-				)} ${details.notes.join("; ")}`;
+		// Expanded view: structured metadata + bounded content preview
+		const metaLines: string[] = [
+			`${uiTheme.fg("muted", "Content-Type:")} ${details.contentType || "unknown"}`,
+			`${uiTheme.fg("muted", "Method:")} ${details.method}`,
+		];
+		if (hasRedirect) {
+			metaLines.push(`${uiTheme.fg("muted", "Final URL:")} ${uiTheme.fg("mdLinkUrl", details.finalUrl)}`);
+		}
+		const lineLabel = `${lineCount} line${lineCount === 1 ? "" : "s"}`;
+		metaLines.push(`${uiTheme.fg("muted", "Lines:")} ${lineLabel}`);
+		metaLines.push(`${uiTheme.fg("muted", "Chars:")} ${charCount}`);
+		if (details.truncated) {
+			metaLines.push(uiTheme.fg("warning", `${uiTheme.status.warning} Output truncated`));
+		}
+		if (hasNotes) {
+			metaLines.push(`${uiTheme.fg("muted", "Notes:")} ${details.notes.join("; ")}`);
+		}
+
+		text += `\n ${uiTheme.fg("dim", uiTheme.tree.branch)} ${uiTheme.fg("accent", "Metadata")}`;
+		for (let i = 0; i < metaLines.length; i++) {
+			const isLast = i === metaLines.length - 1;
+			const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.vertical)}  ${uiTheme.fg("dim", branch)} ${metaLines[i]}`;
+		}
+
+		text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("accent", "Content Preview")}`;
+		const previewLines = getPreviewLines(contentBody, 12, 120, uiTheme.format.ellipsis);
+		const remaining = Math.max(0, lineCount - previewLines.length);
+		const contentPrefix = uiTheme.fg("dim", " ");
+
+		if (previewLines.length === 0) {
+			text += `\n ${contentPrefix}   ${uiTheme.fg("dim", "(no content)")}`;
+		} else {
+			for (const line of previewLines) {
+				text += `\n ${contentPrefix}   ${uiTheme.fg("dim", line)}`;
 			}
 		}
 
-		// Content section
-		text += `\n ${theme.fg("dim", TREE_END)} ${theme.fg("accent", "Content")}`;
-		const contentLines = contentBody.split("\n");
-		for (let i = 0; i < contentLines.length; i++) {
-			const line = contentLines[i];
-			const isLast = i === contentLines.length - 1;
-			text += `\n    ${isLast ? " " : theme.fg("dim", " ")} ${line}`;
+		if (remaining > 0) {
+			text += `\n ${contentPrefix}   ${uiTheme.fg("muted", `${uiTheme.format.ellipsis} ${remaining} more lines`)}`;
 		}
 	}
 
@@ -2349,7 +2488,7 @@ type WebFetchParams = { url: string; timeout?: number; raw?: boolean };
 export const webFetchCustomTool: CustomTool<typeof webFetchSchema, WebFetchToolDetails> = {
 	name: "web_fetch",
 	label: "Web Fetch",
-	description: webFetchTool.description,
+	description: webFetchDescription,
 	parameters: webFetchSchema,
 
 	async execute(
@@ -2362,11 +2501,11 @@ export const webFetchCustomTool: CustomTool<typeof webFetchSchema, WebFetchToolD
 		return webFetchTool.execute(toolCallId, params);
 	},
 
-	renderCall(args: WebFetchParams, theme: Theme) {
-		return renderWebFetchCall(args, theme);
+	renderCall(args: WebFetchParams, uiTheme: Theme) {
+		return renderWebFetchCall(args, uiTheme);
 	},
 
-	renderResult(result, options: RenderResultOptions, theme: Theme) {
-		return renderWebFetchResult(result, options, theme);
+	renderResult(result, options: RenderResultOptions, uiTheme: Theme) {
+		return renderWebFetchResult(result, options, uiTheme);
 	},
 };

package/src/core/tools/web-search/index.ts

@@ -15,6 +15,7 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
 import type { Theme } from "../../../modes/interactive/theme/theme";
+import webSearchDescription from "../../../prompts/tools/web-search.md" with { type: "text" };
 import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../custom-tools/types";
 import { callExaTool, findApiKey as findExaKey, formatSearchResults, isSearchResponse } from "../exa/mcp-client";
 import { renderExaCall, renderExaResult } from "../exa/render";
@@ -107,31 +108,85 @@ async function detectProvider(): Promise<WebSearchProvider> {
 	return "anthropic";
 }
 
+/** Truncate text for tool output */
+function truncateText(text: string, maxLen: number): string {
+	if (text.length <= maxLen) return text;
+	return `${text.slice(0, Math.max(0, maxLen - 3))}...`;
+}
+
+function formatCount(label: string, count: number): string {
+	return `${count} ${label}${count === 1 ? "" : "s"}`;
+}
+
 /** Format response for LLM consumption */
 function formatForLLM(response: WebSearchResponse): string {
 	const parts: string[] = [];
 
-	// Add synthesized answer
-	if (response.answer) {
-		parts.push(response.answer);
-	}
+	parts.push("## Answer");
+	parts.push(response.answer ? response.answer : "No answer text returned.");
 
-	// Add sources
 	if (response.sources.length > 0) {
 		parts.push("\n## Sources");
+		parts.push(formatCount("source", response.sources.length));
 		for (const [i, src] of response.sources.entries()) {
 			const age = formatAge(src.ageSeconds) || src.publishedDate;
 			const agePart = age ? ` (${age})` : "";
 			parts.push(`[${i + 1}] ${src.title}${agePart}\n    ${src.url}`);
+			if (src.snippet) {
+				parts.push(`    ${truncateText(src.snippet, 240)}`);
+			}
+		}
+	} else {
+		parts.push("\n## Sources");
+		parts.push("0 sources");
+	}
+
+	if (response.citations && response.citations.length > 0) {
+		parts.push("\n## Citations");
+		parts.push(formatCount("citation", response.citations.length));
+		for (const [i, citation] of response.citations.entries()) {
+			const title = citation.title || citation.url;
+			parts.push(`[${i + 1}] ${title}\n    ${citation.url}`);
+			if (citation.citedText) {
+				parts.push(`    ${truncateText(citation.citedText, 240)}`);
+			}
 		}
 	}
 
-	// Add related questions (Perplexity)
 	if (response.relatedQuestions && response.relatedQuestions.length > 0) {
-		parts.push("\n## Related Questions");
+		parts.push("\n## Related");
+		parts.push(formatCount("question", response.relatedQuestions.length));
 		for (const q of response.relatedQuestions) {
 			parts.push(`- ${q}`);
 		}
+	} else {
+		parts.push("\n## Related");
+		parts.push("0 questions");
+	}
+
+	parts.push("\n## Meta");
+	parts.push(`Provider: ${response.provider}`);
+	if (response.model) {
+		parts.push(`Model: ${response.model}`);
+	}
+	if (response.usage) {
+		const usageParts: string[] = [];
+		if (response.usage.inputTokens !== undefined) usageParts.push(`in ${response.usage.inputTokens}`);
+		if (response.usage.outputTokens !== undefined) usageParts.push(`out ${response.usage.outputTokens}`);
+		if (response.usage.totalTokens !== undefined) usageParts.push(`total ${response.usage.totalTokens}`);
+		if (response.usage.searchRequests !== undefined) usageParts.push(`search ${response.usage.searchRequests}`);
+		if (usageParts.length > 0) {
+			parts.push(`Usage: ${usageParts.join(" | ")}`);
+		}
+	}
+	if (response.requestId) {
+		parts.push(`Request: ${truncateText(response.requestId, 64)}`);
+	}
+	if (response.searchQueries && response.searchQueries.length > 0) {
+		parts.push(`Search queries: ${response.searchQueries.length}`);
+		for (const query of response.searchQueries.slice(0, 3)) {
+			parts.push(`- ${truncateText(query, 120)}`);
+		}
 	}
 
 	return parts.join("\n");
@@ -186,22 +241,11 @@ async function executeWebSearch(
 	}
 }
 
-const WEB_SEARCH_DESCRIPTION = `Allows OMP to search the web and use the results to inform responses
-- Provides up-to-date information for current events and recent data
-- Returns search result information formatted as search result blocks, including links as markdown hyperlinks
-- Use this tool for accessing information beyond Claude's knowledge cutoff
-- Searches are performed automatically within a single API call
-
-Common: system_prompt (guides response style)
-Anthropic-specific: max_tokens
-Perplexity-specific: model (sonar/sonar-pro), search_recency_filter, search_domain_filter, search_context_size, return_related_questions
-Exa-specific: num_results`;
-
 /** Web search tool as AgentTool (for allTools export) */
 export const webSearchTool: AgentTool<typeof webSearchSchema> = {
 	name: "web_search",
 	label: "Web Search",
-	description: WEB_SEARCH_DESCRIPTION,
+	description: webSearchDescription,
 	parameters: webSearchSchema,
 	execute: async (toolCallId, params) => {
 		return executeWebSearch(toolCallId, params as WebSearchParams);
@@ -212,7 +256,7 @@ export const webSearchTool: AgentTool<typeof webSearchSchema> = {
 export const webSearchCustomTool: CustomTool<typeof webSearchSchema, WebSearchRenderDetails> = {
 	name: "web_search",
 	label: "Web Search",
-	description: WEB_SEARCH_DESCRIPTION,
+	description: webSearchDescription,
 	parameters: webSearchSchema,
 
 	async execute(