@wahack/pi-coding-agent 15.11.0

package/src/web/scrapers/wikipedia.ts

@@ -0,0 +1,84 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { buildResult, loadPage } from "./types";
+
+/**
+ * Handle Wikipedia URLs via Wikipedia API
+ */
+export const handleWikipedia: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		// Match *.wikipedia.org
+		const wikiMatch = parsed.hostname.match(/^(\w+)\.wikipedia\.org$/);
+		if (!wikiMatch) return null;
+
+		const lang = wikiMatch[1];
+		const titleMatch = parsed.pathname.match(/\/wiki\/(.+)/);
+		if (!titleMatch) return null;
+
+		const title = decodeURIComponent(titleMatch[1]);
+		const fetchedAt = new Date().toISOString();
+
+		// Use Wikipedia API to get plain text extract
+		const apiUrl = `https://${lang}.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(title)}`;
+		const summaryResult = await loadPage(apiUrl, { timeout, signal });
+
+		let md = "";
+
+		if (summaryResult.ok) {
+			const summary = JSON.parse(summaryResult.content) as {
+				title: string;
+				description?: string;
+				extract: string;
+			};
+			md = `# ${summary.title}\n\n`;
+			if (summary.description) md += `*${summary.description}*\n\n`;
+			md += `${summary.extract}\n\n---\n\n`;
+		}
+
+		// Get full article content via mobile-html or parse API
+		const contentUrl = `https://${lang}.wikipedia.org/api/rest_v1/page/mobile-html/${encodeURIComponent(title)}`;
+		const contentResult = await loadPage(contentUrl, { timeout, signal });
+
+		if (contentResult.ok) {
+			const { parseHTML } = await import("linkedom");
+			const doc = parseHTML(contentResult.content).document;
+
+			// Extract main content sections
+			const sections = doc.querySelectorAll("section");
+			for (const section of sections) {
+				const heading = section.querySelector("h2, h3, h4");
+				const headingText = heading?.textContent?.trim();
+				// Skip certain sections
+				if (
+					headingText &&
+					["References", "External links", "See also", "Notes", "Further reading"].includes(headingText)
+				) {
+					continue;
+				}
+
+				if (headingText) {
+					const level = heading?.tagName === "H2" ? "##" : "###";
+					md += `${level} ${headingText}\n\n`;
+				}
+
+				const paragraphs = section.querySelectorAll("p");
+				for (const p of paragraphs) {
+					const text = p.textContent?.trim();
+					if (text && text.length > 20) {
+						md += `${text}\n\n`;
+					}
+				}
+			}
+		}
+
+		if (!md) return null;
+
+		return buildResult(md, { url, method: "wikipedia", fetchedAt, notes: ["Fetched via Wikipedia API"] });
+	} catch {}
+
+	return null;
+};

package/src/web/scrapers/youtube.ts

@@ -0,0 +1,325 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { ptree, Snowflake } from "@oh-my-pi/pi-utils";
+import { settings } from "../../config/settings";
+import type { AgentStorage } from "../../session/agent-storage";
+import { throwIfAborted } from "../../tools/tool-errors";
+import { ensureTool } from "../../utils/tools-manager";
+import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../parallel";
+import type { RenderResult, SpecialHandler } from "./types";
+import { buildResult, formatMediaDuration, formatNumber } from "./types";
+
+interface YouTubeUrl {
+	videoId: string;
+	playlistId?: string;
+}
+
+/**
+ * Parse YouTube URL into components
+ */
+function parseYouTubeUrl(url: string): YouTubeUrl | null {
+	try {
+		const parsed = new URL(url);
+		const hostname = parsed.hostname.replace(/^www\./, "");
+
+		// youtube.com/watch?v=VIDEO_ID
+		if ((hostname === "youtube.com" || hostname === "m.youtube.com") && parsed.pathname === "/watch") {
+			const videoId = parsed.searchParams.get("v");
+			const playlistId = parsed.searchParams.get("list") || undefined;
+			if (videoId) return { videoId, playlistId };
+		}
+
+		// youtube.com/v/VIDEO_ID or youtube.com/embed/VIDEO_ID
+		if (hostname === "youtube.com" || hostname === "m.youtube.com") {
+			const match = parsed.pathname.match(/^\/(v|embed)\/([a-zA-Z0-9_-]{11})/);
+			if (match) return { videoId: match[2] };
+		}
+
+		// youtu.be/VIDEO_ID
+		if (hostname === "youtu.be") {
+			const videoId = parsed.pathname.slice(1).split("/")[0];
+			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+				return { videoId };
+			}
+		}
+
+		// youtube.com/shorts/VIDEO_ID
+		if (hostname === "youtube.com" && parsed.pathname.startsWith("/shorts/")) {
+			const videoId = parsed.pathname.replace("/shorts/", "").split("/")[0];
+			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+				return { videoId };
+			}
+		}
+	} catch {}
+
+	return null;
+}
+
+/**
+ * Clean VTT subtitle content to plain text
+ */
+function cleanVttToText(vtt: string): string {
+	const lines = vtt.split("\n");
+	const textLines: string[] = [];
+	let lastLine = "";
+
+	for (const line of lines) {
+		// Skip WEBVTT header, timestamps, and metadata
+		if (
+			line.startsWith("WEBVTT") ||
+			line.startsWith("Kind:") ||
+			line.startsWith("Language:") ||
+			line.match(/^\d{2}:\d{2}/) || // Timestamp lines
+			line.match(/^[a-f0-9-]{36}$/) || // UUID cue identifiers
+			line.match(/^\d+$/) || // Numeric cue identifiers
+			line.includes("-->") ||
+			line.trim() === ""
+		) {
+			continue;
+		}
+
+		// Remove inline timestamp tags like <00:00:01.520>
+		let cleaned = line.replace(/<\d{2}:\d{2}:\d{2}\.\d{3}>/g, "");
+		// Remove other VTT tags like <c> </c>
+		cleaned = cleaned.replace(/<\/?[^>]+>/g, "");
+		cleaned = cleaned.trim();
+
+		// Skip duplicates (auto-generated captions often repeat)
+		if (cleaned && cleaned !== lastLine) {
+			textLines.push(cleaned);
+			lastLine = cleaned;
+		}
+	}
+
+	return textLines.join(" ").replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Handle YouTube URLs - fetch metadata and transcript
+ */
+export const handleYouTube: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	userSignal?: AbortSignal,
+	storage?: AgentStorage | null,
+): Promise<RenderResult | null> => {
+	throwIfAborted(userSignal);
+	const yt = parseYouTubeUrl(url);
+	if (!yt) return null;
+
+	const signal = ptree.combineSignals(userSignal, timeout * 1000);
+	const fetchedAt = new Date().toISOString();
+	const notes: string[] = [];
+	const videoUrl = `https://www.youtube.com/watch?v=${yt.videoId}`;
+
+	// Prefer Parallel extract when it sits in the reader chain and creds exist
+	const fetchPreference = settings.get("providers.fetch");
+	if ((fetchPreference === "auto" || fetchPreference === "parallel") && findParallelApiKey(storage)) {
+		try {
+			const parallelResult = await extractWithParallel(
+				[videoUrl],
+				{
+					objective: "Extract the main content of this YouTube video page",
+					excerpts: true,
+					fullContent: false,
+					signal,
+				},
+				storage,
+			);
+			const firstDocument = parallelResult.results[0];
+			if (firstDocument) {
+				const content = getParallelExtractContent(firstDocument);
+				if (content.trim().length > 100) {
+					return buildResult(content, {
+						url,
+						finalUrl: videoUrl,
+						method: "parallel",
+						fetchedAt,
+						notes: ["Used Parallel extract for YouTube"],
+					});
+				}
+			}
+		} catch {
+			throwIfAborted(signal);
+		}
+	}
+
+	// Ensure yt-dlp is available (auto-download if missing)
+	const ytdlp = await ensureTool("yt-dlp", { signal, silent: true });
+	if (!ytdlp) {
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/plain",
+			method: "youtube-no-ytdlp",
+			content: "YouTube video detected but yt-dlp could not be installed.",
+			fetchedAt: new Date().toISOString(),
+			truncated: false,
+			notes: ["yt-dlp installation failed"],
+		};
+	}
+
+	const execOptions = {
+		mode: "group" as const,
+		signal,
+		allowNonZero: true,
+		allowAbort: true,
+		stderr: "full" as const,
+	};
+
+	// Fetch video metadata
+	const metaResult = await ptree.exec(
+		[ytdlp, "--dump-json", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
+		execOptions,
+	);
+
+	let title = "YouTube Video";
+	let channel = "";
+	let description = "";
+	let duration = 0;
+	let uploadDate = "";
+	let viewCount = 0;
+
+	if (metaResult.ok && metaResult.stdout.trim()) {
+		try {
+			const meta = JSON.parse(metaResult.stdout) as {
+				title?: string;
+				channel?: string;
+				uploader?: string;
+				description?: string;
+				duration?: number;
+				upload_date?: string;
+				view_count?: number;
+			};
+			title = meta.title || title;
+			channel = meta.channel || meta.uploader || "";
+			description = meta.description || "";
+			duration = meta.duration || 0;
+			uploadDate = meta.upload_date || "";
+			viewCount = meta.view_count || 0;
+		} catch {}
+	}
+
+	// Format upload date
+	let formattedDate = "";
+	if (uploadDate && uploadDate.length === 8) {
+		formattedDate = `${uploadDate.slice(0, 4)}-${uploadDate.slice(4, 6)}-${uploadDate.slice(6, 8)}`;
+	}
+
+	// Try to fetch subtitles
+	let transcript = "";
+	let transcriptSource = "";
+
+	// First, list available subtitles
+	const listResult = await ptree.exec(
+		[ytdlp, "--list-subs", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
+		execOptions,
+	);
+
+	const hasManualSubs = listResult.stdout.includes("[info] Available subtitles");
+	const hasAutoSubs = listResult.stdout.includes("[info] Available automatic captions");
+
+	// Create temp directory for subtitle download
+	const tmpDir = os.tmpdir();
+	const tmpBase = path.join(tmpDir, `yt-${yt.videoId}-${Snowflake.next()}`);
+
+	try {
+		// Try manual subtitles first (English preferred)
+		if (hasManualSubs) {
+			const subResult = await ptree.exec(
+				[
+					ytdlp,
+					"--write-sub",
+					"--sub-lang",
+					"en,en-US,en-GB",
+					"--sub-format",
+					"vtt",
+					"--skip-download",
+					"--no-warnings",
+					"--no-playlist",
+					"-o",
+					tmpBase,
+					videoUrl,
+				],
+				execOptions,
+			);
+
+			if (subResult.ok) {
+				// Find the downloaded subtitle file using glob
+				const subFiles = await Array.fromAsync(new Bun.Glob(`${tmpBase}*.vtt`).scan({ absolute: true }));
+				if (subFiles.length > 0) {
+					const vttContent = await Bun.file(subFiles[0]).text();
+					transcript = cleanVttToText(vttContent);
+					transcriptSource = "manual";
+					notes.push("Using manual subtitles");
+				}
+			}
+		}
+
+		// Fall back to auto-generated captions
+		if (!transcript && hasAutoSubs) {
+			const autoResult = await ptree.exec(
+				[
+					ytdlp,
+					"--write-auto-sub",
+					"--sub-lang",
+					"en,en-US,en-GB",
+					"--sub-format",
+					"vtt",
+					"--skip-download",
+					"--no-warnings",
+					"--no-playlist",
+					"-o",
+					tmpBase,
+					videoUrl,
+				],
+				execOptions,
+			);
+
+			if (autoResult.ok) {
+				const subFiles = await Array.fromAsync(new Bun.Glob(`${tmpBase}*.vtt`).scan({ absolute: true }));
+				if (subFiles.length > 0) {
+					const vttContent = await Bun.file(subFiles[0]).text();
+					transcript = cleanVttToText(vttContent);
+					transcriptSource = "auto-generated";
+					notes.push("Using auto-generated captions");
+				}
+			}
+		}
+	} finally {
+		// Cleanup temp files (fire-and-forget with error suppression)
+		Array.fromAsync(new Bun.Glob(`${tmpBase}*`).scan({ absolute: true }))
+			.then(tmpFiles => Promise.all(tmpFiles.map(f => fs.unlink(f).catch(() => {}))))
+			.catch(() => {});
+	}
+	// Only a user-initiated abort is fatal; the per-fetch time budget expiring
+	// just means partial metadata/transcript, which we surface as a note.
+	throwIfAborted(userSignal);
+	if (signal?.aborted) {
+		notes.push("Fetch time budget exhausted; metadata/transcript may be incomplete");
+	}
+
+	// Build markdown output
+	let md = `# ${title}\n\n`;
+	if (channel) md += `**Channel:** ${channel}\n`;
+	if (formattedDate) md += `**Uploaded:** ${formattedDate}\n`;
+	if (duration > 0) md += `**Duration:** ${formatMediaDuration(duration)}\n`;
+	if (viewCount > 0) md += `**Views:** ${formatNumber(viewCount)}\n`;
+	md += `**Video ID:** ${yt.videoId}\n\n`;
+
+	if (description) {
+		// Truncate long descriptions
+		const descPreview = description.length > 1000 ? `${description.slice(0, 1000)}…` : description;
+		md += `---\n\n## Description\n\n${descPreview}\n\n`;
+	}
+
+	if (transcript) {
+		md += `---\n\n## Transcript (${transcriptSource})\n\n${transcript}\n`;
+	} else {
+		notes.push("No subtitles/captions available");
+		md += `---\n\n*No transcript available for this video.*\n`;
+	}
+
+	return buildResult(md, { url, finalUrl: videoUrl, method: "youtube", fetchedAt, notes });
+};

package/src/web/search/index.ts

@@ -0,0 +1,292 @@
+/**
+ * Unified Web Search Tool
+ *
+ * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Tavily, Kagi, Z.AI, SearXNG, and Synthetic
+ * providers with provider-specific parameters exposed conditionally.
+ */
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AuthStorage } from "@oh-my-pi/pi-ai";
+import { prompt } from "@oh-my-pi/pi-utils";
+import * as z from "zod/v4";
+import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../extensibility/custom-tools/types";
+import type { Theme } from "../../modes/theme/theme";
+import webSearchSystemPrompt from "../../prompts/system/web-search.md" with { type: "text" };
+import webSearchDescription from "../../prompts/tools/web-search.md" with { type: "text" };
+import { discoverAuthStorage } from "../../sdk";
+import type { ToolSession } from "../../tools";
+import { formatAge } from "../../tools/render-utils";
+import { throwIfAborted } from "../../tools/tool-errors";
+import { getSearchProvider, getSearchProviderLabel, resolveProviderChain, type SearchProvider } from "./provider";
+import { renderSearchCall, renderSearchResult, type SearchRenderDetails } from "./render";
+import type { SearchProviderId, SearchResponse } from "./types";
+import { SearchProviderError } from "./types";
+
+/** Web search tool parameters schema */
+export const webSearchSchema = z.object({
+	query: z.string().describe("search query"),
+	recency: z.enum(["day", "week", "month", "year"]).describe("recency filter").optional(),
+	limit: z.number().describe("max results").optional(),
+	max_tokens: z.number().describe("max output tokens").optional(),
+	temperature: z.number().describe("sampling temperature").optional(),
+	num_search_results: z.number().describe("number of search results").optional(),
+});
+
+export type SearchToolParams = z.infer<typeof webSearchSchema>;
+
+export interface SearchQueryParams extends SearchToolParams {
+	provider?: SearchProviderId | "auto";
+}
+
+function formatProviderError(error: unknown, provider: SearchProvider): string {
+	if (error instanceof SearchProviderError) {
+		if (error.provider === "anthropic" && error.status === 404) {
+			return "Anthropic web search returned 404 (model or endpoint not found).";
+		}
+		if (error.status === 401 || error.status === 403) {
+			if (error.provider === "zai") {
+				return error.message;
+			}
+			return `${getSearchProviderLabel(error.provider)} authorization failed (${error.status}). Check API key or base URL.`;
+		}
+		return error.message;
+	}
+	if (error instanceof Error) return error.message;
+	return `Unknown error from ${provider.label}`;
+}
+
+/** 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 - 1))}…`;
+}
+
+function formatCount(label: string, count: number): string {
+	return `${count} ${label}${count === 1 ? "" : "s"}`;
+}
+
+/** Format response for LLM consumption */
+function formatForLLM(response: SearchResponse): string {
+	const parts: string[] = [];
+
+	if (response.answer) {
+		parts.push(response.answer);
+		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)}`);
+		}
+	}
+
+	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)}`);
+			}
+		}
+	}
+
+	if (response.relatedQuestions && response.relatedQuestions.length > 0) {
+		parts.push("\n## Related");
+		parts.push(formatCount("question", response.relatedQuestions.length));
+		for (const q of response.relatedQuestions) {
+			parts.push(`- ${q}`);
+		}
+	}
+
+	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");
+}
+
+interface ExecuteSearchOptions {
+	authStorage: AuthStorage;
+	sessionId?: string;
+	signal?: AbortSignal;
+}
+
+/** Execute web search */
+async function executeSearch(
+	_toolCallId: string,
+	params: SearchQueryParams,
+	options: ExecuteSearchOptions,
+): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
+	const { authStorage, sessionId, signal } = options;
+	const providers =
+		params.provider && params.provider !== "auto"
+			? await getSearchProvider(params.provider).then(async provider =>
+					(await provider.isExplicitlyAvailable(authStorage))
+						? [provider]
+						: resolveProviderChain(authStorage, "auto"),
+				)
+			: await resolveProviderChain(authStorage);
+	if (providers.length === 0) {
+		const message = "No web search provider configured.";
+		return {
+			content: [{ type: "text" as const, text: `Error: ${message}` }],
+			details: { response: { provider: "none", sources: [] }, error: message },
+		};
+	}
+
+	const failures: Array<{ provider: SearchProvider; error: unknown }> = [];
+	let lastProvider = providers[0];
+	for (const provider of providers) {
+		lastProvider = provider;
+		try {
+			const response = await provider.search({
+				query: params.query,
+				limit: params.limit,
+				recency: params.recency,
+				systemPrompt: webSearchSystemPrompt,
+				maxOutputTokens: params.max_tokens,
+				numSearchResults: params.num_search_results,
+				temperature: params.temperature,
+				signal,
+				authStorage,
+				sessionId,
+			});
+
+			const text = formatForLLM(response);
+
+			return {
+				content: [{ type: "text" as const, text }],
+				details: { response },
+			};
+		} catch (error) {
+			// Surface user-initiated cancellation immediately so the session sees
+			// a clean abort instead of a generic "all providers failed" message.
+			// Without this, an AbortError from `fetch()` is treated as a provider
+			// failure and the loop falls through to the next provider (or to the
+			// summary error), masking the cancellation.
+			throwIfAborted(signal);
+			failures.push({ provider, error });
+		}
+	}
+
+	const lastFailure = failures[failures.length - 1];
+	const baseMessage = lastFailure
+		? formatProviderError(lastFailure.error, lastFailure.provider)
+		: `Unknown error from ${lastProvider.label}`;
+	const message =
+		providers.length > 1
+			? `All web search providers failed: ${failures
+					.map(f =>
+						f.error instanceof SearchProviderError
+							? f.error.message
+							: `${f.provider.id}: ${formatProviderError(f.error, f.provider)}`,
+					)
+					.join("; ")}`
+			: baseMessage;
+
+	return {
+		content: [{ type: "text" as const, text: `Error: ${message}` }],
+		details: { response: { provider: lastProvider.id, sources: [] }, error: message },
+	};
+}
+
+/**
+ * Execute a web search query for CLI/testing workflows.
+ *
+ * `authStorage` may be omitted; in that case we discover one via the standard
+ * factory (`discoverAuthStorage`), which honours `OMP_AUTH_BROKER_URL` and
+ * otherwise opens the local SQLite credential store.
+ */
+export async function runSearchQuery(
+	params: SearchQueryParams,
+	options: { authStorage?: AuthStorage; sessionId?: string; signal?: AbortSignal } = {},
+): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
+	const authStorage = options.authStorage ?? (await discoverAuthStorage());
+	return executeSearch("cli-web-search", params, {
+		authStorage,
+		sessionId: options.sessionId,
+		signal: options.signal,
+	});
+}
+
+/**
+ * Web search tool implementation.
+ *
+ * Supports the configured web-search provider chain with automatic fallback.
+ */
+export class WebSearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {
+	readonly name = "web_search";
+	readonly approval = "read" as const;
+	readonly label = "Web Search";
+	readonly description: string;
+	readonly parameters = webSearchSchema;
+	readonly strict = true;
+	readonly loadMode = "discoverable";
+	readonly summary = "Search the web for up-to-date information";
+
+	#session: ToolSession;
+
+	constructor(session: ToolSession) {
+		this.#session = session;
+		this.description = prompt.render(webSearchDescription);
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: SearchToolParams,
+		signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<SearchRenderDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<SearchRenderDetails>> {
+		const authStorage = this.#session.authStorage ?? (await discoverAuthStorage());
+		const sessionId = this.#session.getSessionId?.() ?? undefined;
+		return executeSearch(_toolCallId, params, { authStorage, sessionId, signal });
+	}
+}
+
+/** Web search tool as CustomTool (for TUI rendering support) */
+export const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRenderDetails> = {
+	name: "web_search",
+	label: "Web Search",
+	description: prompt.render(webSearchDescription),
+	parameters: webSearchSchema,
+
+	approval: "read",
+	async execute(
+		toolCallId: string,
+		params: SearchToolParams,
+		_onUpdate,
+		ctx: CustomToolContext,
+		signal?: AbortSignal,
+	) {
+		const authStorage = ctx.modelRegistry?.authStorage ?? (await discoverAuthStorage());
+		const sessionId = ctx.sessionManager.getSessionId();
+		return executeSearch(toolCallId, params, { authStorage, sessionId, signal });
+	},
+
+	renderCall(args: SearchToolParams, options: RenderResultOptions, theme: Theme) {
+		return renderSearchCall(args, options, theme);
+	},
+
+	renderResult(result, options: RenderResultOptions, theme: Theme, args) {
+		return renderSearchResult(result, options, theme, args);
+	},
+};
+
+export function getSearchTools(): CustomTool<any, any>[] {
+	return [webSearchCustomTool];
+}
+
+export { getSearchProvider, setPreferredSearchProvider } from "./provider";
+export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";
+export { isSearchProviderPreference } from "./types";