@sayknow-cli/coding-agent 0.2.7 → 0.3.1

package/src/web/insane/url-guard.ts

@@ -0,0 +1,155 @@
+/**
+ * Public HTTP(S) URL guard for the insane-search read fallback.
+ *
+ * The vendored insane-search engine performs its own network requests (curl_cffi,
+ * a real browser) entirely outside the TypeScript fetch path, so the normal
+ * `loadPage()` flow cannot protect against SSRF. This guard MUST run before any
+ * dependency probe or engine subprocess is spawned. It is fail-closed: anything
+ * it cannot prove is a public, non-credentialed http/https target is rejected.
+ *
+ * It does NOT follow or re-validate redirects — the engine may follow redirects
+ * internally that this guard never sees. That residual risk is documented in the
+ * plan and mitigated by validating the input target and keeping the feature
+ * opt-in (default off).
+ */
+import * as dns from "node:dns/promises";
+import * as net from "node:net";
+
+export interface PublicUrlAccepted {
+	ok: true;
+	url: URL;
+	addresses: string[];
+}
+
+export interface PublicUrlRejected {
+	ok: false;
+	reason: string;
+}
+
+export type PublicUrlResult = PublicUrlAccepted | PublicUrlRejected;
+
+/** Resolver seam so tests can inject DNS results without real lookups. */
+export type AddressResolver = (hostname: string) => Promise<string[]>;
+
+const defaultResolver: AddressResolver = async hostname => {
+	const records = await dns.lookup(hostname, { all: true, verbatim: true });
+	return records.map(record => record.address);
+};
+
+const BLOCKED_HOSTNAMES = new Set(["localhost", "localhost.localdomain", "0.0.0.0", ""]);
+
+function isBlockedHostname(hostname: string): boolean {
+	const normalized = hostname.toLowerCase().replace(/\.$/, "");
+	return (
+		BLOCKED_HOSTNAMES.has(normalized) ||
+		normalized === "localhost" ||
+		normalized.endsWith(".localhost") ||
+		normalized.endsWith(".local") ||
+		normalized.endsWith(".internal") ||
+		normalized.endsWith(".home.arpa")
+	);
+}
+
+function isPrivateIPv4(address: string): boolean {
+	const parts = address.split(".").map(part => Number.parseInt(part, 10));
+	if (parts.length !== 4 || parts.some(part => !Number.isInteger(part) || part < 0 || part > 255)) return true;
+	const [a, b] = parts;
+	return (
+		a === 0 || // unspecified / "this network"
+		a === 10 || // RFC1918
+		a === 127 || // loopback
+		(a === 100 && b >= 64 && b <= 127) || // CGNAT 100.64/10
+		(a === 169 && b === 254) || // link-local
+		(a === 172 && b >= 16 && b <= 31) || // RFC1918
+		(a === 192 && b === 0) || // 192.0.0/24 & 192.0.2/24 (documentation/reserved)
+		(a === 192 && b === 168) || // RFC1918
+		(a === 198 && (b === 18 || b === 19)) || // benchmarking 198.18/15
+		(a === 198 && b === 51) || // 198.51.100/24 documentation
+		(a === 203 && b === 0) || // 203.0.113/24 documentation
+		a >= 224 // multicast (224/4) + reserved (240/4) + broadcast
+	);
+}
+
+function normalizeIPv4MappedIPv6(address: string): string {
+	return address.toLowerCase().startsWith("::ffff:") ? address.slice(7) : address;
+}
+
+function isPrivateIPv6(address: string): boolean {
+	const normalized = address.toLowerCase();
+	const mapped = normalizeIPv4MappedIPv6(normalized);
+	if (mapped !== normalized && net.isIP(mapped) === 4) return isPrivateIPv4(mapped);
+	return (
+		normalized === "::" || // unspecified
+		normalized === "::1" || // loopback
+		normalized.startsWith("fc") || // ULA fc00::/7
+		normalized.startsWith("fd") || // ULA
+		normalized.startsWith("fe8") || // link-local fe80::/10
+		normalized.startsWith("fe9") ||
+		normalized.startsWith("fea") ||
+		normalized.startsWith("feb") ||
+		normalized.startsWith("ff") || // multicast ff00::/8
+		normalized.startsWith("2001:db8") || // documentation
+		normalized.startsWith("::ffff:") // any remaining IPv4-mapped form we could not classify
+	);
+}
+
+/** True for any address that is not a routable public unicast address. */
+export function isPrivateOrSpecialAddress(address: string): boolean {
+	const normalized = normalizeIPv4MappedIPv6(address);
+	const family = net.isIP(normalized);
+	if (family === 4) return isPrivateIPv4(normalized);
+	if (family === 6) return isPrivateIPv6(normalized);
+	// Re-check the raw value in case it was an IPv4-mapped IPv6 literal.
+	if (net.isIP(address) === 6) return isPrivateIPv6(address);
+	return true; // not a recognizable IP -> treat as unsafe
+}
+
+/**
+ * Validate that `rawUrl` is a public http/https target safe to hand to the
+ * insane-search engine. Resolves DNS names and rejects any that map to a
+ * private/special address. Never throws; returns a discriminated result.
+ */
+export async function validatePublicHttpUrlForInsane(
+	rawUrl: string,
+	options: { resolver?: AddressResolver } = {},
+): Promise<PublicUrlResult> {
+	const resolver = options.resolver ?? defaultResolver;
+
+	let url: URL;
+	try {
+		url = new URL(rawUrl);
+	} catch {
+		return { ok: false, reason: "invalid URL" };
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") {
+		return { ok: false, reason: `unsupported scheme ${url.protocol}` };
+	}
+	if (url.username || url.password) {
+		return { ok: false, reason: "URL credentials are not allowed" };
+	}
+	if (isBlockedHostname(url.hostname)) {
+		return { ok: false, reason: "localhost or internal host" };
+	}
+
+	const literalFamily = net.isIP(url.hostname);
+	if (literalFamily !== 0) {
+		if (isPrivateOrSpecialAddress(url.hostname)) {
+			return { ok: false, reason: "private, loopback, link-local, or reserved IP literal" };
+		}
+		return { ok: true, url, addresses: [url.hostname] };
+	}
+
+	let addresses: string[];
+	try {
+		addresses = await resolver(url.hostname);
+	} catch {
+		return { ok: false, reason: "host could not be resolved" };
+	}
+	if (addresses.length === 0) {
+		return { ok: false, reason: "host resolved to no addresses" };
+	}
+	if (addresses.some(isPrivateOrSpecialAddress)) {
+		return { ok: false, reason: "host resolves to a private or reserved address" };
+	}
+	return { ok: true, url, addresses };
+}

package/src/web/search/provider.ts

@@ -72,6 +72,11 @@ const PROVIDER_META: Record<SearchProviderId, ProviderMeta> = {
 		label: "DuckDuckGo",
 		load: async () => new (await import("./providers/duckduckgo")).DuckDuckGoProvider(),
 	},
+	insane: {
+		id: "insane",
+		label: "Insane",
+		load: async () => new (await import("./providers/insane")).InsaneProvider(),
+	},
 	"openai-compatible": {
 		id: "openai-compatible",
 		label: "OpenAI-compatible",
@@ -97,6 +102,7 @@ export async function getSearchProvider(id: SearchProviderId): Promise<SearchPro
 
 export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
 	"duckduckgo",
+	"insane",
 	"tavily",
 	"perplexity",
 	"brave",
@@ -234,14 +240,41 @@ export function isLocalBaseUrl(baseUrl: string | undefined): boolean {
 	return false;
 }
 
+/**
+ * Whether `baseUrl` is an official OpenAI endpoint (or absent, i.e. the default
+ * hosted OpenAI). The dedicated `codex` provider authenticates against the
+ * ChatGPT backend with the user's *local* Codex OAuth, so it must only be
+ * selected when the active model is genuinely served by OpenAI/ChatGPT — never
+ * for a custom/proxy endpoint, which should reuse its own credentials through
+ * the `openai-compatible` adapter instead.
+ */
+function isOpenAIOfficialBaseUrl(baseUrl: string | undefined): boolean {
+	if (!baseUrl?.trim()) return true;
+	let host: string;
+	try {
+		host = new URL(baseUrl).hostname.toLowerCase();
+	} catch {
+		return false;
+	}
+	return (
+		host === "api.openai.com" ||
+		host === "chatgpt.com" ||
+		host.endsWith(".openai.com") ||
+		host.endsWith(".chatgpt.com")
+	);
+}
+
 export function inferNativeProviderFromModel(ctx: ActiveSearchModelContext | undefined): SearchProviderId | undefined {
 	if (!ctx || ctx.webSearch === "off") return undefined;
 	const modelId = (ctx.wireModelId ?? ctx.modelId).toLowerCase();
 	if (modelId.startsWith("claude-") && isAnthropicWire(ctx.api)) return "anthropic";
 	if (modelId.startsWith("gemini-") && isGoogleWire(ctx.api)) return "gemini";
 	if (looksXaiFamilyModelId(ctx) && isOpenAICompatWire(ctx.api)) return "xai";
-	if (looksOpenAIFamilyModelId(ctx) && isOpenAICompatWire(ctx.api)) {
-		if (ctx.webSearch === "on" || !isLocalBaseUrl(ctx.baseUrl)) return "codex";
+	// `codex` hits the ChatGPT backend with local Codex OAuth, so only infer it
+	// for genuine OpenAI endpoints. Custom/proxy OpenAI-compatible models fall
+	// through to `activeContextNativeId` → `openai-compatible` (their own creds).
+	if (looksOpenAIFamilyModelId(ctx) && isOpenAICompatWire(ctx.api) && isOpenAIOfficialBaseUrl(ctx.baseUrl)) {
+		return "codex";
 	}
 	return undefined;
 }
@@ -249,8 +282,9 @@ export function inferNativeProviderFromModel(ctx: ActiveSearchModelContext | und
 function canUseDirectProviderMapping(ctx: ActiveSearchModelContext, id: SearchProviderId): boolean {
 	if (ctx.webSearch === "off") return false;
 	if (id !== "codex") return true;
-	if (!isOpenAICompatWire(ctx.api)) return true;
-	return ctx.webSearch === "on" || !isLocalBaseUrl(ctx.baseUrl);
+	// Same constraint as inference: the ChatGPT-backed codex provider is valid
+	// only for official OpenAI endpoints, not custom/proxy base URLs.
+	return isOpenAIOfficialBaseUrl(ctx.baseUrl);
 }
 
 export async function canUseGenericCredentials(
@@ -268,17 +302,35 @@ export async function canUseGenericCredentials(
 	return Boolean(key);
 }
 
-export async function shouldTryGenericOpenAICompat(
-	authStorage: AuthStorage,
-	ctx: ActiveSearchModelContext | undefined,
-	sessionId?: string,
-	signal?: AbortSignal,
-): Promise<boolean> {
-	if (!ctx || ctx.webSearch === "off" || !isOpenAICompatWire(ctx.api)) return false;
-	const autoAllowed =
-		ctx.webSearch === "on" ||
-		((ctx.api === "openai-responses" || looksOpenAIFamilyModelId(ctx)) && !isLocalBaseUrl(ctx.baseUrl));
-	return autoAllowed && (await canUseGenericCredentials(authStorage, ctx, sessionId, signal));
+/**
+ * Native web-search provider to attempt by reusing the ACTIVE model's own
+ * credentials + baseUrl, dispatched by the model's wire protocol.
+ *
+ * This is the "native search over a proxy" path: when a model is served through
+ * a proxy/custom endpoint, its canonical search credentials (e.g. a dedicated
+ * `anthropic` key, or ChatGPT OAuth for `codex`) are usually absent, but the
+ * credential that authenticates the model itself — stored under the active
+ * provider id and aimed at `ctx.baseUrl` — can drive native web search just as
+ * well. Each provider's `search()` falls back to those active credentials when
+ * its canonical ones are missing.
+ *
+ * Returned ids are matched purely from the wire `api` (+ model-id family where a
+ * native tool only makes sense for that family); the providers themselves fail
+ * closed (and the chain falls through to DuckDuckGo) if the endpoint does not
+ * actually support web search.
+ */
+export function activeContextNativeId(ctx: ActiveSearchModelContext | undefined): SearchProviderId | undefined {
+	if (!ctx || ctx.webSearch === "off") return undefined;
+	const modelId = (ctx.wireModelId ?? ctx.modelId).toLowerCase();
+	// Dispatch must match exactly what each provider can service by reusing the
+	// active credential: the OpenAI-compatible adapter only speaks the two plain
+	// OpenAI wires (not azure), and the Gemini active path only speaks the public
+	// Generative Language wire (not vertex/cloud-code). Returning an id the
+	// provider would reject just wastes a guaranteed-fail attempt before DuckDuckGo.
+	if (isAnthropicWire(ctx.api) && modelId.startsWith("claude-")) return "anthropic";
+	if (ctx.api === "openai-responses" || ctx.api === "openai-completions") return "openai-compatible";
+	if (ctx.api === "google-generative-ai" && modelId.startsWith("gemini-")) return "gemini";
+	return undefined;
 }
 
 export async function resolveProviderChain(options: ResolveProviderChainOptions): Promise<SearchProvider[]> {
@@ -304,9 +356,16 @@ export async function resolveProviderChain(options: ResolveProviderChainOptions)
 			await appendAvailable(chain, directId, authStorage);
 		const inferred = inferNativeProviderFromModel(activeModelContext);
 		if (inferred) await appendAvailable(chain, inferred, authStorage);
-		const hasNativeXai = chain.includes("xai");
-		if (!hasNativeXai && (await shouldTryGenericOpenAICompat(authStorage, activeModelContext, sessionId, signal)))
-			appendDeduped(chain, "openai-compatible");
+		// Native-over-proxy: when no canonical native provider was selected above,
+		// fall back to the model's own credentials (resolved under the active
+		// provider id against its baseUrl) to drive native web search. Gated on
+		// those credentials actually resolving; otherwise the chain ends at the
+		// keyless DuckDuckGo terminal fallback.
+		if (chain.length === 0) {
+			const activeNativeId = activeContextNativeId(activeModelContext);
+			if (activeNativeId && (await canUseGenericCredentials(authStorage, activeModelContext, sessionId, signal)))
+				chain.push(activeNativeId);
+		}
 	}
 
 	// Configured fallbacks are user-facing only: the internal `openai-compatible`

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

@@ -25,6 +25,7 @@ import type {
 import { SearchProviderError } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
+import { extractTextSources } from "./text-citations";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const DEFAULT_MODEL = "claude-haiku-4-5";
@@ -87,9 +88,10 @@ async function callSearch(
 	maxTokens?: number,
 	temperature?: number,
 	signal?: AbortSignal,
+	extraHeaders?: Record<string, string>,
 ): Promise<AnthropicApiResponse> {
 	const url = buildAnthropicUrl(auth);
-	const headers = buildAnthropicSearchHeaders(auth);
+	const headers = { ...(extraHeaders ?? {}), ...buildAnthropicSearchHeaders(auth) };
 
 	const systemBlocks = buildSystemBlocks(auth, model, systemPrompt);
 
@@ -191,7 +193,7 @@ function parseResponse(response: AnthropicApiResponse): SearchResponse {
 			if (block.input?.query) {
 				searchQueries.push(block.input.query);
 			}
-		} else if (block.type === "web_search_tool_result" && block.content) {
+		} else if (block.type === "web_search_tool_result" && Array.isArray(block.content)) {
 			// Search results
 			for (const result of block.content) {
 				if (result.type === "web_search_result") {
@@ -235,6 +237,34 @@ function parseResponse(response: AnthropicApiResponse): SearchResponse {
 	};
 }
 
+/**
+ * Whether the response carries proof that a web search actually ran: a
+ * `web_search_tool_result` block, a `web_search` server tool call, or a
+ * non-zero `server_tool_use.web_search_requests` usage counter.
+ */
+function anthropicSearchPerformed(response: AnthropicApiResponse): boolean {
+	if (response.usage?.server_tool_use?.web_search_requests) return true;
+	for (const block of response.content ?? []) {
+		if (block.type === "web_search_tool_result") {
+			// `content` is an array of results on success but an error OBJECT
+			// (`web_search_tool_result_error`) on failure; only count a result
+			// array with at least one real result as proof of search.
+			if (Array.isArray(block.content) && block.content.some(result => result.type === "web_search_result")) {
+				return true;
+			}
+			continue;
+		}
+		if (
+			block.type === "server_tool_use" &&
+			block.name &&
+			stripClaudeToolPrefix(block.name) === WEB_SEARCH_TOOL_NAME
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
 /**
  * Executes a web search using Anthropic's Anthropic model with built-in web search tool.
  * @param params - Search parameters including query and optional settings
@@ -248,6 +278,10 @@ export async function searchAnthropic(
 	const searchApiKey = $env.ANTHROPIC_SEARCH_API_KEY;
 	const searchBaseUrl = $env.ANTHROPIC_SEARCH_BASE_URL;
 	let auth: AnthropicAuthConfig | undefined;
+	// When reusing the active model's own credentials (native search over a
+	// proxy), prefer its wire model id and carry its request headers through.
+	let modelOverride: string | undefined;
+	let extraHeaders: Record<string, string> | undefined;
 
 	if (searchApiKey) {
 		auth = buildAnthropicAuthConfig(searchApiKey, searchBaseUrl);
@@ -256,6 +290,23 @@ export async function searchAnthropic(
 			signal: params.signal,
 		});
 		if (apiKey) auth = buildAnthropicAuthConfig(apiKey);
+
+		// Fall back to the active model's own credentials + baseUrl when no
+		// canonical Anthropic key exists but the active model speaks the
+		// Anthropic wire (e.g. Claude served through a proxy).
+		const ctx = params.activeModelContext;
+		if (!auth && ctx && ctx.api === "anthropic-messages") {
+			const ctxKey = await params.authStorage.getApiKey(ctx.provider, params.sessionId, {
+				baseUrl: ctx.baseUrl,
+				modelId: ctx.modelId,
+				signal: params.signal,
+			});
+			if (ctxKey) {
+				auth = buildAnthropicAuthConfig(ctxKey, ctx.baseUrl);
+				modelOverride = ctx.wireModelId ?? ctx.modelId;
+				extraHeaders = ctx.headers;
+			}
+		}
 	}
 
 	if (!auth) {
@@ -264,7 +315,7 @@ export async function searchAnthropic(
 		);
 	}
 
-	const model = getModel();
+	const model = modelOverride ?? getModel();
 	const systemPrompt = "authStorage" in params ? params.systemPrompt : params.system_prompt;
 	const maxTokens = "authStorage" in params ? params.maxOutputTokens : params.max_tokens;
 	const response = await callSearch(
@@ -275,9 +326,25 @@ export async function searchAnthropic(
 		maxTokens,
 		params.temperature,
 		params.signal,
+		extraHeaders,
 	);
 
 	const result = parseResponse(response);
+	const searched = anthropicSearchPerformed(response);
+
+	// When a search ran but the model wrote its citations inline instead of as
+	// structured `web_search_result_location` blocks, recover sources from the
+	// answer text so a genuinely grounded result is not discarded.
+	if (result.sources.length === 0 && searched && result.answer) {
+		const inline = extractTextSources(result.answer);
+		if (inline.length > 0) result.sources = inline;
+	}
+
+	// Fail closed so the chain falls through to DuckDuckGo when Claude answered
+	// from stable knowledge without running a web search.
+	if (result.sources.length === 0 && !(result.citations && result.citations.length > 0) && !searched) {
+		throw new SearchProviderError("anthropic", "Anthropic web search returned no grounded sources", 424);
+	}
 
 	const numResults = "authStorage" in params ? (params.numSearchResults ?? params.limit) : params.num_results;
 	if (numResults && result.sources.length > numResults) {

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

@@ -15,6 +15,7 @@ import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
+import { addSource, extractTextSources } from "./text-citations";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
@@ -118,125 +119,6 @@ function isImagePlaceholderAnswer(text: string): boolean {
 	return text.trim().toLowerCase() === "(see attached image)";
 }
 
-function addSource(sources: SearchSource[], source: SearchSource): void {
-	if (!sources.some(existing => existing.url === source.url)) {
-		sources.push(source);
-	}
-}
-
-function countCharacter(text: string, target: string): number {
-	let count = 0;
-	for (const char of text) {
-		if (char === target) {
-			count += 1;
-		}
-	}
-	return count;
-}
-
-/**
- * Strips prose punctuation and unmatched closing delimiters from extracted URLs.
- * OpenAI code backend often returns links in markdown or sentence text without structured annotations.
- */
-function normalizeExtractedUrl(candidate: string): string | null {
-	let url = candidate.trim();
-
-	while (url.length > 0) {
-		const lastCharacter = url.at(-1);
-		if (!lastCharacter) break;
-		if (/[.,!?;:'"]/u.test(lastCharacter)) {
-			url = url.slice(0, -1);
-			continue;
-		}
-		if (lastCharacter === ")" && countCharacter(url, ")") > countCharacter(url, "(")) {
-			url = url.slice(0, -1);
-			continue;
-		}
-		if (lastCharacter === "]" && countCharacter(url, "]") > countCharacter(url, "[")) {
-			url = url.slice(0, -1);
-			continue;
-		}
-		if (lastCharacter === "}" && countCharacter(url, "}") > countCharacter(url, "{")) {
-			url = url.slice(0, -1);
-			continue;
-		}
-		break;
-	}
-
-	if (!/^https?:\/\//.test(url)) {
-		return null;
-	}
-
-	try {
-		return new URL(url).toString();
-	} catch {
-		return null;
-	}
-}
-
-function findMarkdownLinkUrlEnd(text: string, openParenIndex: number): number | null {
-	let depth = 0;
-
-	for (let index = openParenIndex; index < text.length; index += 1) {
-		const character = text[index];
-		if (!character || character === "\n") {
-			return null;
-		}
-		if (character === "(") {
-			depth += 1;
-			continue;
-		}
-		if (character !== ")") {
-			continue;
-		}
-		depth -= 1;
-		if (depth === 0) {
-			return index;
-		}
-		if (depth < 0) {
-			return null;
-		}
-	}
-
-	return null;
-}
-
-/**
- * Extracts citation sources from markdown links and bare URLs in the answer text.
- * Used as a fallback when the OpenAI code backend response omits `url_citation` annotations.
- */
-function extractTextSources(text: string): SearchSource[] {
-	const sources: SearchSource[] = [];
-
-	for (let index = 0; index < text.length; index += 1) {
-		if (text[index] !== "[") {
-			continue;
-		}
-		const titleEnd = text.indexOf("]", index + 1);
-		if (titleEnd === -1 || text[titleEnd + 1] !== "(") {
-			continue;
-		}
-		const urlEnd = findMarkdownLinkUrlEnd(text, titleEnd + 1);
-		if (urlEnd === null) {
-			continue;
-		}
-		const title = text.slice(index + 1, titleEnd).trim();
-		const url = normalizeExtractedUrl(text.slice(titleEnd + 2, urlEnd));
-		if (url) {
-			addSource(sources, { title: title || url, url });
-		}
-		index = urlEnd;
-	}
-
-	for (const match of text.matchAll(/https?:\/\/\S+/g)) {
-		const url = normalizeExtractedUrl(match[0] ?? "");
-		if (!url) continue;
-		addSource(sources, { title: url, url });
-	}
-
-	return sources;
-}
-
 /**
  * Extracts account ID from a OpenAI code backend access token.
  * @param accessToken - JWT access token

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

@@ -425,6 +425,98 @@ export async function searchGemini(params: GeminiSearchParams): Promise<SearchRe
 	};
 }
 
+/**
+ * Native Gemini web search over the public Generative Language REST API
+ * (`{baseUrl}/v1beta/models/{model}:generateContent`), reusing the ACTIVE
+ * model's own API key + baseUrl. This is the "native search over a proxy" path
+ * for `google-generative-ai` wire models whose canonical gemini-cli/antigravity
+ * OAuth is absent. Distinct from {@link searchGemini}, which speaks the Cloud
+ * Code Assist API with OAuth.
+ */
+async function searchGeminiViaGenerativeLanguage(params: SearchParams): Promise<SearchResponse> {
+	const ctx = params.activeModelContext;
+	if (!ctx) throw new SearchProviderError("gemini", "Gemini web search requires active model context", 400);
+	const apiKey = await params.authStorage.getApiKey(ctx.provider, params.sessionId, {
+		baseUrl: ctx.baseUrl,
+		modelId: ctx.modelId,
+		signal: params.signal,
+	});
+	if (!apiKey) throw new SearchProviderError("gemini", `No credentials for ${ctx.provider}`, 401);
+
+	const model = ctx.wireModelId ?? ctx.modelId;
+	const base = (ctx.baseUrl ?? "https://generativelanguage.googleapis.com").replace(/\/+$/, "");
+	// Respect an already-versioned active baseUrl (e.g. a proxy exposing `…/v1beta`)
+	// instead of double-appending the version segment.
+	const versionedBase = /\/v1(beta|alpha)?$/.test(base) ? base : `${base}/v1beta`;
+	const url = `${versionedBase}/models/${encodeURIComponent(model)}:generateContent`;
+	const systemPrompt = params.systemPrompt?.toWellFormed();
+	const body: Record<string, unknown> = {
+		contents: [{ role: "user", parts: [{ text: params.query }] }],
+		tools: buildGeminiRequestTools({ google_search: params.googleSearch }),
+		...(systemPrompt ? { systemInstruction: { parts: [{ text: systemPrompt }] } } : {}),
+	};
+	if (params.maxOutputTokens !== undefined || params.temperature !== undefined) {
+		const generationConfig: Record<string, number> = {};
+		if (params.maxOutputTokens !== undefined) generationConfig.maxOutputTokens = params.maxOutputTokens;
+		if (params.temperature !== undefined) generationConfig.temperature = params.temperature;
+		body.generationConfig = generationConfig;
+	}
+
+	const response = await fetch(url, {
+		method: "POST",
+		headers: { ...(ctx.headers ?? {}), "x-goog-api-key": apiKey, "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+		signal: withHardTimeout(params.signal),
+	});
+	const text = await response.text();
+	if (!response.ok) {
+		const classified = classifyProviderHttpError("gemini", response.status, text);
+		if (classified) throw classified;
+		throw new SearchProviderError("gemini", `Gemini API error (${response.status}): ${text}`, response.status);
+	}
+
+	const json = text ? JSON.parse(text) : {};
+	const candidate = json.candidates?.[0];
+	const grounding: GeminiGroundingMetadata | undefined = candidate?.groundingMetadata;
+	const answer = (candidate?.content?.parts ?? []).map((part: { text?: string }) => part.text ?? "").join("");
+
+	const sources: SearchSource[] = [];
+	const citations: SearchCitation[] = [];
+	const searchQueries: string[] = [];
+	const seenUrls = new Set<string>();
+	const chunks = grounding?.groundingChunks ?? [];
+	for (const grChunk of chunks) {
+		const uri = grChunk.web?.uri;
+		if (uri && !seenUrls.has(uri)) {
+			seenUrls.add(uri);
+			sources.push({ title: grChunk.web?.title ?? uri, url: uri });
+		}
+	}
+	for (const support of grounding?.groundingSupports ?? []) {
+		const citedText = support.segment?.text;
+		for (const idx of support.groundingChunkIndices ?? []) {
+			const uri = chunks[idx]?.web?.uri;
+			if (uri) citations.push({ url: uri, title: chunks[idx]?.web?.title ?? uri, citedText });
+		}
+	}
+	for (const q of grounding?.webSearchQueries ?? []) {
+		if (!searchQueries.includes(q)) searchQueries.push(q);
+	}
+
+	if (sources.length === 0) {
+		throw new SearchProviderError("gemini", "Gemini native search returned no grounding sources", 424);
+	}
+	const limit = params.numSearchResults ?? params.limit;
+	return {
+		provider: "gemini",
+		answer: answer || undefined,
+		sources: limit && sources.length > limit ? sources.slice(0, limit) : sources,
+		citations: citations.length > 0 ? citations : undefined,
+		searchQueries: searchQueries.length > 0 ? searchQueries : undefined,
+		model: json.modelVersion ?? model,
+	};
+}
+
 /** Search provider for Google Gemini web search. */
 export class GeminiProvider extends SearchProvider {
 	readonly id = "gemini";
@@ -438,6 +530,13 @@ export class GeminiProvider extends SearchProvider {
 	}
 
 	search(params: SearchParams): Promise<SearchResponse> {
+		// Native-over-proxy: when canonical gemini-cli/antigravity OAuth is
+		// absent but the active model speaks the Generative Language wire, reuse
+		// its own API key + baseUrl instead of failing closed.
+		const ctx = params.activeModelContext;
+		if (!hasGeminiOAuth(params.authStorage) && ctx?.api === "google-generative-ai") {
+			return searchGeminiViaGenerativeLanguage(params);
+		}
 		return searchGemini({
 			query: params.query,
 			system_prompt: params.systemPrompt,