@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.2

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.8.31-alpha.5",
+  "version": "0.9.0-alpha.2",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [
@@ -19,6 +19,7 @@
   },
   "files": [
     "*.ts",
+    "curator-page-assets/**/*.ts",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
@@ -30,7 +31,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.79.7"
+    "@earendil-works/pi-tui": "^0.79.9"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/web-access/web-search-activity.ts

@@ -0,0 +1,102 @@
+import type { ExtensionContext } from "@bastani/atomic";
+import { Text, truncateToWidth } from "@mariozechner/pi-tui";
+import { activityMonitor, type ActivityEntry } from "./activity.js";
+
+export interface ActivityWidgetState {
+	visible: boolean;
+	unsubscribe: (() => void) | null;
+}
+
+export function createActivityWidgetState(): ActivityWidgetState {
+	return { visible: false, unsubscribe: null };
+}
+
+function updateWidget(ctx: ExtensionContext): void {
+	const theme = ctx.ui.theme;
+	const entries = activityMonitor.getEntries();
+	const lines: string[] = [];
+
+	lines.push(theme.fg("accent", "─── Web Search Activity " + "─".repeat(36)));
+
+	if (entries.length === 0) {
+		lines.push(theme.fg("muted", "  No activity yet"));
+	} else {
+		for (const e of entries) {
+			lines.push("  " + formatEntryLine(e, theme));
+		}
+	}
+
+	lines.push(theme.fg("accent", "─".repeat(60)));
+
+	const rateInfo = activityMonitor.getRateLimitInfo();
+	const resetMs = rateInfo.oldestTimestamp ? Math.max(0, rateInfo.oldestTimestamp + rateInfo.windowMs - Date.now()) : 0;
+	const resetSec = Math.ceil(resetMs / 1000);
+	lines.push(
+		theme.fg("muted", `Rate: ${rateInfo.used}/${rateInfo.max}`) +
+			(resetMs > 0 ? theme.fg("dim", ` (resets in ${resetSec}s)`) : ""),
+	);
+
+	ctx.ui.setWidget("web-activity", new Text(lines.join("\n"), 0, 0));
+}
+
+function formatEntryLine(
+	entry: ActivityEntry,
+	theme: { fg: (color: string, text: string) => string },
+): string {
+	const typeStr = entry.type === "api" ? "API" : "GET";
+	const target =
+		entry.type === "api"
+			? `"${truncateToWidth(entry.query || "", 28, "")}"`
+			: truncateToWidth(entry.url?.replace(/^https?:\/\//, "") || "", 30, "");
+
+	const duration = entry.endTime
+		? `${((entry.endTime - entry.startTime) / 1000).toFixed(1)}s`
+		: `${((Date.now() - entry.startTime) / 1000).toFixed(1)}s`;
+
+	let statusStr: string;
+	let indicator: string;
+	if (entry.error) {
+		statusStr = "err";
+		indicator = theme.fg("error", "✗");
+	} else if (entry.status === null) {
+		statusStr = "...";
+		indicator = theme.fg("warning", "⋯");
+	} else if (entry.status === 0) {
+		statusStr = "abort";
+		indicator = theme.fg("muted", "○");
+	} else {
+		statusStr = String(entry.status);
+		indicator = entry.status >= 200 && entry.status < 300 ? theme.fg("success", "✓") : theme.fg("error", "✗");
+	}
+
+	return `${typeStr.padEnd(4)} ${target.padEnd(32)} ${statusStr.padStart(5)} ${duration.padStart(5)} ${indicator}`;
+}
+
+export function toggleActivityWidget(state: ActivityWidgetState, ctx: ExtensionContext): void {
+	state.visible = !state.visible;
+	if (state.visible) {
+		state.unsubscribe = activityMonitor.onUpdate(() => updateWidget(ctx));
+		updateWidget(ctx);
+	} else {
+		state.unsubscribe?.();
+		state.unsubscribe = null;
+		ctx.ui.setWidget("web-activity", null);
+	}
+}
+
+export function refreshActivityForSession(state: ActivityWidgetState, ctx: ExtensionContext): void {
+	state.unsubscribe?.();
+	state.unsubscribe = null;
+	activityMonitor.clear();
+	if (state.visible) {
+		state.unsubscribe = activityMonitor.onUpdate(() => updateWidget(ctx));
+		updateWidget(ctx);
+	}
+}
+
+export function shutdownActivityWidget(state: ActivityWidgetState): void {
+	state.unsubscribe?.();
+	state.unsubscribe = null;
+	activityMonitor.clear();
+	state.visible = false;
+}

package/dist/builtin/web-access/web-search-browser.ts

@@ -0,0 +1,116 @@
+import type { ExtensionAPI } from "@bastani/atomic";
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { platform } from "node:os";
+import { join } from "node:path";
+
+export interface GlimpseWindow {
+	on(event: "closed", handler: () => void): void;
+	on(event: "message", handler: (data: unknown) => void): void;
+	on(event: "ready", handler: (info: { screen?: { visibleHeight?: number } }) => void): void;
+	close(): void;
+	_write(obj: Record<string, unknown>): void;
+}
+
+type GlimpseOpen = (html: string, opts: Record<string, unknown>) => GlimpseWindow;
+
+let glimpseOpen: GlimpseOpen | null | undefined;
+
+async function openInBrowser(pi: ExtensionAPI, url: string): Promise<void> {
+	const plat = platform();
+	const result = plat === "darwin"
+		? await pi.exec("open", [url])
+		: plat === "win32"
+			? await pi.exec("cmd", ["/c", "start", "", url])
+			: await pi.exec("xdg-open", [url]);
+	if (result.code !== 0) {
+		throw new Error(result.stderr || `Failed to open browser (exit code ${result.code})`);
+	}
+}
+
+function findGlimpseMjs(): string | null {
+	try {
+		const req = createRequire(import.meta.url);
+		return req.resolve("glimpseui");
+	} catch {
+		// Optional dependency.
+	}
+	try {
+		const globalRoot = execFileSync("npm", ["root", "-g"], { encoding: "utf-8" }).trim();
+		const entry = join(globalRoot, "glimpseui", "src", "glimpse.mjs");
+		if (existsSync(entry)) return entry;
+	} catch {
+		// npm may be unavailable.
+	}
+	return null;
+}
+
+async function getGlimpseOpen(): Promise<GlimpseOpen | null> {
+	if (glimpseOpen !== undefined) return glimpseOpen;
+	const resolved = findGlimpseMjs();
+	if (resolved) {
+		try {
+			const mod = await import(resolved) as { open?: GlimpseOpen };
+			glimpseOpen = typeof mod.open === "function" ? mod.open : null;
+			return glimpseOpen;
+		} catch {}
+	}
+	glimpseOpen = null;
+	return glimpseOpen;
+}
+
+function openInGlimpse(open: GlimpseOpen, url: string, title: string): GlimpseWindow {
+	const shellHTML = `<!DOCTYPE html>
+<html>
+<head><meta charset="UTF-8"><title>${title}</title></head>
+<body style="margin:0; background:#1a1a2e;">
+  <script>window.location.replace(${JSON.stringify(url)});</script>
+</body>
+</html>`;
+	const win = open(shellHTML, {
+		width: 800,
+		height: 900,
+		title,
+	});
+
+	let maxHeight = 1200;
+	win.on("ready", (info) => {
+		const visibleHeight = info?.screen?.visibleHeight;
+		if (typeof visibleHeight === "number" && visibleHeight > 0) {
+			maxHeight = Math.floor(visibleHeight * 0.85);
+		}
+	});
+	win.on("message", (data) => {
+		if (!data || typeof data !== "object") return;
+		const msg = data as Record<string, unknown>;
+		if (msg.type !== "resize" || typeof msg.height !== "number") return;
+		const clamped = Math.max(400, Math.min(Math.round(msg.height), maxHeight));
+		win._write({ type: "resize", width: 800, height: clamped });
+	});
+
+	return win;
+}
+
+export async function openCuratorWindow(
+	pi: ExtensionAPI,
+	url: string,
+	title: string,
+	setGlimpseWindow: (win: GlimpseWindow | null) => void,
+	onGlimpseClosed: (win: GlimpseWindow) => void,
+): Promise<void> {
+	const open = platform() === "darwin" ? await getGlimpseOpen() : null;
+	if (open) {
+		try {
+			const win = openInGlimpse(open, url, title);
+			setGlimpseWindow(win);
+			win.on("closed", () => onGlimpseClosed(win));
+			return;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			console.error(`Failed to open Glimpse curator window: ${message}`);
+			setGlimpseWindow(null);
+		}
+	}
+	await openInBrowser(pi, url);
+}

package/dist/builtin/web-access/web-search-command.ts

@@ -0,0 +1,242 @@
+import type { ExtensionAPI } from "@bastani/atomic";
+import { randomUUID } from "node:crypto";
+import { startCuratorServer, type CuratorServerHandle } from "./curator-server.js";
+import { search } from "./gemini-search.js";
+import type { QueryResultData } from "./storage.js";
+import type { SummaryGenerationContext } from "./summary-review.js";
+import { openCuratorWindow } from "./web-search-browser.js";
+import {
+	collectAllResultsAndUrls,
+	extractDomain,
+	filterByQueryIndices,
+} from "./web-search-formatting.js";
+import type { SearchReturnBuilder, SearchReturnOptions, SearchReturnPayload } from "./web-search-return.js";
+import { generateSummaryForSelectedIndices, loadSummaryModelChoices, resolveSummaryForSubmit, rewriteSearchQuery } from "./web-search-summary.js";
+import type { WebSearchRuntimeState } from "./web-search-types.js";
+import { loadCuratorBootstrap, normalizeProviderInput, normalizeQueryList, saveConfig, type CuratorBootstrap } from "./web-search-config.js";
+
+interface RegisterWebSearchCommandDeps {
+	state: WebSearchRuntimeState;
+	closeCurator(): void;
+	buildSearchReturn: SearchReturnBuilder;
+}
+
+export function registerWebSearchCommand(pi: ExtensionAPI, deps: RegisterWebSearchCommandDeps): void {
+	pi.registerCommand("websearch", {
+		description: "Open web search curator",
+		handler: async (args, ctx) => {
+			deps.closeCurator();
+			const sessionToken = randomUUID();
+
+			const raw = args.trim();
+			const queries = raw.length > 0
+				? normalizeQueryList(raw.split(","))
+				: [];
+
+			let bootstrap: CuratorBootstrap;
+			try {
+				bootstrap = await loadCuratorBootstrap(undefined);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				ctx.ui.notify(`Failed to load web search config: ${message}`, "error");
+				return;
+			}
+			const availableProviders = bootstrap.availableProviders;
+			const initialProvider = bootstrap.defaultProvider;
+			const curatorTimeoutSeconds = bootstrap.timeoutSeconds;
+			let currentProvider = initialProvider;
+			const summaryContext: SummaryGenerationContext = {
+				model: ctx.model,
+				modelRegistry: ctx.modelRegistry,
+			};
+			const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
+
+			ctx.ui.notify("Opening web search curator...", "info");
+
+			const collected = new Map<number, QueryResultData>();
+			const searchAbort = new AbortController();
+			let aborted = false;
+			let commandHandle: CuratorServerHandle | null = null;
+
+			function sendFollowUpFromReturn(payload: SearchReturnPayload) {
+				pi.sendMessage({
+					customType: "web-search-results",
+					content: payload.content,
+					display: "tool",
+					details: payload.details,
+				}, { triggerTurn: true, deliverAs: "followUp" });
+			}
+
+			try {
+				const handle = await startCuratorServer(
+					{
+						queries,
+						sessionToken,
+						timeout: curatorTimeoutSeconds,
+						availableProviders,
+						defaultProvider: initialProvider,
+						summaryModels: summaryModelChoices.summaryModels,
+						defaultSummaryModel: summaryModelChoices.defaultSummaryModel,
+					},
+					{
+						async onSummarize(selectedQueryIndices, summarizeSignal, model, feedback) {
+							if (commandHandle && deps.state.activeCurator !== commandHandle) {
+								throw new Error("Curator session is no longer active.");
+							}
+							return generateSummaryForSelectedIndices(
+								selectedQueryIndices,
+								collected,
+								summaryContext,
+								summarizeSignal,
+								model,
+								feedback,
+							);
+						},
+						onSubmit(payload) {
+							if (commandHandle && deps.state.activeCurator !== commandHandle) return;
+							aborted = true;
+							searchAbort.abort();
+							const filtered = payload.selectedQueryIndices.length > 0
+								? filterByQueryIndices(payload.selectedQueryIndices, collected)
+								: collectAllResultsAndUrls(collected);
+							const base: SearchReturnOptions = {
+								queryList: filtered.results.map(r => r.query),
+								results: filtered.results,
+								urls: filtered.urls,
+								includeContent: false,
+								curated: true,
+								curatedFrom: collected.size,
+							};
+							if (!payload.rawResults) {
+								const resolvedSummary = resolveSummaryForSubmit(payload, collected);
+								base.workflow = "summary-review";
+								base.approvedSummary = resolvedSummary.approvedSummary;
+								base.summaryMeta = resolvedSummary.summaryMeta;
+							}
+							sendFollowUpFromReturn(deps.buildSearchReturn(base));
+							deps.closeCurator();
+						},
+						onCancel(reason) {
+							if (commandHandle && deps.state.activeCurator !== commandHandle) return;
+							aborted = true;
+							searchAbort.abort();
+							if (reason === "timeout") {
+								const all = collectAllResultsAndUrls(collected);
+								const resolvedSummary = resolveSummaryForSubmit({ selectedQueryIndices: [], summary: undefined, summaryMeta: undefined }, collected);
+								sendFollowUpFromReturn(deps.buildSearchReturn({
+									queryList: all.results.map(r => r.query),
+									results: all.results,
+									urls: all.urls,
+									includeContent: false,
+									curated: true,
+									curatedFrom: collected.size,
+									workflow: "summary-review",
+									approvedSummary: resolvedSummary.approvedSummary,
+									summaryMeta: resolvedSummary.summaryMeta,
+								}));
+							}
+							deps.closeCurator();
+						},
+						onProviderChange(provider) {
+							if (commandHandle && deps.state.activeCurator !== commandHandle) return;
+							const normalized = normalizeProviderInput(provider);
+							if (!normalized || normalized === "auto") return;
+							currentProvider = normalized;
+							try {
+								saveConfig({ provider: normalized });
+							} catch (err) {
+								const message = err instanceof Error ? err.message : String(err);
+								console.error(`Failed to persist default provider: ${message}`);
+							}
+						},
+						async onAddSearch(query, queryIndex, provider) {
+							if (commandHandle && deps.state.activeCurator !== commandHandle) {
+								throw new Error("Curator session is no longer active.");
+							}
+							const normalizedProvider = normalizeProviderInput(provider);
+							const requestedProvider = !normalizedProvider || normalizedProvider === "auto"
+								? currentProvider
+								: normalizedProvider;
+							try {
+								const { answer, results, provider: actualProvider } = await search(query, {
+									provider: requestedProvider,
+									signal: searchAbort.signal,
+								});
+								if (commandHandle && deps.state.activeCurator !== commandHandle) {
+									throw new Error("Curator session is no longer active.");
+								}
+								collected.set(queryIndex, { query, answer, results, error: null, provider: actualProvider });
+								return {
+									answer,
+									results: results.map(r => ({ title: r.title, url: r.url, domain: extractDomain(r.url) })),
+									provider: actualProvider,
+								};
+							} catch (err) {
+								const message = err instanceof Error ? err.message : String(err);
+								if (!commandHandle || deps.state.activeCurator === commandHandle) {
+									collected.set(queryIndex, { query, answer: "", results: [], error: message, provider: requestedProvider });
+								}
+								throw err;
+							}
+						},
+						async onRewriteQuery(query, rewriteSignal) {
+							if (commandHandle && deps.state.activeCurator !== commandHandle) {
+								throw new Error("Curator session is no longer active.");
+							}
+							return rewriteSearchQuery(query, summaryContext, rewriteSignal);
+						},
+					},
+				);
+
+				commandHandle = handle;
+				deps.state.activeCurator = handle;
+				await openCuratorWindow(
+					pi,
+					handle.url,
+					"Search Curator",
+					win => { deps.state.glimpseWin = win; },
+					win => {
+						if (deps.state.glimpseWin === win) {
+							deps.state.glimpseWin = null;
+							deps.closeCurator();
+						}
+					},
+				);
+
+				if (queries.length > 0) {
+					(async () => {
+						for (let qi = 0; qi < queries.length; qi++) {
+							if (aborted || deps.state.activeCurator !== handle) break;
+							const requestedProvider = currentProvider;
+							try {
+								const { answer, results, provider } = await search(queries[qi], {
+									provider: requestedProvider,
+									signal: searchAbort.signal,
+								});
+								if (aborted || deps.state.activeCurator !== handle) break;
+								handle.pushResult(qi, {
+									answer,
+									results: results.map(r => ({ title: r.title, url: r.url, domain: extractDomain(r.url) })),
+									provider,
+								});
+								collected.set(qi, { query: queries[qi], answer, results, error: null, provider });
+							} catch (err) {
+								if (aborted || deps.state.activeCurator !== handle) break;
+								const message = err instanceof Error ? err.message : String(err);
+								handle.pushError(qi, message, requestedProvider);
+								collected.set(qi, { query: queries[qi], answer: "", results: [], error: message, provider: requestedProvider });
+							}
+						}
+						if (!aborted && deps.state.activeCurator === handle) handle.searchesDone();
+					})();
+				} else {
+					if (deps.state.activeCurator === handle) handle.searchesDone();
+				}
+			} catch (err) {
+				deps.closeCurator();
+				const message = err instanceof Error ? err.message : String(err);
+				ctx.ui.notify(`Failed to open curator: ${message}`, "error");
+			}
+		},
+	});
+}

package/dist/builtin/web-access/web-search-config.ts

@@ -0,0 +1,163 @@
+import { CONFIG_DIR_NAME, getUserConfigPaths } from "@bastani/atomic";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { findReadableConfigPath } from "./config-paths.ts";
+import { isExaAvailable } from "./exa.js";
+import { isGeminiApiAvailable } from "./gemini-api.js";
+import { isGeminiWebAvailable } from "./gemini-web.js";
+import { isPerplexityAvailable } from "./perplexity.js";
+import type { SearchProvider, ResolvedSearchProvider } from "./gemini-search.js";
+
+const WEB_SEARCH_CONFIG_PATH = getUserConfigPaths("web-search.json")[0] ?? join(homedir(), CONFIG_DIR_NAME, "web-search.json");
+const WEB_SEARCH_CONFIG_READ_PATH = findReadableConfigPath();
+const MAX_CURATOR_TIMEOUT_SECONDS = 600;
+const DEFAULT_CURATOR_TIMEOUT_SECONDS = 20;
+
+export const DEFAULT_SHORTCUTS = { curate: "ctrl+shift+s", activity: "ctrl+shift+w" };
+
+export interface WebSearchConfig {
+	provider?: string;
+	workflow?: string;
+	curatorTimeoutSeconds?: unknown;
+	summaryModel?: string;
+	shortcuts?: {
+		curate?: string;
+		activity?: string;
+	};
+}
+
+export interface ProviderAvailability {
+	perplexity: boolean;
+	exa: boolean;
+	gemini: boolean;
+}
+
+export type WebSearchWorkflow = "none" | "summary-review";
+export type CuratorWorkflow = "summary-review";
+
+export interface CuratorBootstrap {
+	availableProviders: ProviderAvailability;
+	defaultProvider: ResolvedSearchProvider;
+	timeoutSeconds: number;
+}
+
+export function loadConfig(): WebSearchConfig {
+	if (!existsSync(WEB_SEARCH_CONFIG_READ_PATH)) return {};
+	const raw = readFileSync(WEB_SEARCH_CONFIG_READ_PATH, "utf-8");
+	try {
+		return JSON.parse(raw) as WebSearchConfig;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to parse ${WEB_SEARCH_CONFIG_READ_PATH}: ${message}`);
+	}
+}
+
+export function saveConfig(updates: Partial<WebSearchConfig>): void {
+	let config: Record<string, unknown> = {};
+	const existingConfigPath = findReadableConfigPath();
+	if (existsSync(existingConfigPath)) {
+		const raw = readFileSync(existingConfigPath, "utf-8");
+		try {
+			config = JSON.parse(raw) as Record<string, unknown>;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			throw new Error(`Failed to parse ${existingConfigPath}: ${message}`);
+		}
+	}
+
+	Object.assign(config, updates);
+	const dir = join(homedir(), CONFIG_DIR_NAME);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(WEB_SEARCH_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+
+export function loadConfigForExtensionInit(): WebSearchConfig {
+	try {
+		return loadConfig();
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		console.error(`[pi-web-access] ${message}`);
+		return {};
+	}
+}
+
+export function normalizeProviderInput(value: unknown): SearchProvider | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value !== "string") return "auto";
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "auto" || normalized === "exa" || normalized === "perplexity" || normalized === "gemini") {
+		return normalized;
+	}
+	return "auto";
+}
+
+function normalizeCuratorTimeoutSeconds(value: unknown): number | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+	const normalized = Math.floor(value);
+	if (normalized < 1) return undefined;
+	return Math.min(normalized, MAX_CURATOR_TIMEOUT_SECONDS);
+}
+
+export function resolveWorkflow(input: unknown, hasUI: boolean): WebSearchWorkflow {
+	if (!hasUI) return "none";
+	if (typeof input === "string" && input.trim().toLowerCase() === "none") return "none";
+	return "summary-review";
+}
+
+export function normalizeQueryList(queryList: unknown[]): string[] {
+	const normalized: string[] = [];
+	for (const query of queryList) {
+		if (typeof query !== "string") continue;
+		const trimmed = query.trim();
+		if (trimmed.length > 0) normalized.push(trimmed);
+	}
+	return normalized;
+}
+
+function getCuratorTimeoutSeconds(): number {
+	const source = loadConfig();
+	return normalizeCuratorTimeoutSeconds(source.curatorTimeoutSeconds) ?? DEFAULT_CURATOR_TIMEOUT_SECONDS;
+}
+
+async function getProviderAvailability(): Promise<ProviderAvailability> {
+	const geminiWebAvail = await isGeminiWebAvailable();
+	return {
+		perplexity: isPerplexityAvailable(),
+		exa: isExaAvailable(),
+		gemini: isGeminiApiAvailable() || !!geminiWebAvail,
+	};
+}
+
+export async function loadCuratorBootstrap(requestedProvider: unknown): Promise<CuratorBootstrap> {
+	const availableProviders = await getProviderAvailability();
+	return {
+		availableProviders,
+		defaultProvider: resolveProvider(requestedProvider, availableProviders),
+		timeoutSeconds: getCuratorTimeoutSeconds(),
+	};
+}
+
+function resolveProvider(requested: unknown, available: ProviderAvailability): ResolvedSearchProvider {
+	const provider = normalizeProviderInput(requested ?? loadConfig().provider ?? "auto") ?? "auto";
+
+	if (provider === "auto") {
+		if (available.exa) return "exa";
+		if (available.perplexity) return "perplexity";
+		if (available.gemini) return "gemini";
+		return "exa";
+	}
+	if (provider === "exa" && !available.exa) {
+		if (available.perplexity) return "perplexity";
+		return available.gemini ? "gemini" : "exa";
+	}
+	if (provider === "perplexity" && !available.perplexity) {
+		if (available.exa) return "exa";
+		return available.gemini ? "gemini" : "perplexity";
+	}
+	if (provider === "gemini" && !available.gemini) {
+		if (available.exa) return "exa";
+		return available.perplexity ? "perplexity" : "gemini";
+	}
+	return provider;
+}