@oh-my-pi/pi-coding-agent 17.0.8 → 17.1.0

package/src/web/search/index.ts

@@ -135,11 +135,9 @@ async function executeSearch(
 	let candidates: SearchProviderCandidate[];
 	if (explicitProvider && explicitProvider !== "auto") {
 		candidates = [{ id: explicitProvider, explicit: true }];
-	} else if (explicitProvider === "auto") {
-		// Explicit `--provider auto` bypasses the configured preferred provider
-		// for this invocation; exclusions still apply.
-		candidates = resolveProviderCandidates("auto");
 	} else {
+		// `--provider auto` and the default both walk the configured chain;
+		// exclusions still apply.
 		candidates = resolveProviderCandidates();
 	}
 
@@ -216,7 +214,6 @@ async function executeSearch(
 			// summary error), masking the cancellation.
 			throwIfAborted(signal);
 			failures.push({ provider: provider ?? providerMeta, error });
-			if (candidate.explicit) break;
 		}
 	}
 
@@ -351,6 +348,6 @@ export function getSearchTools(): CustomTool<any, any>[] {
 	return [webSearchCustomTool];
 }
 
-export { getSearchProvider, setExcludedSearchProviders, setPreferredSearchProvider } from "./provider";
+export { getSearchProvider, setExcludedSearchProviders, setSearchProviderOrder } from "./provider";
 export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";
 export { isSearchProviderId, isSearchProviderPreference } from "./types";

package/src/web/search/provider.ts

@@ -189,12 +189,25 @@ export async function getSearchProvider(id: SearchProviderId): Promise<SearchPro
 	return provider;
 }
 
-/** Preferred provider set via settings (default: auto) */
-let preferredProvId: SearchProviderId | "auto" = "auto";
+/** Provider fallback order set via settings (default: built-in order). */
+let orderedProvIds: readonly SearchProviderId[] = SEARCH_PROVIDER_ORDER;
+/** Providers the user explicitly listed in `providers.webSearchOrder`. */
+let explicitProvIds = new Set<SearchProviderId>();
 
-/** Set the preferred web search provider from settings */
-export function setPreferredSearchProvider(provider: SearchProviderId | "auto"): void {
-	preferredProvId = provider;
+/**
+ * Prioritize configured providers while retaining every unlisted provider in
+ * its built-in relative order. Invalid IDs are ignored defensively. Listed
+ * providers are treated as explicit selections: they resolve through
+ * `isExplicitlyAvailable`, so e.g. a hand-listed Perplexity may fall back to
+ * anonymous search exactly like the retired single-preference setting did.
+ */
+export function setSearchProviderOrder(providers: readonly SearchProviderId[]): void {
+	const prioritized = new Set(providers.filter(id => SEARCH_PROVIDER_ORDER.includes(id)));
+	explicitProvIds = prioritized;
+	orderedProvIds =
+		prioritized.size === 0
+			? SEARCH_PROVIDER_ORDER
+			: [...prioritized, ...SEARCH_PROVIDER_ORDER.filter(id => !prioritized.has(id))];
 }
 
 /** Providers excluded from web search resolution via settings. */
@@ -215,19 +228,21 @@ export interface SearchProviderCandidate {
 	explicit: boolean;
 }
 
-/** Return provider candidates in fallback order without loading their modules. */
-export function resolveProviderCandidates(
-	preferredProvider: SearchProviderId | "auto" = preferredProvId,
-): SearchProviderCandidate[] {
+/**
+ * Return provider candidates in fallback order without loading their modules.
+ * `forcedProvider` (a per-request `provider` argument) is terminal-first and
+ * bypasses exclusion; configured-order entries carry `explicit: true`.
+ */
+export function resolveProviderCandidates(forcedProvider?: SearchProviderId): SearchProviderCandidate[] {
 	const candidates: SearchProviderCandidate[] = [];
 
-	if (preferredProvider !== "auto" && !isSearchProviderExcluded(preferredProvider)) {
-		candidates.push({ id: preferredProvider, explicit: true });
+	if (forcedProvider !== undefined && !isSearchProviderExcluded(forcedProvider)) {
+		candidates.push({ id: forcedProvider, explicit: true });
 	}
 
-	for (const id of SEARCH_PROVIDER_ORDER) {
-		if (id === preferredProvider || isSearchProviderExcluded(id)) continue;
-		candidates.push({ id, explicit: false });
+	for (const id of orderedProvIds) {
+		if (id === forcedProvider || isSearchProviderExcluded(id)) continue;
+		candidates.push({ id, explicit: explicitProvIds.has(id) });
 	}
 
 	return candidates;
@@ -241,11 +256,11 @@ export function resolveProviderCandidates(
  */
 export async function resolveProviderChain(
 	authStorage: AuthStorage,
-	preferredProvider: SearchProviderId | "auto" = preferredProvId,
+	forcedProvider?: SearchProviderId,
 ): Promise<SearchProvider[]> {
 	const providers: SearchProvider[] = [];
 
-	for (const candidate of resolveProviderCandidates(preferredProvider)) {
+	for (const candidate of resolveProviderCandidates(forcedProvider)) {
 		const provider = await getSearchProvider(candidate.id);
 		const available = candidate.explicit
 			? await provider.isExplicitlyAvailable(authStorage)

package/src/web/search/providers/firecrawl.ts

@@ -4,7 +4,14 @@
  * Calls Firecrawl's search API and maps web results into the unified
  * SearchResponse shape used by the web search tool.
  */
-import { type ApiKey, type AuthStorage, type FetchImpl, getEnvApiKey, withAuth } from "@oh-my-pi/pi-ai";
+import {
+	type AuthStorage,
+	type FetchImpl,
+	getEnvApiKey,
+	resolveApiKeyOnce,
+	seedApiKeyResolver,
+	withAuth,
+} from "@oh-my-pi/pi-ai";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import { clampNumResults } from "../utils";
@@ -66,13 +73,19 @@ function buildRequestBody(params: FirecrawlSearchParams): Record<string, unknown
 	return body;
 }
 
-async function callFirecrawlSearch(apiKey: string, params: FirecrawlSearchParams): Promise<FirecrawlSearchResponse> {
+async function callFirecrawlSearch(
+	apiKey: string | undefined,
+	params: FirecrawlSearchParams,
+): Promise<FirecrawlSearchResponse> {
+	const headers: Record<string, string> = {
+		"Content-Type": "application/json",
+	};
+	if (apiKey) {
+		headers.Authorization = `Bearer ${apiKey}`;
+	}
 	const response = await (params.fetch ?? fetch)(FIRECRAWL_SEARCH_URL, {
 		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			Authorization: `Bearer ${apiKey}`,
-		},
+		headers,
 		body: JSON.stringify(buildRequestBody(params)),
 		signal: withHardTimeout(params.signal),
 	});
@@ -100,16 +113,24 @@ export async function searchFirecrawl(params: SearchParams): Promise<SearchRespo
 		signal: params.signal,
 		fetch: params.fetch,
 	};
-	const keyOrResolver: ApiKey = params.authStorage.resolver("firecrawl", {
+	const keyResolver = params.authStorage.resolver("firecrawl", {
 		sessionId: params.sessionId,
 	});
 	const numResults = clampNumResults(firecrawlParams.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
 
-	const data = await withAuth(keyOrResolver, key => callFirecrawlSearch(key, firecrawlParams), {
-		signal: params.signal,
-		missingKeyMessage:
-			'Firecrawl credentials not found. Set FIRECRAWL_API_KEY or configure an API key for provider "firecrawl".',
-	});
+	const resolvedKey = await resolveApiKeyOnce(keyResolver, params.signal);
+	let data: FirecrawlSearchResponse;
+	if (resolvedKey) {
+		// Reuse the preflight credential for the initial authenticated attempt.
+		const seededResolver = seedApiKeyResolver(resolvedKey, keyResolver);
+		data = await withAuth(seededResolver, key => callFirecrawlSearch(key, firecrawlParams), {
+			signal: params.signal,
+		});
+	} else {
+		// Keyless mode — omit Authorization header
+		data = await callFirecrawlSearch(undefined, firecrawlParams);
+	}
+
 	const sources: SearchSource[] = [];
 
 	for (const result of data.data?.web ?? []) {
@@ -125,7 +146,7 @@ export async function searchFirecrawl(params: SearchParams): Promise<SearchRespo
 		provider: "firecrawl",
 		sources: sources.slice(0, numResults),
 		requestId: data.id ?? undefined,
-		authMode: "api_key",
+		authMode: resolvedKey ? "api_key" : "keyless",
 	};
 }
 
@@ -134,10 +155,22 @@ export class FirecrawlProvider extends SearchProvider {
 	readonly id = "firecrawl";
 	readonly label = "Firecrawl";
 
+	/**
+	 * Auto-chain admission: requires a credential so an unconfigured Firecrawl
+	 * doesn't displace other providers that the user has set up with API keys.
+	 */
 	isAvailable(authStorage: AuthStorage): boolean {
 		return authStorage.hasAuth("firecrawl") || !!getEnvApiKey("firecrawl");
 	}
 
+	/**
+	 * Firecrawl supports keyless mode, so an explicit user selection
+	 * (`webSearch: firecrawl`) works without any credential configured.
+	 */
+	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+		return true;
+	}
+
 	search(params: SearchParams): Promise<SearchResponse> {
 		return searchFirecrawl(params);
 	}

package/src/web/search/providers/xai.ts

@@ -9,7 +9,12 @@ import { SearchProvider } from "./base";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const XAI_DEFAULT_BASE_URL = "https://api.x.ai/v1";
-const XAI_WEB_SEARCH_MODEL = "grok-4.3";
+const XAI_WEB_SEARCH_MODEL = "grok-4.5";
+// grok-4.5 defaults reasoning.effort to "high"; xAI documents "low" for
+// latency-sensitive agentic use and simple tool calling
+// (docs.x.ai/developers/model-capabilities/text/reasoning). Web search is
+// exactly that and runs under a 60s hard timeout, so pin the search calls low.
+const XAI_WEB_SEARCH_REASONING_EFFORT = "low";
 const DEFAULT_NUM_RESULTS = 10;
 const MAX_NUM_RESULTS = 30;
 
@@ -60,6 +65,7 @@ function buildRequestBody(params: SearchParams): Record<string, unknown> {
 			{ role: "user", content: params.query },
 		],
 		tools: [{ type: "web_search" }],
+		reasoning: { effort: XAI_WEB_SEARCH_REASONING_EFFORT },
 	};
 
 	if (params.maxOutputTokens !== undefined) {

package/src/web/search/types.ts

@@ -37,7 +37,11 @@ export const SEARCH_PROVIDER_OPTIONS = [
 	{ value: "jina", label: "Jina", description: "Requires JINA_API_KEY" },
 	{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY and Kagi Search API beta access" },
 	{ value: "tavily", label: "Tavily", description: "Requires TAVILY_API_KEY" },
-	{ value: "firecrawl", label: "Firecrawl", description: "Requires FIRECRAWL_API_KEY" },
+	{
+		value: "firecrawl",
+		label: "Firecrawl",
+		description: "Uses Firecrawl API when FIRECRAWL_API_KEY is set; falls back to keyless mode",
+	},
 	{ value: "brave", label: "Brave", description: "Requires BRAVE_API_KEY" },
 	{
 		value: "kimi",
@@ -92,6 +96,9 @@ export const SEARCH_PROVIDER_ORDER: readonly SearchProviderId[] = SEARCH_PROVIDE
 	option.value === "auto" ? [] : [option.value],
 );
 
+/** Concrete provider choices (no `auto` sentinel) — for list-valued settings like order/exclude. */
+export const SEARCH_PROVIDER_CHOICES = SEARCH_PROVIDER_OPTIONS.filter(option => option.value !== "auto");
+
 export const SEARCH_PROVIDER_PREFERENCES = ["auto", ...SEARCH_PROVIDER_ORDER] as const;
 
 /** Display labels, derived from {@link SEARCH_PROVIDER_OPTIONS}. */