@oh-my-pi/pi-coding-agent 17.2.12 → 17.2.14

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

@@ -20,7 +20,7 @@ import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
-const FIRECRAWL_SEARCH_URL = "https://api.firecrawl.dev/v2/search";
+const FIRECRAWL_DEFAULT_BASE_URL = "https://api.firecrawl.dev/v2";
 const DEFAULT_NUM_RESULTS = 10;
 const MAX_NUM_RESULTS = 100;
 
@@ -30,6 +30,28 @@ const RECENCY_TBS: Record<NonNullable<SearchParams["recency"]>, string> = {
 	month: "qdr:m",
 	year: "qdr:y",
 };
+function resolveSearchUrl(): string {
+	const configured = process.env.FIRECRAWL_BASE_URL ?? process.env.FIRECRAWL_API_URL;
+	if (!configured?.trim()) return `${FIRECRAWL_DEFAULT_BASE_URL}/search`;
+	let url: URL;
+	try {
+		url = new URL(configured.trim());
+	} catch {
+		throw new Error("Invalid Firecrawl base URL: expected an HTTP or HTTPS URL");
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") {
+		throw new Error("Invalid Firecrawl base URL: expected an HTTP or HTTPS URL");
+	}
+	if (url.username || url.password) {
+		throw new Error("Invalid Firecrawl base URL: URL credentials are not allowed");
+	}
+	url.search = "";
+	url.hash = "";
+	url.pathname = url.pathname.replace(/\/+$/, "");
+	if (!/\/v[12]$/i.test(url.pathname)) url.pathname += "/v2";
+	url.pathname += "/search";
+	return url.toString();
+}
 
 export interface FirecrawlSearchParams {
 	query: string;
@@ -46,14 +68,23 @@ interface FirecrawlWebResult {
 	title?: string | null;
 	url?: string | null;
 	description?: string | null;
+	snippet?: string | null;
 	markdown?: string | null;
 }
 
 interface FirecrawlSearchResponse {
+	success?: boolean;
+	error?: string | null;
 	id?: string | null;
-	data?: {
-		web?: FirecrawlWebResult[] | null;
-	} | null;
+	data?:
+		| FirecrawlWebResult[]
+		| {
+				web?: FirecrawlWebResult[] | null;
+				news?: FirecrawlWebResult[] | null;
+				images?: FirecrawlWebResult[] | null;
+		  }
+		| null;
+	results?: FirecrawlWebResult[] | null;
 }
 
 /** Resolve Firecrawl API key through the shared auth storage pipeline. */
@@ -88,7 +119,7 @@ async function callFirecrawlSearch(
 	if (apiKey) {
 		headers.Authorization = `Bearer ${apiKey}`;
 	}
-	const response = await (params.fetch ?? fetch)(FIRECRAWL_SEARCH_URL, {
+	const response = await (params.fetch ?? fetch)(resolveSearchUrl(), {
 		method: "POST",
 		headers,
 		body: JSON.stringify(buildRequestBody(params)),
@@ -106,7 +137,11 @@ async function callFirecrawlSearch(
 		);
 	}
 
-	return (await response.json()) as FirecrawlSearchResponse;
+	const data = (await response.json()) as FirecrawlSearchResponse;
+	if (data.success === false) {
+		throw new SearchProviderError("firecrawl", data.error?.trim() || "Firecrawl request failed");
+	}
+	return data;
 }
 
 /** ISO `YYYY-MM-DD` to Google `MM/DD/YYYY` for `tbs=cdr` custom date ranges. */
@@ -128,6 +163,11 @@ function buildDateTbs(parsed: StructuredQuery): string | undefined {
 	return parts.join(",");
 }
 
+function getWebResults(data: FirecrawlSearchResponse): FirecrawlWebResult[] {
+	if (Array.isArray(data.data)) return data.data;
+	if (data.data && Array.isArray(data.data.web)) return data.data.web;
+	return data.results ?? [];
+}
 /** Execute Firecrawl web search. */
 export async function searchFirecrawl(params: SearchParams): Promise<SearchResponse> {
 	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
@@ -169,12 +209,12 @@ export async function searchFirecrawl(params: SearchParams): Promise<SearchRespo
 
 	const sources: SearchSource[] = [];
 
-	for (const result of data.data?.web ?? []) {
+	for (const result of getWebResults(data)) {
 		if (!result.url) continue;
 		sources.push({
 			title: result.title ?? result.url,
 			url: result.url,
-			snippet: result.description ?? result.markdown ?? undefined,
+			snippet: result.description ?? result.snippet ?? result.markdown ?? undefined,
 		});
 	}
 
@@ -192,11 +232,13 @@ export class FirecrawlProvider extends SearchProvider {
 	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.
+	 * Auto-chain admission requires either a credential or an explicitly
+	 * configured self-hosted endpoint. Hosted keyless mode remains explicit-only
+	 * so it does not displace providers the user configured.
 	 */
 	isAvailable(authStorage: AuthStorage): boolean {
-		return authStorage.hasAuth("firecrawl") || !!getEnvApiKey("firecrawl");
+		const configuredBaseUrl = process.env.FIRECRAWL_BASE_URL ?? process.env.FIRECRAWL_API_URL;
+		return !!configuredBaseUrl?.trim() || authStorage.hasAuth("firecrawl") || !!getEnvApiKey("firecrawl");
 	}
 
 	/**

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

@@ -14,7 +14,7 @@ import {
 	getAntigravityUserAgent,
 	getGeminiCliHeaders,
 } from "@oh-my-pi/pi-catalog/wire/gemini-headers";
-import { fetchWithRetry } from "@oh-my-pi/pi-utils";
+import { fetchWithRetry, USER_AGENT } from "@oh-my-pi/pi-utils";
 
 import type { SearchCitation, SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
@@ -25,7 +25,9 @@ import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const DEFAULT_ENDPOINT = "https://cloudcode-pa.googleapis.com";
 const DEVELOPER_API_PROVIDER = "google";
-const DEVELOPER_API_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta";
+const CLOUDFLARE_GATEWAY_PROVIDER = "cloudflare-ai-gateway";
+const DEFAULT_DEVELOPER_API_HOST = "https://generativelanguage.googleapis.com";
+const DEVELOPER_API_VERSION = "v1beta";
 const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
 const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
 const ANTIGRAVITY_ENDPOINT_FALLBACKS = [ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_SANDBOX_ENDPOINT] as const;
@@ -41,6 +43,32 @@ function resolveGeminiSearchModel(configuredModel: string | undefined): string {
 	return model || DEFAULT_MODEL;
 }
 
+interface GeminiDeveloperEndpoint {
+	url: string;
+	authProvider: typeof DEVELOPER_API_PROVIDER | typeof CLOUDFLARE_GATEWAY_PROVIDER;
+	isCloudflareGateway: boolean;
+}
+
+function resolveGeminiDeveloperEndpoint(): GeminiDeveloperEndpoint {
+	const configuredHost = Bun.env.GOOGLE_GEMINI_BASE_URL?.trim().replace(/\/+$/, "");
+	const host = configuredHost || DEFAULT_DEVELOPER_API_HOST;
+	let parsed: URL;
+	try {
+		parsed = new URL(host);
+	} catch {
+		throw new SearchProviderError("gemini", "GOOGLE_GEMINI_BASE_URL must be a valid absolute URL", 400);
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+		throw new SearchProviderError("gemini", "GOOGLE_GEMINI_BASE_URL must use HTTP or HTTPS", 400);
+	}
+	const isCloudflareGateway = parsed.hostname === "gateway.ai.cloudflare.com";
+	return {
+		url: `${host}/${DEVELOPER_API_VERSION}`,
+		authProvider: isCloudflareGateway ? CLOUDFLARE_GATEWAY_PROVIDER : DEVELOPER_API_PROVIDER,
+		isCloudflareGateway,
+	};
+}
+
 const GEMINI_PROVIDERS = ["google-gemini-cli", "google-antigravity"] as const;
 type GeminiProviderId = (typeof GEMINI_PROVIDERS)[number];
 
@@ -292,6 +320,79 @@ async function parseGeminiSearchStream(
 	};
 }
 
+function isGroundingRedirectUrl(url: string): boolean {
+	try {
+		const parsed = new URL(url);
+		return (
+			parsed.hostname === "vertexaisearch.cloud.google.com" && parsed.pathname.includes("/grounding-api-redirect")
+		);
+	} catch {
+		return false;
+	}
+}
+
+async function resolveGroundingRedirect(
+	proxyUrl: string,
+	fetchImpl: FetchImpl | undefined,
+	signal: AbortSignal | undefined,
+): Promise<string> {
+	try {
+		const response = await (fetchImpl ?? fetch)(proxyUrl, {
+			method: "HEAD",
+			redirect: "manual",
+			signal: withHardTimeout(signal, 5000),
+		});
+		const location = response.headers.get("location");
+		if (!location) return proxyUrl;
+		const resolved = new URL(location, proxyUrl);
+		return resolved.protocol === "http:" || resolved.protocol === "https:" ? resolved.toString() : proxyUrl;
+	} catch {
+		return proxyUrl;
+	}
+}
+
+async function finalizeGeminiSearchResult(
+	result: GeminiSearchResult,
+	fetchImpl: FetchImpl | undefined,
+	signal: AbortSignal | undefined,
+): Promise<GeminiSearchResult> {
+	if (!result.answer && result.sources.length === 0) {
+		throw new SearchProviderError("gemini", "Gemini API returned an empty grounded response", 502);
+	}
+
+	const redirectUrls = new Set<string>();
+	for (const source of result.sources) {
+		if (isGroundingRedirectUrl(source.url)) redirectUrls.add(source.url);
+	}
+	for (const citation of result.citations) {
+		if (isGroundingRedirectUrl(citation.url)) redirectUrls.add(citation.url);
+	}
+	if (redirectUrls.size === 0) return result;
+
+	signal?.throwIfAborted();
+	const resolvedEntries = await Promise.all(
+		[...redirectUrls].map(async url => [url, await resolveGroundingRedirect(url, fetchImpl, signal)] as const),
+	);
+	signal?.throwIfAborted();
+	const resolvedUrls = new Map(resolvedEntries);
+	for (const source of result.sources) {
+		source.url = resolvedUrls.get(source.url) ?? source.url;
+	}
+	for (const citation of result.citations) {
+		citation.url = resolvedUrls.get(citation.url) ?? citation.url;
+	}
+
+	const seenUrls = new Set<string>();
+	let writeIndex = 0;
+	for (const source of result.sources) {
+		if (seenUrls.has(source.url)) continue;
+		seenUrls.add(source.url);
+		result.sources[writeIndex++] = source;
+	}
+	result.sources.length = writeIndex;
+	return result;
+}
+
 /**
  * Calls the Cloud Code Assist API with Google Search grounding enabled.
  *
@@ -335,8 +436,8 @@ async function callGeminiSearch(
 				requestId: `agent-${crypto.randomUUID()}`,
 			}
 		: {
-				userAgent: "pi-coding-agent",
-				requestId: `pi-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+				userAgent: USER_AGENT,
+				requestId: `omp-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
 			};
 
 	const normalizedSystemPrompt = systemPrompt?.toWellFormed();
@@ -420,7 +521,8 @@ async function callGeminiSearch(
 	}
 
 	if (!response?.ok) {
-		const errorText = response ? await response.text() : "Network error";
+		const rawErrorText = response ? await response.text() : "Network error";
+		const errorText = auth.accessToken ? rawErrorText.split(auth.accessToken).join("[redacted]") : rawErrorText;
 		const status = response?.status ?? 502;
 		const classified = classifyProviderHttpError("gemini", status, errorText);
 		if (classified) throw classified;
@@ -431,11 +533,12 @@ async function callGeminiSearch(
 		throw new SearchProviderError("gemini", "Gemini API returned no response body", 500);
 	}
 
-	return parseGeminiSearchStream(response.body, model);
+	return finalizeGeminiSearchResult(await parseGeminiSearchStream(response.body, model), fetchImpl, signal);
 }
 
 async function callGeminiDeveloperSearch(
 	apiKey: string,
+	endpoint: GeminiDeveloperEndpoint,
 	model: string,
 	query: string,
 	systemPrompt: string | undefined,
@@ -473,26 +576,26 @@ async function callGeminiDeveloperSearch(
 		requestBody.generationConfig = generationConfig;
 	}
 
-	const response = await fetchWithRetry(
-		() => `${DEVELOPER_API_ENDPOINT}/models/${model}:streamGenerateContent?alt=sse`,
-		{
-			method: "POST",
-			headers: {
-				"x-goog-api-key": apiKey,
-				"Content-Type": "application/json",
-				Accept: "text/event-stream",
-			},
-			body: JSON.stringify(requestBody),
-			signal: withHardTimeout(signal, timeoutMs),
-			fetch: fetchImpl,
-			maxAttempts: MAX_RETRIES + 1,
-			defaultDelayMs: attempt => BASE_DELAY_MS * 2 ** attempt,
-			maxDelayMs: RATE_LIMIT_BUDGET_MS,
+	const response = await fetchWithRetry(() => `${endpoint.url}/models/${model}:streamGenerateContent?alt=sse`, {
+		method: "POST",
+		headers: {
+			...(endpoint.isCloudflareGateway
+				? { "cf-aig-authorization": `Bearer ${apiKey}` }
+				: { "x-goog-api-key": apiKey }),
+			"Content-Type": "application/json",
+			Accept: "text/event-stream",
 		},
-	);
+		body: JSON.stringify(requestBody),
+		signal: withHardTimeout(signal, timeoutMs),
+		fetch: fetchImpl,
+		maxAttempts: MAX_RETRIES + 1,
+		defaultDelayMs: attempt => BASE_DELAY_MS * 2 ** attempt,
+		maxDelayMs: RATE_LIMIT_BUDGET_MS,
+	});
 
 	if (!response.ok) {
-		const errorText = await response.text();
+		const rawErrorText = await response.text();
+		const errorText = apiKey ? rawErrorText.split(apiKey).join("[redacted]") : rawErrorText;
 		const classified = classifyProviderHttpError("gemini", response.status, errorText);
 		if (classified) throw classified;
 		throw new SearchProviderError(
@@ -506,7 +609,7 @@ async function callGeminiDeveloperSearch(
 		throw new SearchProviderError("gemini", "Gemini API returned no response body", 500);
 	}
 
-	return parseGeminiSearchStream(response.body, model);
+	return finalizeGeminiSearchResult(await parseGeminiSearchStream(response.body, model), fetchImpl, signal);
 }
 
 /**
@@ -557,16 +660,20 @@ export async function searchGemini(params: GeminiSearchParams): Promise<SearchRe
 			{ sessionId: params.sessionId, signal: params.signal, seed: seed.access },
 		);
 	} else {
-		const apiKey = await params.authStorage.getApiKey(DEVELOPER_API_PROVIDER, params.sessionId, {
+		const endpoint = resolveGeminiDeveloperEndpoint();
+		const apiKey = await params.authStorage.getApiKey(endpoint.authProvider, params.sessionId, {
 			signal: params.signal,
 		});
 		if (!apiKey) {
 			throw new Error(
-				"No Gemini credentials found. Set GEMINI_API_KEY, configure an API key for provider \"google\", or login with 'omp /login google-gemini-cli' / 'omp /login google-antigravity' to enable Gemini web search.",
+				endpoint.isCloudflareGateway
+					? 'No Cloudflare AI Gateway credential found. Configure provider "cloudflare-ai-gateway" or set CLOUDFLARE_AI_GATEWAY_API_KEY.'
+					: "No Gemini credentials found. Set GEMINI_API_KEY, configure an API key for provider \"google\", or login with 'omp /login google-gemini-cli' / 'omp /login google-antigravity' to enable Gemini web search.",
 			);
 		}
 		result = await callGeminiDeveloperSearch(
 			apiKey,
+			endpoint,
 			selectedModel,
 			searchQuery,
 			params.system_prompt,
@@ -609,7 +716,12 @@ export class GeminiProvider extends SearchProvider {
 		// Cheap, in-memory check — avoids driving the refresh pipeline during
 		// the provider-chain probe. `searchGemini` refreshes OAuth lazily on the
 		// actual request and resolves developer API keys through AuthStorage.
-		return hasGeminiOAuth(authStorage) || authStorage.hasAuth(DEVELOPER_API_PROVIDER);
+		if (hasGeminiOAuth(authStorage)) return true;
+		try {
+			return authStorage.hasAuth(resolveGeminiDeveloperEndpoint().authProvider);
+		} catch {
+			return false;
+		}
 	}
 
 	search(params: SearchParams): Promise<SearchResponse> {

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

@@ -5,19 +5,24 @@
  * cleaned content.
  */
 
-import { type AuthStorage, type FetchImpl, getEnvApiKey } from "@oh-my-pi/pi-ai";
+import { type ApiKey, type AuthStorage, type FetchImpl, withAuth } from "@oh-my-pi/pi-ai";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import { formatQuery, parseSearchQuery } from "../query";
+import { clampNumResults } from "../utils";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const JINA_SEARCH_URL = "https://s.jina.ai";
+const DEFAULT_NUM_RESULTS = 5;
+const MAX_NUM_RESULTS = 20;
 type SearchParamsWithFetch = SearchParams & { fetch?: FetchImpl };
 
 export interface JinaSearchParams {
 	query: string;
+	authStorage: AuthStorage;
+	sessionId?: string;
 	num_results?: number;
 	/** Single bare host for Jina's `X-Site` in-site search header. */
 	site?: string;
@@ -29,31 +34,37 @@ export interface JinaSearchParams {
 interface JinaSearchResult {
 	title?: string | null;
 	url?: string | null;
+	description?: string | null;
 	content?: string | null;
 }
 
-type JinaSearchResponse = JinaSearchResult[];
-
-/** Find JINA_API_KEY from environment or .env files. */
-export function findApiKey(): string | null {
-	return getEnvApiKey("jina") ?? null;
+interface JinaSearchEnvelope {
+	code?: unknown;
+	data?: unknown;
 }
 
+type JinaSearchResponse = JinaSearchResult[];
+
 /** Call Jina Reader search API. */
 async function callJinaSearch(
 	apiKey: string,
 	query: string,
+	numResults: number,
 	site?: string,
 	signal?: AbortSignal,
 	fetchImpl: FetchImpl = fetch,
 	timeoutMs?: number,
 ): Promise<JinaSearchResponse> {
-	const requestUrl = `${JINA_SEARCH_URL}/${encodeURIComponent(query)}`;
+	const requestUrl = new URL(`${JINA_SEARCH_URL}/${encodeURIComponent(query)}`);
+	requestUrl.searchParams.set("count", String(numResults));
+
 	const headers: Record<string, string> = {
 		Accept: "application/json",
 		Authorization: `Bearer ${apiKey}`,
 	};
 	if (site) headers["X-Site"] = site;
+	headers["X-Respond-With"] = "no-content";
+	headers["X-Retain-Images"] = "none";
 	const response = await fetchImpl(requestUrl, {
 		headers,
 		signal: withHardTimeout(signal, timeoutMs),
@@ -66,24 +77,34 @@ async function callJinaSearch(
 		throw new SearchProviderError("jina", `Jina API error (${response.status}): ${errorText}`, response.status);
 	}
 
-	const payload = (await response.json()) as { data?: JinaSearchResponse } | null;
-	return Array.isArray(payload?.data) ? payload.data : [];
+	const payload = (await response.json()) as JinaSearchEnvelope | JinaSearchResponse | null;
+	if (Array.isArray(payload)) return payload;
+	if (!payload || typeof payload !== "object") {
+		throw new SearchProviderError("jina", "Jina API returned invalid response: expected an object or array");
+	}
+	if (typeof payload.code === "number" && payload.code !== 200) {
+		throw new SearchProviderError("jina", `Jina API response reported failure (${payload.code})`, payload.code);
+	}
+	if (!Array.isArray(payload.data)) {
+		throw new SearchProviderError("jina", "Jina API returned invalid response: expected data array");
+	}
+	return payload.data as JinaSearchResponse;
 }
 
 /** Execute Jina web search. */
 export async function searchJina(params: JinaSearchParams): Promise<SearchResponse> {
-	const apiKey = findApiKey();
-	if (!apiKey) {
-		throw new Error("JINA_API_KEY not found. Set it in environment or .env file.");
-	}
-
-	const response = await callJinaSearch(
-		apiKey,
-		params.query,
-		params.site,
-		params.signal,
-		params.fetch,
-		params.timeoutMs,
+	const numResults = clampNumResults(params.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
+	const keyOrResolver: ApiKey = params.authStorage.resolver("jina", {
+		sessionId: params.sessionId,
+	});
+	const response = await withAuth(
+		keyOrResolver,
+		apiKey =>
+			callJinaSearch(apiKey, params.query, numResults, params.site, params.signal, params.fetch, params.timeoutMs),
+		{
+			signal: params.signal,
+			missingKeyMessage: 'Jina credentials not found. Set JINA_API_KEY or configure an API key for provider "jina".',
+		},
 	);
 	const sources: SearchSource[] = [];
 
@@ -92,11 +113,11 @@ export async function searchJina(params: JinaSearchParams): Promise<SearchRespon
 		sources.push({
 			title: result.title ?? result.url,
 			url: result.url,
-			snippet: result.content ?? undefined,
+			snippet: result.description?.trim() || result.content?.trim() || undefined,
 		});
 	}
 
-	const limitedSources = params.num_results ? sources.slice(0, params.num_results) : sources;
+	const limitedSources = sources.slice(0, numResults);
 
 	return {
 		provider: "jina",
@@ -109,8 +130,8 @@ export class JinaProvider extends SearchProvider {
 	readonly id = "jina";
 	readonly label = "Jina";
 
-	isAvailable(_authStorage: AuthStorage): boolean {
-		return !!findApiKey();
+	isAvailable(authStorage: AuthStorage): boolean {
+		return authStorage.hasAuth("jina");
 	}
 
 	search(params: SearchParamsWithFetch): Promise<SearchResponse> {
@@ -134,6 +155,8 @@ export class JinaProvider extends SearchProvider {
 
 		return searchJina({
 			query,
+			authStorage: params.authStorage,
+			sessionId: params.sessionId,
 			num_results: params.numSearchResults ?? params.limit,
 			site,
 			signal: params.signal,

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

@@ -7,6 +7,7 @@ import {
 	ParallelApiError,
 	type ParallelSearchResult,
 	parseParallelErrorResponse,
+	parseParallelJsonResponse,
 	parseParallelSearchPayload,
 } from "../../parallel";
 import { formatQuery, parseSearchQuery, type StructuredQuery } from "../query";
@@ -28,6 +29,13 @@ interface ParallelSourcePolicy {
 	after_date?: string;
 }
 
+const RECENCY_DAYS: Record<NonNullable<SearchParams["recency"]>, number> = {
+	day: 1,
+	week: 7,
+	month: 30,
+	year: 365,
+};
+
 /** Site values may carry paths (`github.com/anthropics`); Parallel takes bare hosts. */
 function toHosts(sites: readonly string[]): string[] {
 	const hosts = new Set<string>();
@@ -39,19 +47,23 @@ function toHosts(sites: readonly string[]): string[] {
 }
 
 /**
- * Map parsed `site:`/`-site:`/`after:` directives onto Parallel's
- * `source_policy`. Per Parallel docs, `exclude_domains` is ignored when
- * `include_domains` is set, so exclusions are only sent without an allow
- * list (the central lenient filter enforces them regardless).
+ * Map parsed `site:`/`-site:`/`after:` directives and the relative recency
+ * option onto Parallel's `source_policy`. An explicit `after:` bound wins.
+ * Per Parallel docs, `exclude_domains` is ignored when `include_domains` is
+ * set, so exclusions are only sent without an allow list (the central lenient
+ * filter enforces them regardless).
  */
-function toSourcePolicy(parsed: StructuredQuery): ParallelSourcePolicy | undefined {
+function toSourcePolicy(parsed: StructuredQuery, recency?: SearchParams["recency"]): ParallelSourcePolicy | undefined {
 	const policy: ParallelSourcePolicy = {};
 	const include = toHosts(parsed.sites);
 	const exclude = toHosts(parsed.excludedSites);
 	if (include.length) policy.include_domains = include;
 	else if (exclude.length) policy.exclude_domains = exclude;
 	if (parsed.after) policy.after_date = parsed.after;
-	return Object.keys(policy).length ? policy : undefined;
+	else if (recency) {
+		policy.after_date = new Date(Date.now() - RECENCY_DAYS[recency] * 86_400_000).toISOString().slice(0, 10);
+	}
+	return policy.include_domains || policy.exclude_domains || policy.after_date ? policy : undefined;
 }
 
 async function searchWithAuthStorage(
@@ -105,7 +117,7 @@ async function searchWithAuthStorage(
 				throw parseParallelErrorResponse(response.status, await response.text());
 			}
 
-			const payload: unknown = await response.json();
+			const payload = await parseParallelJsonResponse(response, "search");
 			return parseParallelSearchPayload(payload, { parseMetadata: false });
 		},
 		{ signal: params.signal },
@@ -116,6 +128,7 @@ export async function searchParallel(
 	params: {
 		query: string;
 		num_results?: number;
+		recency?: SearchParams["recency"];
 		signal?: AbortSignal;
 		timeoutMs?: number;
 		fetch?: FetchImpl;
@@ -126,9 +139,9 @@ export async function searchParallel(
 ): Promise<SearchResponse> {
 	const numResults = clampNumResults(params.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
 	const parsed = params.parsedQuery ?? parseSearchQuery(params.query);
-	// Back-compat: without directives the upstream request is byte-identical.
+	// Directives are removed only where Parallel has a native equivalent.
 	const query = parsed.hasDirectives ? formatQuery(parsed, PARALLEL_QUERY_SYNTAX) : params.query;
-	const sourcePolicy = parsed.hasDirectives ? toSourcePolicy(parsed) : undefined;
+	const sourcePolicy = toSourcePolicy(parsed, params.recency);
 
 	try {
 		const result = await searchWithAuthStorage(
@@ -174,6 +187,7 @@ export class ParallelProvider extends SearchProvider {
 			{
 				query: params.query,
 				num_results: params.numSearchResults ?? params.limit,
+				recency: params.recency,
 				signal: params.signal,
 				timeoutMs: params.timeoutMs,
 				fetch: params.fetch,