@herbertgao/pi-extensions 2026.9.10 → 2026.9.11

package/node_modules/pi-web-access/domain-filter-normalization.ts

@@ -0,0 +1,14 @@
+export function normalizeDomain(value: string): string | null {
+	let input = value.trim().toLowerCase();
+	if (!input) return null;
+	if (input.startsWith("-")) input = input.slice(1).trim();
+	if (!input) return null;
+	try {
+		const parsed = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
+		input = parsed.hostname;
+	} catch {
+		input = input.split("/")[0]?.split(":")[0] ?? "";
+	}
+	input = input.replace(/^\.+|\.+$/g, "");
+	return /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}

package/node_modules/pi-web-access/duckduckgo.ts

@@ -1,5 +1,7 @@
 import { activityMonitor } from "./activity.ts";
+import { normalizeDomain } from "./domain-filter-normalization.ts";
 import type { SearchOptions, SearchResult, SearchResponse } from "./perplexity.ts";
+import { normalizeSearchResultCount } from "./search-result-count-normalization.ts";
 
 const SEARCH_URL = "https://html.duckduckgo.com/html/";
 const SEARCH_TIMEOUT_MS = 30_000;
@@ -9,26 +11,6 @@ interface NormalizedDomainFilters {
 	blocked: string[];
 }
 
-function normalizeCount(value: number | undefined): number {
-	if (typeof value !== "number" || !Number.isFinite(value)) return 5;
-	return Math.max(1, Math.min(Math.floor(value), 20));
-}
-
-function normalizeDomain(value: string): string | null {
-	let input = value.trim().toLowerCase();
-	if (!input) return null;
-	if (input.startsWith("-")) input = input.slice(1).trim();
-	if (!input) return null;
-	try {
-		const parsed = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
-		input = parsed.hostname;
-	} catch {
-		input = input.split("/")[0]?.split(":")[0] ?? "";
-	}
-	input = input.replace(/^\.+|\.+$/g, "");
-	return /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
-}
-
 function normalizeDomainFilters(domainFilter: string[] | undefined): NormalizedDomainFilters {
 	const filters: NormalizedDomainFilters = { allowed: [], blocked: [] };
 	for (const raw of domainFilter ?? []) {
@@ -103,7 +85,7 @@ export async function searchWithDuckDuckGo(query: string, options: SearchOptions
 			if (!matchesDomainFilters(resultUrl, filters)) continue;
 			const snippet = container.querySelector(".result__snippet")?.textContent?.trim() ?? "";
 			results.push({ title, url: resultUrl, snippet });
-			if (results.length >= normalizeCount(options.numResults)) break;
+			if (results.length >= normalizeSearchResultCount(options.numResults)) break;
 		}
 		if (parseableResults === 0) {
 			throw new Error("DuckDuckGo returned no parseable results (invalid response)");

package/node_modules/pi-web-access/extract.ts

@@ -1275,7 +1275,9 @@ async function extractViaHttp(
 				return {
 					url,
 					title: result.title,
-					content: `PDF extracted and saved to: ${result.outputPath}\n\nPages: ${result.pages}\nCharacters: ${result.chars}`,
+					content: options?.mode === "answer"
+						? result.content
+						: `PDF extracted and saved to: ${result.outputPath}\n\nPages: ${result.pages}\nCharacters: ${result.chars}`,
 					error: null,
 				};
 			} catch (err) {

package/node_modules/pi-web-access/firecrawl.ts

@@ -1,9 +1,12 @@
 import { existsSync, readFileSync } from "node:fs";
 import net from "node:net";
 import { activityMonitor } from "./activity.ts";
+import { normalizeDomain } from "./domain-filter-normalization.ts";
 import { redactCredential, resolveCredential } from "./credential-source.ts";
 import type { ExtractedContent, ExtractOptions } from "./extract.ts";
 import type { SearchOptions, SearchResponse } from "./perplexity.ts";
+import { formatSearchResultsAsAnswer } from "./search-answer-formatting.ts";
+import { normalizeSearchResultCount } from "./search-result-count-normalization.ts";
 import { loadSsrfConfig, validateRemoteUrl, type Lookup } from "./ssrf-protection.ts";
 import { getWebSearchConfigPath } from "./utils.ts";
 
@@ -242,26 +245,6 @@ function scrapeBody(url: string): Record<string, unknown> {
 	};
 }
 
-function normalizeCount(value: number | undefined): number {
-	if (typeof value !== "number" || !Number.isFinite(value)) return 5;
-	return Math.max(1, Math.min(Math.floor(value), 20));
-}
-
-function normalizeDomain(value: string): string | null {
-	let input = value.trim().toLowerCase();
-	if (!input) return null;
-	if (input.startsWith("-")) input = input.slice(1).trim();
-	if (!input) return null;
-	try {
-		const parsed = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
-		input = parsed.hostname;
-	} catch {
-		input = input.split("/")[0]?.split(":")[0] ?? "";
-	}
-	input = input.replace(/^\.+|\.+$/g, "");
-	return /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
-}
-
 function parseDomainFilter(domainFilter: string[] | undefined): DomainFilters {
 	const filters: DomainFilters = { include: [], exclude: [] };
 	for (const raw of domainFilter ?? []) {
@@ -321,13 +304,6 @@ function firstString(...values: unknown[]): string | null {
 	return null;
 }
 
-function buildAnswer(results: SearchResponse["results"]): string {
-	return results.map((result) => {
-		if (result.snippet) return `${result.snippet}\nSource: ${result.title} (${result.url})`;
-		return `Source: ${result.title} (${result.url})`;
-	}).join("\n\n");
-}
-
 function mapSearchResults(data: unknown, numResults: number, filters: DomainFilters): {
 	results: SearchResponse["results"];
 	inlineContent: ExtractedContent[];
@@ -413,7 +389,7 @@ export function isFirecrawlAvailable(): boolean {
 
 export async function searchWithFirecrawl(query: string, options: FirecrawlSearchOptions = {}): Promise<SearchResponse> {
 	requireBaseUrl();
-	const numResults = normalizeCount(options.numResults);
+	const numResults = normalizeSearchResultCount(options.numResults);
 	const filters = parseDomainFilter(options.domainFilter);
 	const envelope = await firecrawlFetch(
 		"search",
@@ -424,7 +400,7 @@ export async function searchWithFirecrawl(query: string, options: FirecrawlSearc
 		{ type: "api", query },
 	);
 	const mapped = mapSearchResults(envelope.data, numResults, filters);
-	const response: SearchResponse = { answer: buildAnswer(mapped.results), results: mapped.results };
+	const response: SearchResponse = { answer: formatSearchResultsAsAnswer(mapped.results), results: mapped.results };
 	if (options.includeContent && mapped.inlineContent.length > 0) response.inlineContent = mapped.inlineContent;
 	return response;
 }

package/node_modules/pi-web-access/gemini-search.ts

@@ -11,6 +11,7 @@ import { isBraveAvailable, searchWithBrave } from "./brave.ts";
 import {
 	isCurrentModelHostedSearchEligible,
 	isOpenAISearchAvailable,
+	OpenAIAlphaSearchUnsupportedError,
 	searchWithCurrentModelOpenAI,
 	searchWithOpenAI,
 } from "./openai-search.ts";
@@ -36,12 +37,13 @@ import { isBrightDataAvailable, searchWithBrightData } from "./brightdata.ts";
 import { isSerpBaseAvailable, searchWithSerpBase } from "./serpbase.ts";
 import { isSerpApiAvailable, searchWithSerpApi } from "./serpapi.ts";
 import { isSerperAvailable, searchWithSerper } from "./serper.ts";
+import { isSerplyAvailable, searchWithSerply } from "./serply.ts";
 import { isValyuAvailable, searchWithValyu } from "./valyu.ts";
 import { isKimiSearchAvailable, searchWithKimi } from "./kimi-search.ts";
 import { isMistralAvailable, searchWithMistral } from "./mistral-search.ts";
 import { getWebSearchConfigPath } from "./utils.ts";
 
-export const RESOLVED_SEARCH_PROVIDERS = ["openai", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "exa", "serpdive", "kagi", "ollama", "anysearch", "xai", "mistral", "brightdata", "serpbase", "serpapi", "serper", "valyu", "bocha", "xcrawl"] as const;
+export const RESOLVED_SEARCH_PROVIDERS = ["openai", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "exa", "serpdive", "kagi", "ollama", "anysearch", "xai", "mistral", "brightdata", "serpbase", "serpapi", "serper", "serply", "valyu", "bocha", "xcrawl"] as const;
 export const SEARCH_PROVIDERS = ["auto", "all", ...RESOLVED_SEARCH_PROVIDERS] as const;
 
 export type ResolvedSearchProvider = typeof RESOLVED_SEARCH_PROVIDERS[number];
@@ -106,7 +108,7 @@ export interface AttributedSearchResponse extends SearchResponse {
 
 const CONFIG_PATH = getWebSearchConfigPath();
 const DEFAULT_SEARCH_MODEL = "gemini-3.6-flash";
-// Explicit-only providers (Parallel MCP, DuckDuckGo, Kimi, AnySearch, XCrawl, xAI, Mistral, Bright Data, SerpBase, SerpApi, Serper, Valyu) are deliberately absent:
+// Explicit-only providers (Parallel MCP, DuckDuckGo, Kimi, AnySearch, XCrawl, xAI, Mistral, Bright Data, SerpBase, SerpApi, Serper, Serply, Valyu) are deliberately absent:
 // `all` must never fan out to an opt-in or paid provider without the user asking for it.
 export const ALL_SEARCH_PROVIDERS: ResolvedSearchProvider[] = ["searxng", "openai", "exa", "brave", "parallel", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "serpdive", "kagi", "ollama", "perplexity", "gemini", "bocha"];
 const VALID_ROUTING_KINDS = ["transient", "quota", "network", "invalid-response", "unsupported"] as const;
@@ -116,6 +118,7 @@ type SearchConfig = {
 	searchProviderConfigured: boolean;
 	searchRouting?: SearchRoutingConfig;
 	searchModel?: string;
+	allowedProviders?: ResolvedSearchProvider[];
 };
 
 let cachedSearchConfig: SearchConfig | null = null;
@@ -141,12 +144,31 @@ function getSearchConfig(): SearchConfig {
 	}
 
 	const searchModel = normalizeSearchModel(raw.searchModel);
+	const webSearch = raw.webSearch;
+	if (webSearch !== undefined && (!webSearch || typeof webSearch !== "object" || Array.isArray(webSearch))) {
+		throw new Error(`webSearch in ${CONFIG_PATH} must be an object`);
+	}
+	const allowedProviders = webSearch && Object.hasOwn(webSearch, "allowedProviders")
+		? normalizeResolvedProviderList((webSearch as Record<string, unknown>).allowedProviders, `webSearch.allowedProviders in ${CONFIG_PATH}`)
+		: undefined;
 	const searchProviderConfigured = Object.hasOwn(raw, "searchProvider") || Object.hasOwn(raw, "provider");
+	const searchProvider = normalizeSearchProviderSelection(raw.searchProvider ?? raw.provider, `provider in ${CONFIG_PATH}`);
+	const searchRouting = Object.hasOwn(raw, "searchRouting") ? normalizeSearchRouting(raw.searchRouting) : undefined;
+	if (allowedProviders) {
+		if (Object.hasOwn(raw, "searchProvider")) {
+			assertSearchProviderSelectionAllowed(normalizeSearchProviderSelection(raw.searchProvider), `searchProvider in ${CONFIG_PATH}`, allowedProviders);
+		}
+		if (Object.hasOwn(raw, "provider")) {
+			assertSearchProviderSelectionAllowed(normalizeSearchProviderSelection(raw.provider), `provider in ${CONFIG_PATH}`, allowedProviders);
+		}
+		if (searchRouting) assertSearchProviderSelectionAllowed(searchRouting.providers, `searchRouting.providers in ${CONFIG_PATH}`, allowedProviders);
+	}
 	cachedSearchConfig = {
-		searchProvider: normalizeSearchProviderSelection(raw.searchProvider ?? raw.provider, `provider in ${CONFIG_PATH}`),
+		searchProvider,
 		searchProviderConfigured,
-		...(Object.hasOwn(raw, "searchRouting") ? { searchRouting: normalizeSearchRouting(raw.searchRouting) } : {}),
+		...(searchRouting ? { searchRouting } : {}),
 		...(searchModel ? { searchModel } : {}),
+		...(allowedProviders ? { allowedProviders } : {}),
 	};
 	return cachedSearchConfig;
 }
@@ -209,6 +231,25 @@ function normalizeResolvedProviderList(value: unknown, label: string): ResolvedS
 	return providers;
 }
 
+export function assertSearchProviderSelectionAllowed(
+	selection: SearchProviderSelection,
+	label = "provider",
+	allowedProviders = getSearchConfig().allowedProviders,
+): void {
+	if (!allowedProviders) return;
+	const requested = Array.isArray(selection)
+		? selection
+		: selection === "auto" || selection === "all" ? [] : [selection];
+	const disabled = requested.filter(provider => !allowedProviders.includes(provider));
+	if (disabled.length > 0) {
+		throw new Error(`${label} ${disabled.length === 1 ? `references disabled provider "${disabled[0]}"` : `references disabled providers: ${disabled.join(", ")}`}; allowed by webSearch.allowedProviders: ${allowedProviders.join(", ")}`);
+	}
+}
+
+export function getAllowedSearchProviders(): readonly ResolvedSearchProvider[] {
+	return getSearchConfig().allowedProviders ?? RESOLVED_SEARCH_PROVIDERS;
+}
+
 export function normalizeSearchProviderSelection(value: unknown, label = "provider"): SearchProviderSelection {
 	if (Array.isArray(value)) return normalizeResolvedProviderList(value, label);
 	const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
@@ -304,6 +345,8 @@ function classifyProviderError(provider: ResolvedSearchProvider, err: unknown):
 		kind = "credential";
 	} else if (isAbortError(err)) {
 		kind = "aborted";
+	} else if (err instanceof OpenAIAlphaSearchUnsupportedError) {
+		kind = "unsupported";
 	} else if (provider === "xai" && status === 403 && /spending[- ]limit|(?:no|out of) credits?|insufficient quota|quota (?:exceeded|exhausted)|credits? (?:exhausted|depleted|used up)/.test(lower)) {
 		kind = "quota";
 	} else if (status === 401 || status === 403) {
@@ -339,7 +382,7 @@ async function searchWithResolvedProvider(
 	query: string,
 	options: FullSearchOptions,
 	useCurrentModel = false,
-): Promise<AttributedSearchResponse> {
+): Promise<ProviderSearchResponse> {
 	if (provider === "openai") {
 		const result = useCurrentModel
 			? await searchWithCurrentModelOpenAI(query, options, options.extensionContext)
@@ -367,6 +410,7 @@ async function searchWithResolvedProvider(
 	if (provider === "serpbase") return { ...(await searchWithSerpBase(query, options)), provider };
 	if (provider === "serpapi") return { ...(await searchWithSerpApi(query, options)), provider };
 	if (provider === "serper") return { ...(await searchWithSerper(query, options)), provider };
+	if (provider === "serply") return { ...(await searchWithSerply(query, options)), provider };
 	if (provider === "valyu") return { ...(await searchWithValyu(query, options)), provider };
 	if (provider === "xcrawl") return { ...(await searchWithXCrawl(query, options)), provider };
 	if (provider === "perplexity") return { ...(await searchWithPerplexity(query, options)), provider };
@@ -416,6 +460,7 @@ async function isResolvedProviderAvailable(provider: ResolvedSearchProvider, opt
 	if (provider === "serpbase") return isSerpBaseAvailable();
 	if (provider === "serpapi") return isSerpApiAvailable();
 	if (provider === "serper") return isSerperAvailable();
+	if (provider === "serply") return isSerplyAvailable();
 	if (provider === "valyu") return isValyuAvailable();
 	if (provider === "xcrawl") return isXcrawlAvailable();
 	if (provider === "perplexity") return isPerplexityAvailable();
@@ -434,7 +479,7 @@ async function isGeminiWebOptionallyAvailable(): Promise<boolean> {
 	}
 }
 
-function providerLabel(provider: ResolvedSearchProvider): string {
+export function providerLabel(provider: ResolvedSearchProvider): string {
 	if (provider === "openai") return "OpenAI";
 	if (provider === "parallel-mcp") return "Parallel MCP";
 	if (provider === "tinyfish") return "TinyFish";
@@ -456,6 +501,7 @@ function providerLabel(provider: ResolvedSearchProvider): string {
 	if (provider === "serpbase") return "SerpBase";
 	if (provider === "serpapi") return "SerpApi";
 	if (provider === "serper") return "Serper";
+	if (provider === "serply") return "Serply";
 	if (provider === "valyu") return "Valyu";
 	return provider.charAt(0).toUpperCase() + provider.slice(1);
 }
@@ -464,7 +510,7 @@ async function searchWithAllProvider(
 	provider: ResolvedSearchProvider,
 	query: string,
 	options: FullSearchOptions,
-): Promise<AttributedSearchResponse> {
+): Promise<ProviderSearchResponse> {
 	if (provider !== "gemini") return searchWithResolvedProvider(provider, query, options);
 	const result = await searchWithGeminiApi(query, options);
 	if (result) return { ...result, provider };
@@ -476,14 +522,15 @@ async function searchWithProviders(
 	options: FullSearchOptions,
 	selectedProviders?: ResolvedSearchProvider[],
 ): Promise<AttributedSearchResponse> {
-	const providers = selectedProviders ?? (await Promise.all(ALL_SEARCH_PROVIDERS.map(async (provider) => ({
+	const allowed = getAllowedSearchProviders();
+	const providers = selectedProviders ?? (await Promise.all(ALL_SEARCH_PROVIDERS.filter(provider => allowed.includes(provider)).map(async (provider) => ({
 		provider,
 		available: provider === "gemini"
 			? isGeminiApiAvailable()
 			: await isResolvedProviderAvailable(provider, options),
 	})))).filter((entry) => entry.available).map((entry) => entry.provider);
 	if (providers.length === 0) {
-		throw new Error("No configured search provider available for provider \"all\". Parallel MCP, DuckDuckGo, Kimi, AnySearch, xAI, Mistral, Bright Data, SerpBase, SerpApi, Serper, Valyu, and XCrawl are excluded.");
+		throw new Error("No configured search provider available for provider \"all\". Parallel MCP, DuckDuckGo, Kimi, AnySearch, xAI, Mistral, Bright Data, SerpBase, SerpApi, Serper, Serply, Valyu, and XCrawl are excluded.");
 	}
 
 	const settled = await Promise.allSettled(
@@ -493,7 +540,7 @@ async function searchWithProviders(
 	);
 	if (options.signal?.aborted) throw new Error("Aborted");
 
-	const successes: AttributedSearchResponse[] = [];
+	const successes: ProviderSearchResponse[] = [];
 	const failures: Array<{ provider: ResolvedSearchProvider; error: string }> = [];
 	for (let index = 0; index < settled.length; index++) {
 		const outcome = settled[index];
@@ -526,7 +573,7 @@ async function searchWithProviders(
 	}
 
 	const answerSections = successes.map((response) =>
-		`## ${providerLabel(response.provider as ResolvedSearchProvider)}\n\n${response.answer || "(No answer text returned.)"}`
+		`## ${providerLabel(response.provider)}\n\n${response.answer || "(No answer text returned.)"}`
 	);
 	if (failures.length > 0) {
 		answerSections.push(
@@ -538,7 +585,7 @@ async function searchWithProviders(
 		provider: "all",
 		answer: answerSections.join("\n\n"),
 		results,
-		providerResponses: successes as ProviderSearchResponse[],
+		providerResponses: successes,
 		...(failures.length > 0 ? { providerErrors: failures } : {}),
 		...(inlineContent.length > 0 ? { inlineContent } : {}),
 	};
@@ -574,6 +621,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 	const provider = options.provider === undefined || options.provider === "auto"
 		? config.searchProvider
 		: options.provider;
+	assertSearchProviderSelectionAllowed(provider, "Requested provider");
 	if (Array.isArray(provider)) {
 		return searchWithProviders(query, options, normalizeResolvedProviderList(provider, "provider"));
 	}
@@ -584,8 +632,9 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 	}
 
 	const fallbackErrors: string[] = [];
+	const allowed = new Set(config.allowedProviders ?? RESOLVED_SEARCH_PROVIDERS);
 
-	if (isSearXNGAvailable()) {
+	if (allowed.has("searxng") && isSearXNGAvailable()) {
 		try {
 			const result = await searchWithSearXNG(query, options);
 			return { ...result, provider: "searxng" };
@@ -596,13 +645,13 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 	}
 
 	let triedOpenAI = false;
-	if (!options.extensionContext || isOpenAICodexSelected(options.extensionContext)) {
+	if (allowed.has("openai") && (!options.extensionContext || isOpenAICodexSelected(options.extensionContext))) {
 		triedOpenAI = true;
 		const result = await tryOpenAIInAuto(query, options, fallbackErrors);
 		if (result) return result;
 	}
 
-	if (isExaAvailable()) {
+	if (allowed.has("exa") && isExaAvailable()) {
 		try {
 			const result = await searchWithExa(query, options);
 			if (result) return { ...result, provider: "exa" };
@@ -612,12 +661,12 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (!triedOpenAI) {
+	if (allowed.has("openai") && !triedOpenAI) {
 		const result = await tryOpenAIInAuto(query, options, fallbackErrors);
 		if (result) return result;
 	}
 
-	if (isBraveAvailable()) {
+	if (allowed.has("brave") && isBraveAvailable()) {
 		try {
 			const result = await searchWithBrave(query, options);
 			return { ...result, provider: "brave" };
@@ -627,7 +676,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isParallelAvailable()) {
+	if (allowed.has("parallel") && isParallelAvailable()) {
 		try {
 			const result = await searchWithParallel(query, options);
 			return { ...result, provider: "parallel" };
@@ -637,7 +686,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isTinyFishAvailable()) {
+	if (allowed.has("tinyfish") && isTinyFishAvailable()) {
 		try {
 			const result = await searchWithTinyFish(query, options);
 			return { ...result, provider: "tinyfish" };
@@ -647,7 +696,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isSearch1APIAvailable()) {
+	if (allowed.has("search1api") && isSearch1APIAvailable()) {
 		try {
 			const result = await searchWithSearch1API(query, options);
 			return { ...result, provider: "search1api" };
@@ -657,7 +706,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isSearchinfinityAvailable()) {
+	if (allowed.has("searchinfinity") && isSearchinfinityAvailable()) {
 		try {
 			const result = await searchWithSearchinfinity(query, options);
 			return { ...result, provider: "searchinfinity" };
@@ -667,7 +716,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isQueritAvailable()) {
+	if (allowed.has("querit") && isQueritAvailable()) {
 		try {
 			const result = await searchWithQuerit(query, options);
 			return { ...result, provider: "querit" };
@@ -677,7 +726,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isTavilyAvailable()) {
+	if (allowed.has("tavily") && isTavilyAvailable()) {
 		try {
 			const result = await searchWithTavily(query, options);
 			return { ...result, provider: "tavily" };
@@ -687,7 +736,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isFirecrawlAvailable()) {
+	if (allowed.has("firecrawl") && isFirecrawlAvailable()) {
 		try {
 			const result = await searchWithFirecrawl(query, options);
 			return { ...result, provider: "firecrawl" };
@@ -697,7 +746,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isJinaSearchAvailable()) {
+	if (allowed.has("jina") && isJinaSearchAvailable()) {
 		try {
 			const result = await searchWithJina(query, options);
 			return { ...result, provider: "jina" };
@@ -707,7 +756,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isSerpdiveAvailable()) {
+	if (allowed.has("serpdive") && isSerpdiveAvailable()) {
 		try {
 			const result = await searchWithSerpdive(query, options);
 			return { ...result, provider: "serpdive" };
@@ -717,7 +766,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isKagiAvailable()) {
+	if (allowed.has("kagi") && isKagiAvailable()) {
 		try {
 			const result = await searchWithKagi(query, options);
 			return { ...result, provider: "kagi" };
@@ -727,7 +776,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isBochaAvailable()) {
+	if (allowed.has("bocha") && isBochaAvailable()) {
 		try {
 			const result = await searchWithBocha(query, options);
 			return { ...result, provider: "bocha" };
@@ -737,7 +786,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isOllamaAvailable()) {
+	if (allowed.has("ollama") && isOllamaAvailable()) {
 		try {
 			const result = await searchWithOllama(query, options);
 			return { ...result, provider: "ollama" };
@@ -747,7 +796,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	if (isPerplexityAvailable()) {
+	if (allowed.has("perplexity") && isPerplexityAvailable()) {
 		try {
 			const result = await searchWithPerplexity(query, options);
 			return { ...result, provider: "perplexity" };
@@ -757,7 +806,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		}
 	}
 
-	try {
+	if (allowed.has("gemini")) try {
 		const geminiResult = await searchWithGemini(query, options, false);
 		if (geminiResult) return { ...geminiResult, provider: "gemini" };
 	} catch (err) {
@@ -776,7 +825,7 @@ export async function search(query: string, options: FullSearchOptions = {}): Pr
 		"  3. Set OPENAI_API_KEY, BRAVE_API_KEY, PARALLEL_API_KEY, TINYFISH_API_KEY, SEARCH1API_KEY, SEARCHINFINITY_API_KEY, QUERIT_API_KEY, TAVILY_API_KEY, FIRECRAWL_BASE_URL, JINA_API_KEY, SERPDIVE_API_KEY, KAGI_API_KEY, BOCHA_API_KEY, OLLAMA_API_KEY, SEARXNG_BASE_URL, EXA_API_KEY, PERPLEXITY_API_KEY, GEMINI_API_KEY, or CLOUDFLARE_API_KEY env vars\n" +
 		"  4. Set GOOGLE_GEMINI_BASE_URL with CLOUDFLARE_API_KEY for Cloudflare AI Gateway routing\n" +
 		"  5. Sign into gemini.google.com in a supported Chromium-based browser\n" +
-		"  6. Explicitly select provider: \"anysearch\" for anonymous AnySearch, \"xcrawl\" for XCrawl, \"xai\" for Grok, \"mistral\" for Mistral Conversations web search, \"brightdata\" with brightdataSerpZone for paid Bright Data SERP, \"serpbase\", \"serpapi\", or \"serper\" for Google SERP, or \"valyu\" for research search"
+		"  6. Explicitly select provider: \"anysearch\" for anonymous AnySearch, \"xcrawl\" for XCrawl, \"xai\" for Grok, \"mistral\" for Mistral Conversations web search, \"brightdata\" with brightdataSerpZone for paid Bright Data SERP, \"serpbase\", \"serpapi\", \"serper\", or \"serply\" for Google SERP, or \"valyu\" for research search"
 	);
 }