@oh-my-pi/pi-coding-agent 15.9.5 → 15.10.0

package/src/web/scrapers/github.ts

@@ -1,14 +1,28 @@
 import { $env, ptree } from "@oh-my-pi/pi-utils";
 import type { RenderResult, SpecialHandler } from "./types";
-import { buildResult, loadPage } from "./types";
+import { buildResult, formatMediaDuration, loadPage } from "./types";
 
 interface GitHubUrl {
-	type: "blob" | "tree" | "repo" | "issue" | "issues" | "pull" | "pulls" | "discussion" | "discussions" | "other";
+	type:
+		| "blob"
+		| "tree"
+		| "repo"
+		| "issue"
+		| "issues"
+		| "pull"
+		| "pulls"
+		| "discussion"
+		| "discussions"
+		| "actions-run"
+		| "actions-job"
+		| "other";
 	owner: string;
 	repo: string;
 	ref?: string;
 	path?: string;
 	number?: number;
+	runId?: number;
+	jobId?: number;
 }
 
 interface GitHubIssueComment {
@@ -20,7 +34,7 @@ interface GitHubIssueComment {
 /**
  * Parse GitHub URL into components
  */
-function parseGitHubUrl(url: string): GitHubUrl | null {
+export function parseGitHubUrl(url: string): GitHubUrl | null {
 	try {
 		const parsed = new URL(url);
 		if (parsed.hostname !== "github.com") return null;
@@ -54,6 +68,20 @@ function parseGitHubUrl(url: string): GitHubUrl | null {
 				return { type: "pulls", owner, repo };
 			case "pulls":
 				return { type: "pulls", owner, repo };
+			case "actions": {
+				// /actions/runs/{runId}                      → run summary + jobs
+				// /actions/runs/{runId}/job/{jobId}          → single job (web URL uses singular "job")
+				// /actions/runs/{runId}/jobs/{jobId}         → single job (API-style plural)
+				if (subParts[0] === "runs" && /^\d+$/.test(subParts[1] ?? "")) {
+					const runId = parseInt(subParts[1], 10);
+					const seg = subParts[2];
+					if ((seg === "job" || seg === "jobs") && /^\d+$/.test(subParts[3] ?? "")) {
+						return { type: "actions-job", owner, repo, runId, jobId: parseInt(subParts[3], 10) };
+					}
+					return { type: "actions-run", owner, repo, runId };
+				}
+				return { type: "other", owner, repo };
+			}
 			case "discussions":
 				if (subParts.length > 0 && /^\d+$/.test(subParts[0])) {
 					return { type: "discussion", owner, repo, number: parseInt(subParts[0], 10) };
@@ -371,6 +399,212 @@ async function renderGitHubRepo(
 	return { content: md, ok: true };
 }
 
+interface GitHubActionsStep {
+	name: string;
+	status: string;
+	conclusion: string | null;
+	number: number;
+	started_at: string | null;
+	completed_at: string | null;
+}
+
+interface GitHubActionsJob {
+	id: number;
+	run_id: number;
+	name: string;
+	status: string;
+	conclusion: string | null;
+	started_at: string | null;
+	completed_at: string | null;
+	html_url: string | null;
+	steps?: GitHubActionsStep[];
+	runner_name?: string | null;
+	labels?: string[];
+	workflow_name?: string | null;
+	head_branch?: string | null;
+	head_sha?: string;
+}
+
+interface GitHubActionsRun {
+	id: number;
+	name?: string | null;
+	display_title?: string;
+	run_number: number;
+	run_attempt?: number;
+	event: string;
+	status: string;
+	conclusion: string | null;
+	head_branch?: string | null;
+	head_sha?: string;
+	html_url: string;
+	created_at: string;
+	updated_at: string;
+	run_started_at?: string;
+	actor?: { login: string };
+	triggering_actor?: { login: string };
+}
+
+/** Combine status + conclusion into a single label, e.g. `completed (failure)`. */
+function statusLabel(status: string, conclusion: string | null | undefined): string {
+	return conclusion ? `${status} (${conclusion})` : status;
+}
+
+/** Wall-clock duration between two ISO timestamps, formatted HH:MM:SS / MM:SS. Empty when unknown. */
+function actionDuration(start?: string | null, end?: string | null): string {
+	if (!start || !end) return "";
+	const ms = Date.parse(end) - Date.parse(start);
+	if (!Number.isFinite(ms) || ms < 0) return "";
+	return formatMediaDuration(Math.round(ms / 1000));
+}
+
+/** Escape `|` so step/job names can't break a markdown table row. */
+function escapeCell(text: string): string {
+	return text.replaceAll("|", "\\|");
+}
+
+/**
+ * Strip the per-line ISO-8601 timestamp prefix GitHub prepends to every job log line.
+ * Cuts ~28 bytes/line of noise while preserving the message text. Also drops the leading
+ * UTF-8 BOM GitHub puts at the start of the log file (otherwise the first line's timestamp
+ * survives because `^` no longer sits before a digit).
+ */
+export function stripActionsLogTimestamps(logs: string): string {
+	return logs.replace(/^\uFEFF/, "").replace(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z /gm, "");
+}
+
+/** Render a job's steps as a markdown table. Empty string when there are no steps. */
+function renderActionsSteps(steps?: GitHubActionsStep[]): string {
+	if (!steps || steps.length === 0) return "";
+	let md = "| # | Step | Status | Conclusion | Duration |\n";
+	md += "|---|------|--------|------------|----------|\n";
+	for (const step of steps) {
+		const dur = actionDuration(step.started_at, step.completed_at) || "-";
+		md += `| ${step.number} | ${escapeCell(step.name)} | ${step.status} | ${step.conclusion ?? "-"} | ${dur} |\n`;
+	}
+	return `${md}\n`;
+}
+
+/** Run-level metadata lines shared by the run and job renderers. */
+function renderActionsRunMeta(run: GitHubActionsRun): string {
+	let md = `**Workflow:** ${run.name ?? "(unknown)"}\n`;
+	md += `**Run:** #${run.run_number}`;
+	if (run.run_attempt && run.run_attempt > 1) md += ` (attempt ${run.run_attempt})`;
+	md += ` · ${statusLabel(run.status, run.conclusion)}\n`;
+	if (run.head_branch) {
+		md += `**Branch:** ${run.head_branch}${run.head_sha ? ` @ ${run.head_sha.slice(0, 7)}` : ""}\n`;
+	}
+	const actor = run.triggering_actor?.login ?? run.actor?.login;
+	md += `**Event:** ${run.event}${actor ? ` · by @${actor}` : ""}\n`;
+	const started = run.run_started_at ?? run.created_at;
+	const dur = actionDuration(started, run.updated_at);
+	md += `Started: ${started}${dur ? ` · Duration: ${dur}` : ""}\n`;
+	md += `URL: ${run.html_url}\n`;
+	return md;
+}
+
+/** Fetch a job's plain-text logs. Returns null when unavailable (no token / expired / private). */
+async function fetchGitHubJobLogs(
+	owner: string,
+	repo: string,
+	jobId: number,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<string | null> {
+	const headers: Record<string, string> = {
+		Accept: "application/vnd.github+json",
+		"X-GitHub-Api-Version": "2022-11-28",
+	};
+	const token = $env.GITHUB_TOKEN || $env.GH_TOKEN;
+	if (token) headers.Authorization = `Bearer ${token}`;
+
+	// 302 → signed log URL on a different origin; fetch strips Authorization on the cross-origin hop.
+	const result = await loadPage(`https://api.github.com/repos/${owner}/${repo}/actions/jobs/${jobId}/logs`, {
+		timeout,
+		headers,
+		signal,
+	});
+	return result.ok && result.content ? result.content : null;
+}
+
+/**
+ * Render a workflow run: run metadata plus a per-job breakdown. Steps are listed for any job that
+ * did not succeed (the debugging-relevant ones); successful jobs collapse to a single line.
+ */
+async function renderGitHubActionsRun(
+	gh: GitHubUrl,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ content: string; ok: boolean }> {
+	const runResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}/actions/runs/${gh.runId}`, timeout, signal);
+	if (!runResult.ok || !runResult.data) return { content: "", ok: false };
+
+	const run = runResult.data as GitHubActionsRun;
+	let md = `# ${run.display_title || run.name || `Run #${run.run_number}`}\n\n`;
+	md += renderActionsRunMeta(run);
+	md += `\n---\n\n`;
+
+	const jobsResult = await fetchGitHubApi(
+		`/repos/${gh.owner}/${gh.repo}/actions/runs/${gh.runId}/jobs?per_page=100`,
+		timeout,
+		signal,
+	);
+	if (jobsResult.ok && jobsResult.data) {
+		const jobs = (jobsResult.data as { jobs?: GitHubActionsJob[] }).jobs ?? [];
+		md += `## Jobs (${jobs.length})\n\n`;
+		for (const job of jobs) {
+			const dur = actionDuration(job.started_at, job.completed_at);
+			md += `### ${escapeCell(job.name)} — ${statusLabel(job.status, job.conclusion)}${dur ? ` (${dur})` : ""}\n\n`;
+			if (job.conclusion !== "success") {
+				md += renderActionsSteps(job.steps);
+			}
+		}
+	}
+
+	return { content: md, ok: true };
+}
+
+/**
+ * Render a single workflow job: run context, step table, and the full job logs.
+ */
+async function renderGitHubActionsJob(
+	gh: GitHubUrl,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ content: string; ok: boolean }> {
+	const jobResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}/actions/jobs/${gh.jobId}`, timeout, signal);
+	if (!jobResult.ok || !jobResult.data) return { content: "", ok: false };
+
+	const job = jobResult.data as GitHubActionsJob;
+
+	// Best-effort run context for nicer headers; the job render stands on its own without it.
+	const runResult = await fetchGitHubApi(`/repos/${gh.owner}/${gh.repo}/actions/runs/${job.run_id}`, timeout, signal);
+	const run = runResult.ok && runResult.data ? (runResult.data as GitHubActionsRun) : null;
+
+	let md = `# ${escapeCell(job.name)}\n\n`;
+	if (run) {
+		md += renderActionsRunMeta(run);
+	} else if (job.workflow_name) {
+		md += `**Workflow:** ${job.workflow_name}\n`;
+		if (job.head_branch) md += `**Branch:** ${job.head_branch}\n`;
+	}
+	const dur = actionDuration(job.started_at, job.completed_at);
+	md += `**Job:** ${escapeCell(job.name)} · ${statusLabel(job.status, job.conclusion)}${dur ? ` · ${dur}` : ""}\n`;
+	if (job.runner_name) md += `**Runner:** ${job.runner_name}\n`;
+	if (job.html_url) md += `URL: ${job.html_url}\n`;
+	md += `\n---\n\n`;
+
+	const steps = renderActionsSteps(job.steps);
+	if (steps) md += `## Steps\n\n${steps}`;
+
+	const logs = await fetchGitHubJobLogs(gh.owner, gh.repo, job.id, timeout, signal);
+	md += `## Logs\n\n`;
+	md += logs
+		? stripActionsLogTimestamps(logs)
+		: "*Logs unavailable — requires a GITHUB_TOKEN/GH_TOKEN with read access, or the run's logs have expired.*\n";
+
+	return { content: md, ok: true };
+}
+
 /**
  * Handle GitHub URLs specially
  */
@@ -445,6 +679,24 @@ export const handleGitHub: SpecialHandler = async (
 			}
 			break;
 		}
+
+		case "actions-run": {
+			notes.push(`Fetched via GitHub API`);
+			const result = await renderGitHubActionsRun(gh, timeout, signal);
+			if (result.ok) {
+				return buildResult(result.content, { url, method: "github-actions-run", fetchedAt, notes });
+			}
+			break;
+		}
+
+		case "actions-job": {
+			notes.push(`Fetched via GitHub API`);
+			const result = await renderGitHubActionsJob(gh, timeout, signal);
+			if (result.ok) {
+				return buildResult(result.content, { url, method: "github-actions-job", fetchedAt, notes });
+			}
+			break;
+		}
 	}
 
 	// Fall back to null (let normal rendering handle it)

package/src/web/scrapers/youtube.ts

@@ -113,8 +113,9 @@ export const handleYouTube: SpecialHandler = async (
 	const notes: string[] = [];
 	const videoUrl = `https://www.youtube.com/watch?v=${yt.videoId}`;
 
-	// Prefer Parallel extract when credentials are available
-	if (settings.get("providers.parallelFetch") && findParallelApiKey(storage)) {
+	// Prefer Parallel extract when it sits in the reader chain and creds exist
+	const fetchPreference = settings.get("providers.fetch");
+	if ((fetchPreference === "auto" || fetchPreference === "parallel") && findParallelApiKey(storage)) {
 		try {
 			const parallelResult = await extractWithParallel(
 				[videoUrl],

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

@@ -1,10 +1,11 @@
 /**
  * Perplexity Web Search Provider
  *
- * Supports three auth modes:
+ * Supports four auth modes:
  * - Cookies (`PERPLEXITY_COOKIES`) via `www.perplexity.ai/rest/sse/perplexity_ask`
  * - OAuth/session bearer via `AuthStorage` and `www.perplexity.ai/rest/sse/perplexity_ask`
  * - API key (`PERPLEXITY_API_KEY`) via `api.perplexity.ai/chat/completions`
+ * - Anonymous via `www.perplexity.ai/rest/sse/perplexity_ask`
  */
 
 import { type AuthStorage, getEnvApiKey } from "@oh-my-pi/pi-ai";
@@ -32,6 +33,8 @@ const DEFAULT_NUM_SEARCH_RESULTS = 20;
 const OAUTH_EXPIRY_BUFFER_MS = 5 * 60 * 1000;
 const OAUTH_API_VERSION = "2.18";
 const OAUTH_USER_AGENT = "Perplexity/641 CFNetwork/1568 Darwin/25.2.0";
+const ANONYMOUS_USER_AGENT =
+	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
 
 type PerplexityAuth =
 	| {
@@ -45,6 +48,9 @@ type PerplexityAuth =
 	| {
 			type: "cookies";
 			cookies: string;
+	  }
+	| {
+			type: "anonymous";
 	  };
 
 interface PerplexityOAuthStreamMarkdownBlock {
@@ -149,6 +155,112 @@ function mergeOAuthEventSnapshot(
 
 	return merged;
 }
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	return value as Record<string, unknown>;
+}
+
+function parseJson(text: string): unknown | null {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+
+function textFromChunks(value: unknown): string | null {
+	if (!Array.isArray(value) || value.length === 0) return null;
+	let text = "";
+	for (const chunk of value) {
+		if (typeof chunk !== "string") return null;
+		text += chunk;
+	}
+	return text.length > 0 ? text : null;
+}
+
+function textFromStructuredAnswer(value: unknown): string | null {
+	if (!Array.isArray(value)) return null;
+	for (const item of value) {
+		const record = asRecord(item);
+		if (!record) continue;
+		const text = record.text;
+		if (typeof text === "string" && text.length > 0) return text;
+		const chunks = textFromChunks(record.chunks);
+		if (chunks) return chunks;
+	}
+	return null;
+}
+
+function answerFromTextPayload(payload: Record<string, unknown>): string | null {
+	const structured = textFromStructuredAnswer(payload.structured_answer);
+	if (structured) return structured;
+	const chunks = textFromChunks(payload.chunks);
+	if (chunks) return chunks;
+	const answer = payload.answer;
+	return typeof answer === "string" && answer.length > 0 ? answer : null;
+}
+
+function parseOAuthTextPayload(text: string): Record<string, unknown> | null {
+	const parsed = parseJson(text);
+	const direct = asRecord(parsed);
+	if (direct) return direct;
+	if (!Array.isArray(parsed)) return null;
+
+	for (const item of parsed) {
+		const step = asRecord(item);
+		const content = asRecord(step?.content);
+		const answer = content?.answer;
+		if (typeof answer !== "string" || answer.length === 0) continue;
+		const payload = asRecord(parseJson(answer));
+		if (payload) return payload;
+	}
+	return null;
+}
+
+function parseOAuthTextAnswer(text: string): string {
+	const payload = parseOAuthTextPayload(text);
+	if (payload) {
+		const answer = answerFromTextPayload(payload);
+		if (answer) return answer;
+	}
+
+	const parsed = parseJson(text);
+	if (!Array.isArray(parsed)) return text;
+	for (const item of parsed) {
+		const step = asRecord(item);
+		const content = asRecord(step?.content);
+		const answer = content?.answer;
+		if (typeof answer === "string" && answer.length > 0) return answer;
+	}
+	return text;
+}
+
+function sourcesFromTextPayload(text: string | undefined): SearchSource[] {
+	if (!text) return [];
+	const payload = parseOAuthTextPayload(text);
+	const webResults = payload?.web_results;
+	if (!Array.isArray(webResults) || webResults.length === 0) return [];
+
+	const sources: SearchSource[] = [];
+	for (const value of webResults) {
+		const result = asRecord(value);
+		if (!result) continue;
+		const url = result.url;
+		if (typeof url !== "string" || url.length === 0) continue;
+		const name = result.name ?? result.title;
+		const snippet = result.snippet;
+		const timestamp = result.timestamp;
+		sources.push({
+			title: typeof name === "string" && name.length > 0 ? name : url,
+			url,
+			snippet: typeof snippet === "string" ? snippet : undefined,
+			publishedDate: typeof timestamp === "string" ? timestamp : undefined,
+			ageSeconds: dateToAgeSeconds(typeof timestamp === "string" ? timestamp : undefined),
+		});
+	}
+	return sources;
+}
 export interface PerplexitySearchParams {
 	signal?: AbortSignal;
 	query: string;
@@ -216,7 +328,7 @@ async function findPerplexityAuth(
 	authStorage: AuthStorage,
 	sessionId: string | undefined,
 	signal: AbortSignal | undefined,
-): Promise<PerplexityAuth | null> {
+): Promise<PerplexityAuth> {
 	// 1. PERPLEXITY_COOKIES env var
 	const cookies = $env.PERPLEXITY_COOKIES?.trim();
 	if (cookies) {
@@ -235,7 +347,9 @@ async function findPerplexityAuth(
 	if (apiKey) {
 		return { type: "api_key", token: apiKey };
 	}
-	return null;
+
+	// 4. The consumer ask endpoint currently accepts unauthenticated browser-style requests.
+	return { type: "anonymous" };
 }
 
 /** Call Perplexity API-key endpoint. */
@@ -284,7 +398,7 @@ function buildOAuthSources(event: PerplexityOAuthStreamEvent): SearchSource[] {
 			}));
 	}
 
-	return (event.sources_list ?? [])
+	const sources = (event.sources_list ?? [])
 		.filter(source => typeof source.url === "string" && source.url.length > 0)
 		.map(source => ({
 			title: source.title ?? source.url ?? "",
@@ -293,11 +407,13 @@ function buildOAuthSources(event: PerplexityOAuthStreamEvent): SearchSource[] {
 			publishedDate: source.date,
 			ageSeconds: dateToAgeSeconds(source.date),
 		}));
+	if (sources.length > 0) return sources;
+	return sourcesFromTextPayload(event.text);
 }
 
 function buildOAuthAnswer(event: PerplexityOAuthStreamEvent): string {
 	if (!event.blocks?.length) {
-		return typeof event.text === "string" ? event.text : "";
+		return typeof event.text === "string" ? parseOAuthTextAnswer(event.text) : "";
 	}
 
 	const markdownBlock = event.blocks.find(
@@ -324,51 +440,77 @@ function buildOAuthAnswer(event: PerplexityOAuthStreamEvent): string {
 		}
 	}
 	if (typeof event.text === "string" && event.text.length > 0) {
-		return event.text;
+		return parseOAuthTextAnswer(event.text);
 	}
 	return "";
 }
 
-async function callPerplexityOAuth(
-	auth: { type: "oauth"; token: string } | { type: "cookies"; cookies: string },
+async function callPerplexityAsk(
+	auth: { type: "oauth"; token: string } | { type: "cookies"; cookies: string } | { type: "anonymous" },
 	params: PerplexitySearchParams,
 ): Promise<{ answer: string; sources: SearchSource[]; model?: string; requestId?: string }> {
 	const requestId = crypto.randomUUID();
-	const effectiveQuery = params.system_prompt ? `${params.system_prompt}\n\n${params.query}` : params.query;
+	// The consumer `perplexity_ask` endpoint is itself a research assistant and
+	// has no system-message slot. Prepending the API-style system prompt to the
+	// query makes the model read it as a meta-instruction and refuse with
+	// "I don't have access to web-search tools in this turn", so ask-endpoint
+	// searches send the bare query. (The API-key path still uses system_prompt
+	// as a proper `system` message.)
+	const effectiveQuery = params.query;
+
+	const headers: Record<string, string> = {
+		"Content-Type": "application/json",
+		Accept: "text/event-stream",
+		Origin: "https://www.perplexity.ai",
+		Referer: "https://www.perplexity.ai/",
+		"User-Agent": auth.type === "anonymous" ? ANONYMOUS_USER_AGENT : OAUTH_USER_AGENT,
+		"X-Request-ID": requestId,
+	};
+	if (auth.type === "oauth") {
+		// The ask endpoint authenticates via the next-auth session cookie, NOT a
+		// bearer header — a bearer (even a garbage one) is ignored and the request
+		// silently falls back to the anonymous free `turbo` model regardless of
+		// `model_preference`. The stored OAuth token IS the Perplexity session JWT
+		// (the native app injects the same value as this cookie), so sending it as
+		// the cookie is what unlocks the account's Pro model selection.
+		headers.Cookie = `__Secure-next-auth.session-token=${auth.token}`;
+	} else if (auth.type === "cookies") {
+		headers.Cookie = auth.cookies;
+	}
+	if (auth.type !== "anonymous") {
+		headers["X-App-ApiClient"] = "default";
+		headers["X-App-ApiVersion"] = OAUTH_API_VERSION;
+		headers["X-Perplexity-Request-Reason"] = "submit";
+	}
+
+	const requestParams: Record<string, unknown> = {
+		query_str: effectiveQuery,
+		search_focus: "internet",
+		mode: "copilot",
+		model_preference: "experimental",
+		sources: ["web"],
+		attachments: [],
+		frontend_uuid: crypto.randomUUID(),
+		frontend_context_uuid: crypto.randomUUID(),
+		version: OAUTH_API_VERSION,
+		language: "en-US",
+		timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+		search_recency_filter: params.search_recency_filter ?? null,
+		is_incognito: true,
+		use_schematized_api: true,
+		skip_search_enabled: true,
+	};
+	if (auth.type === "anonymous") {
+		requestParams.send_back_text_in_streaming_api = true;
+		requestParams.source = "default";
+	}
 
 	const response = await fetch(PERPLEXITY_OAUTH_ASK_URL, {
 		method: "POST",
-		headers: {
-			...(auth.type === "cookies" ? { Cookie: auth.cookies } : { Authorization: `Bearer ${auth.token}` }),
-			"Content-Type": "application/json",
-			Accept: "text/event-stream",
-			Origin: "https://www.perplexity.ai",
-			Referer: "https://www.perplexity.ai/",
-			"User-Agent": OAUTH_USER_AGENT,
-			"X-App-ApiClient": "default",
-			"X-App-ApiVersion": OAUTH_API_VERSION,
-			"X-Perplexity-Request-Reason": "submit",
-			"X-Request-ID": requestId,
-		},
+		headers,
 		body: JSON.stringify({
 			query_str: effectiveQuery,
-			params: {
-				query_str: effectiveQuery,
-				search_focus: "internet",
-				mode: "copilot",
-				model_preference: "pplx_pro_upgraded",
-				sources: ["web"],
-				attachments: [],
-				frontend_uuid: crypto.randomUUID(),
-				frontend_context_uuid: crypto.randomUUID(),
-				version: OAUTH_API_VERSION,
-				language: "en-US",
-				timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-				search_recency_filter: params.search_recency_filter ?? null,
-				is_incognito: true,
-				use_schematized_api: true,
-				skip_search_enabled: true,
-			},
+			params: requestParams,
 		}),
 		signal: withHardTimeout(params.signal),
 	});
@@ -379,13 +521,13 @@ async function callPerplexityOAuth(
 		if (classified) throw classified;
 		throw new SearchProviderError(
 			"perplexity",
-			`Perplexity OAuth API error (${response.status}): ${errorText}`,
+			`Perplexity ask API error (${response.status}): ${errorText}`,
 			response.status,
 		);
 	}
 
 	if (!response.body) {
-		throw new SearchProviderError("perplexity", "Perplexity OAuth API returned no response body", 500);
+		throw new SearchProviderError("perplexity", "Perplexity ask API returned no response body", 500);
 	}
 
 	let answer = "";
@@ -397,7 +539,7 @@ async function callPerplexityOAuth(
 	for await (const event of readSseJson<PerplexityOAuthStreamEvent>(response.body, params.signal)) {
 		if (event.error_code) {
 			const message = event.error_message ?? event.error_code;
-			throw new SearchProviderError("perplexity", `Perplexity OAuth stream error: ${message}`, 400);
+			throw new SearchProviderError("perplexity", `Perplexity ask stream error: ${message}`, 400);
 		}
 
 		mergedEvent = mergeOAuthEventSnapshot(mergedEvent, event);
@@ -500,20 +642,17 @@ function applySourceLimit(result: SearchResponse, limit?: number): SearchRespons
 /** Execute Perplexity web search */
 export async function searchPerplexity(params: PerplexitySearchParams): Promise<SearchResponse> {
 	const auth = await findPerplexityAuth(params.authStorage, params.sessionId, params.signal);
-	if (!auth) {
-		throw new Error("Perplexity auth not found. Set PERPLEXITY_COOKIES, PERPLEXITY_API_KEY, or login via OAuth.");
-	}
 
-	if (auth.type === "oauth" || auth.type === "cookies") {
-		const oauthResult = await callPerplexityOAuth(auth, params);
+	if (auth.type !== "api_key") {
+		const askResult = await callPerplexityAsk(auth, params);
 		return applySourceLimit(
 			{
 				provider: "perplexity",
-				answer: oauthResult.answer || undefined,
-				sources: oauthResult.sources,
-				model: oauthResult.model,
-				requestId: oauthResult.requestId,
-				authMode: "oauth",
+				answer: askResult.answer || undefined,
+				sources: askResult.sources,
+				model: askResult.model,
+				requestId: askResult.requestId,
+				authMode: auth.type === "anonymous" ? "anonymous" : "oauth",
 			},
 			params.num_results,
 		);
@@ -562,6 +701,15 @@ export class PerplexityProvider extends SearchProvider {
 		return !!$env.PERPLEXITY_COOKIES?.trim() || authStorage.hasAuth("perplexity") || !!findApiKey();
 	}
 
+	/**
+	 * Perplexity accepts anonymous browser-style ask requests, but keep auto
+	 * provider selection credential-gated so a configured provider keeps priority
+	 * over the anonymous fallback.
+	 */
+	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+		return true;
+	}
+
 	search(params: SearchParams): Promise<SearchResponse> {
 		return searchPerplexity({
 			signal: params.signal,