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

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,

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

@@ -150,6 +150,7 @@ interface PerplexityOAuthStreamEvent {
 	error_code?: string;
 	error_message?: string;
 	display_model?: string;
+	user_selected_model?: string;
 	uuid?: string;
 }
 
@@ -327,7 +328,11 @@ export interface PerplexitySearchParams {
 	system_prompt?: string;
 	/** Pre-parsed view of `query` from the search pipeline; parsed locally when absent. */
 	parsedQuery?: StructuredQuery;
+	/** Direct API model. Defaults to `PI_PERPLEXITY_API_MODEL`, then `sonar-pro`. */
+	api_model?: string;
 	search_recency_filter?: "hour" | "day" | "week" | "month" | "year";
+	/** Consumer subscription model preference. Defaults to `PI_PERPLEXITY_MODEL`, then Sonar (`experimental`). */
+	subscription_model?: string;
 	num_results?: number;
 	/** Maximum output tokens. Defaults to 8192. */
 	max_tokens?: number;
@@ -539,6 +544,15 @@ async function callPerplexityApi(
 	return parseStreamedApiResponse(message, metadata);
 }
 
+function oauthSourceKey(url: string): string {
+	const trimmed = url.trim().replace(/\/$/, "");
+	try {
+		return new URL(trimmed).href.replace(/\/$/, "");
+	} catch {
+		return trimmed.toLowerCase();
+	}
+}
+
 function buildOAuthSources(event: PerplexityOAuthStreamEvent): SearchSource[] {
 	const results =
 		event.blocks?.find(block => block.intended_usage === "web_results")?.web_result_block?.web_results ?? [];
@@ -607,6 +621,7 @@ async function callPerplexityAsk(
 	params: PerplexitySearchParams,
 	filters: PerplexityNativeFilters,
 ): Promise<{ answer: string; sources: SearchSource[]; model?: string; requestId?: string }> {
+	const subscriptionModel = params.subscription_model?.trim() || $env.PI_PERPLEXITY_MODEL?.trim() || "experimental";
 	const requestId = crypto.randomUUID();
 	// The consumer `perplexity_ask` endpoint is itself a research assistant and
 	// has no system-message slot. Prepending the API-style system prompt to the
@@ -645,14 +660,14 @@ async function callPerplexityAsk(
 		query_str: effectiveQuery,
 		search_focus: "internet",
 		mode: "copilot",
-		model_preference: "experimental",
+		model_preference: subscriptionModel,
 		sources: ["web"],
 		attachments: [],
 		frontend_uuid: crypto.randomUUID(),
 		frontend_context_uuid: crypto.randomUUID(),
 		version: OAUTH_API_VERSION,
 		language: "en-US",
-		timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+		timezone: Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC",
 		// Recency cannot be combined with absolute date filters; explicit
 		// before:/after: bounds take precedence.
 		search_recency_filter: filters.afterDate || filters.beforeDate ? null : (params.search_recency_filter ?? null),
@@ -740,12 +755,14 @@ async function callPerplexityAsk(
 		if (eventAnswer.length > 0) {
 			answer = eventAnswer;
 		}
-
 		for (const source of buildOAuthSources(mergedEvent)) {
-			sourcesByUrl.set(source.url, source);
+			sourcesByUrl.set(oauthSourceKey(source.url), source);
 		}
 
-		if (mergedEvent.display_model) model = mergedEvent.display_model;
+		const reportedModel = [mergedEvent.user_selected_model, mergedEvent.display_model].find(
+			candidate => candidate && candidate !== "turbo",
+		);
+		if (reportedModel) model = reportedModel;
 		if (mergedEvent.uuid) finalRequestId = mergedEvent.uuid;
 		if (mergedEvent.final || mergedEvent.status === "COMPLETED") {
 			break;
@@ -755,7 +772,7 @@ async function callPerplexityAsk(
 	return {
 		answer,
 		sources: [...sourcesByUrl.values()],
-		model,
+		model: model ?? (auth.type === "anonymous" ? mergedEvent.display_model : subscriptionModel),
 		requestId: finalRequestId ?? requestId,
 	};
 }
@@ -872,7 +889,7 @@ export async function searchPerplexity(params: PerplexitySearchParams): Promise<
 	messages.push({ role: "user", content: filters.query });
 
 	const request: PerplexityRequest = {
-		model: "sonar-pro",
+		model: params.api_model?.trim() || $env.PI_PERPLEXITY_API_MODEL?.trim() || "sonar-pro",
 		messages,
 		max_tokens: params.max_tokens ?? DEFAULT_MAX_TOKENS,
 		temperature: params.temperature ?? DEFAULT_TEMPERATURE,