@gajae-code/coding-agent 0.15.4 → 0.15.6

package/src/web/search/provider.ts

@@ -208,7 +208,15 @@ function chainCacheKey(
 		preferred ?? null,
 		fallbacks,
 		ctx
-			? [ctx.provider, ctx.modelId, ctx.wireModelId ?? null, ctx.api, ctx.baseUrl ?? null, ctx.webSearch ?? null]
+			? [
+					ctx.provider,
+					ctx.modelId,
+					ctx.wireModelId ?? null,
+					ctx.api,
+					ctx.baseUrl ?? null,
+					ctx.webSearch ?? null,
+					ctx.ownerAuthOverride ?? false,
+				]
 			: null,
 	]);
 }
@@ -278,7 +286,17 @@ function isAnthropicWire(api: string): boolean {
 }
 
 function isGoogleWire(api: string): boolean {
-	return api === "google-generative-ai" || api === "google-vertex" || api === "google-gemini-cli";
+	return (
+		api === "google-generative-ai" ||
+		api === "google-generative-language" ||
+		api === "gemini-wire" ||
+		api === "google-vertex" ||
+		api === "google-gemini-cli"
+	);
+}
+
+function isGenerativeLanguageWire(api: string): boolean {
+	return api === "google-generative-ai" || api === "google-generative-language" || api === "gemini-wire";
 }
 
 function isOpenAICompatWire(api: string): boolean {
@@ -305,6 +323,52 @@ function looksXaiFamilyModelId(ctx: ActiveSearchModelContext): boolean {
 	return looksXaiModelId(ctx.wireModelId) || looksXaiModelId(ctx.modelId);
 }
 
+const OFFICIAL_GEMINI_HOSTS = new Set([
+	"cloudcode-pa.googleapis.com",
+	"daily-cloudcode-pa.googleapis.com",
+	"daily-cloudcode-pa.sandbox.googleapis.com",
+	"generativelanguage.googleapis.com",
+]);
+
+function normalizedHost(baseUrl: string): string | undefined {
+	try {
+		return new URL(baseUrl).hostname.toLowerCase().replace(/^\[/, "").replace(/\]$/, "").replace(/\.$/, "");
+	} catch {
+		return undefined;
+	}
+}
+
+function isOfficialGeminiBaseUrl(baseUrl: string | undefined): boolean {
+	if (!baseUrl?.trim()) return true;
+	const host = normalizedHost(baseUrl);
+	return host !== undefined && OFFICIAL_GEMINI_HOSTS.has(host);
+}
+
+function isOfficialXaiBaseUrl(baseUrl: string | undefined): boolean {
+	if (!baseUrl?.trim()) return true;
+	return normalizedHost(baseUrl) === "api.x.ai";
+}
+
+const CANONICAL_GEMINI_PROVIDERS = new Set(["google", "gemini", "google-gemini-cli", "google-antigravity"]);
+
+function hasCustomGeminiSearchContext(ctx: ActiveSearchModelContext): boolean {
+	if (!isGoogleWire(ctx.api)) return false;
+	if (ctx.ownerAuthOverride) return true;
+	if (!isOfficialGeminiBaseUrl(ctx.baseUrl)) return true;
+	const provider = ctx.provider.toLowerCase();
+	return Boolean(ctx.resolveCredentials && !CANONICAL_GEMINI_PROVIDERS.has(provider));
+}
+
+function hasCustomXaiSearchContext(ctx: ActiveSearchModelContext): boolean {
+	if (!isOpenAICompatWire(ctx.api)) return false;
+	if (ctx.ownerAuthOverride) return true;
+	const provider = ctx.provider.toLowerCase();
+	if (provider === "xai" && !isOfficialXaiBaseUrl(ctx.baseUrl)) return true;
+	if (!looksXaiFamilyModelId(ctx)) return false;
+	if (!isOfficialXaiBaseUrl(ctx.baseUrl)) return true;
+	return provider !== "xai";
+}
+
 export function isLocalBaseUrl(baseUrl: string | undefined): boolean {
 	if (!baseUrl) return false;
 	let url: URL;
@@ -369,12 +433,29 @@ export function inferNativeProviderFromModel(ctx: ActiveSearchModelContext | und
 	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 (modelId.startsWith("gemini-") && isGoogleWire(ctx.api) && !hasCustomGeminiSearchContext(ctx)) return "gemini";
+	// A custom proxy may expose a Grok model through an OpenAI wire while the
+	// process also has canonical xAI credentials. Do not infer the canonical
+	// xAI provider from the model family: that would silently send the search to
+	// api.x.ai with another registry's credentials. Custom active contexts are
+	// dispatched below by activeContextNativeId, where the provider can consume
+	// the active owner-bound resolver instead.
+	if (
+		looksXaiFamilyModelId(ctx) &&
+		isOpenAICompatWire(ctx.api) &&
+		ctx.provider.toLowerCase() === "xai" &&
+		!hasCustomXaiSearchContext(ctx)
+	)
+		return "xai";
 	// `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)) {
+	// through to `activeContextNativeId` and reuse their own credentials.
+	if (
+		!ctx.ownerAuthOverride &&
+		looksOpenAIFamilyModelId(ctx) &&
+		isOpenAICompatWire(ctx.api) &&
+		isOpenAIOfficialBaseUrl(ctx.baseUrl)
+	) {
 		return "codex";
 	}
 	return undefined;
@@ -382,7 +463,10 @@ export function inferNativeProviderFromModel(ctx: ActiveSearchModelContext | und
 
 function canUseDirectProviderMapping(ctx: ActiveSearchModelContext, id: SearchProviderId): boolean {
 	if (ctx.webSearch === "off") return false;
+	if (id === "gemini" && hasCustomGeminiSearchContext(ctx)) return false;
+	if (id === "xai" && hasCustomXaiSearchContext(ctx)) return false;
 	if (id !== "codex") return true;
+	if (ctx.ownerAuthOverride) return false;
 	// 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);
@@ -395,6 +479,10 @@ export async function canUseGenericCredentials(
 	signal?: AbortSignal,
 ): Promise<boolean> {
 	if (!ctx) return false;
+	if (ctx.resolveCredentials) {
+		const resolved = await ctx.resolveCredentials({ sessionId, signal });
+		return Boolean(resolved.apiKey) || hasActiveCredentialHeader(resolved.headers);
+	}
 	const key = await authStorage.getApiKey(ctx.provider, sessionId, {
 		baseUrl: ctx.baseUrl,
 		modelId: ctx.modelId,
@@ -403,6 +491,13 @@ export async function canUseGenericCredentials(
 	return Boolean(key);
 }
 
+function hasActiveCredentialHeader(headers: Record<string, string> | undefined): boolean {
+	return Object.keys(headers ?? {}).some(key => {
+		const normalized = key.toLowerCase();
+		return normalized === "authorization" || normalized === "x-api-key" || normalized === "x-goog-api-key";
+	});
+}
+
 /**
  * Native web-search provider to attempt by reusing the ACTIVE model's own
  * credentials + baseUrl, dispatched by the model's wire protocol.
@@ -424,13 +519,20 @@ export function activeContextNativeId(ctx: ActiveSearchModelContext | 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.
+	// active credential: xAI-family models use the xAI search tools, 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 (isGenerativeLanguageWire(ctx.api) && modelId.startsWith("gemini-")) return "gemini";
+	if (
+		isOpenAICompatWire(ctx.api) &&
+		hasCustomXaiSearchContext(ctx) &&
+		(looksXaiFamilyModelId(ctx) || ctx.provider.toLowerCase() === "xai")
+	)
+		return "xai";
 	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;
 }
 
@@ -445,6 +547,13 @@ export async function resolveProviderChain(options: ResolveProviderChainOptions)
 		settings,
 	} = options;
 
+	// Resolve the active model before consulting the chain cache. The registry
+	// resolver refreshes rotating apiKeyEnv credentials and updates generated
+	// headers, which also advances AuthStorage's generation when credentials
+	// rotate or disappear.
+	if (preferredProvider === "auto" && activeModelContext?.resolveCredentials) {
+		await activeModelContext.resolveCredentials({ sessionId, signal });
+	}
 	const cacheKey = chainCacheKey(preferredProvider, fallbackProviders, activeModelContext, authStorage, settings);
 	const perStorage = chainCache.get(authStorage);
 	const now = Date.now();

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

@@ -18,6 +18,7 @@ import {
 } from "@gajae-code/ai/utils/anthropic-auth";
 import { $credentialEnv, $env } from "@gajae-code/utils";
 import type {
+	ActiveSearchModelCredentials,
 	AnthropicApiResponse,
 	AnthropicCitation,
 	SearchCitation,
@@ -73,6 +74,28 @@ function buildSystemBlocks(
 	});
 }
 
+function mergeHeadersPreservingExplicit(
+	baseHeaders: Record<string, string>,
+	explicitHeaders: Record<string, string> | undefined,
+): Record<string, string> {
+	const merged = { ...baseHeaders };
+	for (const [key, value] of Object.entries(explicitHeaders ?? {})) {
+		for (const existingKey of Object.keys(merged)) {
+			if (existingKey.toLowerCase() === key.toLowerCase()) delete merged[existingKey];
+		}
+		merged[key] = value;
+	}
+	return merged;
+}
+
+function explicitCredentialHeader(headers: Record<string, string> | undefined): string | undefined {
+	for (const [key, value] of Object.entries(headers ?? {})) {
+		const normalized = key.toLowerCase();
+		if (normalized === "authorization" || normalized === "x-api-key") return value;
+	}
+	return undefined;
+}
+
 /**
  * Calls the Anthropic API with web search tool enabled.
  * @param auth - Authentication configuration (API key or OAuth)
@@ -93,7 +116,7 @@ async function callSearch(
 	extraHeaders?: Record<string, string>,
 ): Promise<AnthropicApiResponse> {
 	const url = buildAnthropicUrl(auth);
-	const headers = { ...(extraHeaders ?? {}), ...buildAnthropicSearchHeaders(auth) };
+	const headers = mergeHeadersPreservingExplicit(buildAnthropicSearchHeaders(auth), extraHeaders);
 
 	const systemBlocks = buildSystemBlocks(auth, model, systemPrompt);
 
@@ -284,29 +307,78 @@ export async function searchAnthropic(
 	// 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);
-	} else if ("authStorage" in params) {
-		const apiKey = await params.authStorage.getApiKey("anthropic", params.sessionId, {
+	const activeContext = "authStorage" in params ? params.activeModelContext : undefined;
+	const activeSessionId = "authStorage" in params ? params.sessionId : undefined;
+	const activeCustomContext =
+		activeContext?.api === "anthropic-messages" &&
+		(activeContext.ownerAuthOverride || activeContext.provider.toLowerCase() !== "anthropic");
+
+	if (activeCustomContext && activeContext?.resolveCredentials) {
+		const activeCredentials = await activeContext.resolveCredentials({
+			sessionId: activeSessionId,
 			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,
+		const ctxKey =
+			activeCredentials.apiKey ?? explicitCredentialHeader(activeCredentials.headers ?? activeContext.headers);
+		if (ctxKey) {
+			auth = buildAnthropicAuthConfig(ctxKey, activeContext.baseUrl);
+			modelOverride = activeContext.wireModelId ?? activeContext.modelId;
+			extraHeaders = activeCredentials.headers ?? activeContext.headers;
+		}
+	} else if (searchApiKey) {
+		auth = buildAnthropicAuthConfig(searchApiKey, searchBaseUrl);
+	} else if ("authStorage" in params) {
+		const ctx = activeContext;
+		const resolveActiveCredentials = ctx?.resolveCredentials;
+		const activeAnthropicWire = ctx?.api === "anthropic-messages";
+		const activeModelOwnsProvider =
+			ctx !== undefined &&
+			resolveActiveCredentials !== undefined &&
+			activeAnthropicWire &&
+			ctx.provider.toLowerCase() === "anthropic";
+		const activeCustomModel =
+			ctx !== undefined &&
+			resolveActiveCredentials !== undefined &&
+			activeAnthropicWire &&
+			ctx.provider.toLowerCase() !== "anthropic";
+		if (activeModelOwnsProvider || activeCustomModel) {
+			const activeCredentials: ActiveSearchModelCredentials = await resolveActiveCredentials({
+				sessionId: params.sessionId,
 				signal: params.signal,
 			});
+			const ctxKey = activeCredentials.apiKey ?? explicitCredentialHeader(activeCredentials.headers ?? ctx.headers);
 			if (ctxKey) {
 				auth = buildAnthropicAuthConfig(ctxKey, ctx.baseUrl);
 				modelOverride = ctx.wireModelId ?? ctx.modelId;
-				extraHeaders = ctx.headers;
+				extraHeaders = activeCredentials.headers ?? ctx.headers;
+			}
+		} else {
+			const apiKey = await params.authStorage.getApiKey("anthropic", params.sessionId, {
+				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).
+			if (!auth && ctx && ctx.api === "anthropic-messages") {
+				const activeCredentials: ActiveSearchModelCredentials = ctx.resolveCredentials
+					? await ctx.resolveCredentials({ sessionId: params.sessionId, signal: params.signal })
+					: {
+							apiKey: await params.authStorage.getApiKey(ctx.provider, params.sessionId, {
+								baseUrl: ctx.baseUrl,
+								modelId: ctx.modelId,
+								signal: params.signal,
+							}),
+							headers: ctx.headers,
+						};
+				const ctxKey =
+					activeCredentials.apiKey ?? explicitCredentialHeader(activeCredentials.headers ?? ctx.headers);
+				if (ctxKey) {
+					auth = buildAnthropicAuthConfig(ctxKey, ctx.baseUrl);
+					modelOverride = ctx.wireModelId ?? ctx.modelId;
+					extraHeaders = activeCredentials.headers ?? ctx.headers;
+				}
 			}
 		}
 	}

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

@@ -20,7 +20,10 @@ export const SEARXNG_BEARER_CREDENTIAL_PREFIX = "gjc-searxng-bearer:";
 /**
  * Shared web search parameters passed to providers.
  *
- * `authStorage` is the **only** credential source providers may consult.
+ * `authStorage` is the credential source for canonical providers. Native
+ * active-model search may instead use `activeModelContext.resolveCredentials`,
+ * which is supplied by ModelRegistry so rotating config credentials and
+ * generated headers are refreshed before the request.
  * Opening a sibling SQLite handle or calling provider-direct refresh helpers
  * (e.g. `refreshOpenAIOpenAI code backendToken`, `refreshGoogleCloudToken`) is prohibited:
  * it races the broker's per-credential refresh and POSTs the broker sentinel
@@ -75,8 +78,8 @@ export interface SearchParams {
 	codeExecution?: Record<string, unknown>;
 	urlContext?: Record<string, unknown>;
 	/**
-	 * The single source of truth for credentials. Providers MUST consult this
-	 * handle exclusively (`getApiKey` for bearer-style auth, `getOAuthAccess`
+	 * The canonical source of truth for credentials. Providers MUST consult this
+	 * handle (`getApiKey` for bearer-style auth, `getOAuthAccess`
 	 * when identity metadata is required). Do not open `AgentStorage` or any
 	 * `AuthCredentialStore` directly — that bypasses the broker pipeline and
 	 * the per-credential single-flight refresh.
@@ -108,7 +111,9 @@ export abstract class SearchProvider {
 	abstract isAvailable(authStorage: AuthStorage, settings?: SearchProviderSettings): Promise<boolean> | boolean;
 
 	/**
-	 * Execute a search. Credentials MUST be resolved through `params.authStorage`.
+	 * Execute a search. Canonical credentials MUST be resolved through
+	 * `params.authStorage`; active-model credentials MUST use the injected
+	 * resolver when one is present.
 	 */
 	abstract search(params: SearchParams): Promise<SearchResponse>;
 }

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

@@ -16,7 +16,13 @@ import {
 } from "@gajae-code/ai/providers/google-gemini-headers";
 import { fetchWithRetry } from "@gajae-code/utils";
 
-import type { SearchCitation, SearchResponse, SearchSource } from "../../../web/search/types";
+import type {
+	ActiveSearchModelContext,
+	ActiveSearchModelCredentials,
+	SearchCitation,
+	SearchResponse,
+	SearchSource,
+} from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -38,6 +44,49 @@ const RATE_LIMIT_BUDGET_MS = 30 * 1000;
 const GEMINI_PROVIDERS = ["google-gemini-cli", "google-antigravity"] as const;
 type GeminiProviderId = (typeof GEMINI_PROVIDERS)[number];
 
+function isGenerativeLanguageWire(api: string): boolean {
+	return api === "google-generative-ai" || api === "google-generative-language" || api === "gemini-wire";
+}
+
+function isGoogleWire(api: string): boolean {
+	return isGenerativeLanguageWire(api) || api === "google-gemini-cli" || api === "google-vertex";
+}
+
+const OFFICIAL_GEMINI_HOSTS = new Set([
+	"cloudcode-pa.googleapis.com",
+	"daily-cloudcode-pa.googleapis.com",
+	"daily-cloudcode-pa.sandbox.googleapis.com",
+	"generativelanguage.googleapis.com",
+]);
+const CANONICAL_GEMINI_PROVIDERS = new Set(["google", "gemini", "google-gemini-cli", "google-antigravity"]);
+
+function isOfficialGeminiBaseUrl(baseUrl: string | undefined): boolean {
+	if (!baseUrl?.trim()) return true;
+	try {
+		const host = new URL(baseUrl).hostname.toLowerCase().replace(/^\[/, "").replace(/\]$/, "").replace(/\.$/, "");
+		return OFFICIAL_GEMINI_HOSTS.has(host);
+	} catch {
+		return false;
+	}
+}
+
+function isCustomGeminiContext(ctx: ActiveSearchModelContext | undefined): boolean {
+	if (!ctx || !isGoogleWire(ctx.api)) return false;
+	if (ctx.ownerAuthOverride) return true;
+	if (!isOfficialGeminiBaseUrl(ctx.baseUrl)) return true;
+	const provider = ctx.provider.toLowerCase();
+	return Boolean(ctx.resolveCredentials && !CANONICAL_GEMINI_PROVIDERS.has(provider));
+}
+
+function isCustomGenerativeLanguageContext(ctx: ActiveSearchModelContext | undefined): boolean {
+	return isGenerativeLanguageWire(ctx?.api ?? "") && isCustomGeminiContext(ctx);
+}
+
+function hasHeader(headers: Record<string, string>, name: string): boolean {
+	const normalized = name.toLowerCase();
+	return Object.keys(headers).some(key => key.toLowerCase() === normalized);
+}
+
 interface GeminiToolParams {
 	google_search?: Record<string, unknown>;
 	code_execution?: Record<string, unknown>;
@@ -433,19 +482,28 @@ 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.
+ * for Generative Language wire models. 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 activeCredentials: ActiveSearchModelCredentials = ctx.resolveCredentials
+		? await ctx.resolveCredentials({ sessionId: params.sessionId, signal: params.signal })
+		: {
+				apiKey: await params.authStorage.getApiKey(ctx.provider, params.sessionId, {
+					baseUrl: ctx.baseUrl,
+					modelId: ctx.modelId,
+					signal: params.signal,
+				}),
+				headers: ctx.headers,
+			};
+	const apiKey = activeCredentials.apiKey;
+	const headers = { ...(activeCredentials.headers ?? ctx.headers ?? {}) };
+	if (apiKey && !hasHeader(headers, "x-goog-api-key")) headers["x-goog-api-key"] = apiKey;
+	if (!apiKey && !hasHeader(headers, "x-goog-api-key")) {
+		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(/\/+$/, "");
@@ -468,7 +526,10 @@ async function searchGeminiViaGenerativeLanguage(params: SearchParams): Promise<
 
 	const response = await fetch(url, {
 		method: "POST",
-		headers: { ...(ctx.headers ?? {}), "x-goog-api-key": apiKey, "Content-Type": "application/json" },
+		headers: {
+			...headers,
+			...(hasHeader(headers, "content-type") ? {} : { "Content-Type": "application/json" }),
+		},
 		body: JSON.stringify(body),
 		signal: withHardTimeout(params.signal, "llm"),
 	});
@@ -534,11 +595,22 @@ 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") {
+		// Native-over-proxy: a custom model's owner-bound resolver must win over
+		// canonical Gemini OAuth. Otherwise the request would silently leave the
+		// proxy and hit Cloud Code with another registry's identity.
+		if (isCustomGeminiContext(ctx)) {
+			if (isCustomGenerativeLanguageContext(ctx)) return searchGeminiViaGenerativeLanguage(params);
+			return Promise.reject(
+				new SearchProviderError(
+					"gemini",
+					`Gemini native search does not support custom ${ctx?.api ?? ""} transports`,
+					400,
+				),
+			);
+		}
+		// Preserve the existing active-key fallback when canonical OAuth is absent.
+		if (!hasGeminiOAuth(params.authStorage) && ctx && isGenerativeLanguageWire(ctx.api)) {
 			return searchGeminiViaGenerativeLanguage(params);
 		}
 		return searchGemini({

package/src/web/search/providers/openai-compatible.ts

@@ -1,4 +1,4 @@
-import type { SearchCitation, SearchResponse, SearchSource } from "../types";
+import type { ActiveSearchModelCredentials, SearchCitation, SearchResponse, SearchSource } from "../types";
 import { SearchProviderError } from "../types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -7,6 +7,11 @@ import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 type JsonObject = Record<string, unknown>;
 
+function hasHeader(headers: Record<string, string>, name: string): boolean {
+	const normalized = name.toLowerCase();
+	return Object.keys(headers).some(key => key.toLowerCase() === normalized);
+}
+
 function isJsonObject(value: unknown): value is JsonObject {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -154,15 +159,25 @@ export class OpenAICompatibleSearchProvider extends SearchProvider {
 		if (ctx.api !== "openai-responses" && ctx.api !== "openai-completions") {
 			throw new SearchProviderError(this.id, `OpenAI-compatible web search does not support ${ctx.api}`, 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(this.id, `No credentials for ${ctx.provider}`, 401);
+		const activeCredentials: ActiveSearchModelCredentials = ctx.resolveCredentials
+			? await ctx.resolveCredentials({ sessionId: params.sessionId, signal: params.signal })
+			: {
+					apiKey: await params.authStorage.getApiKey(ctx.provider, params.sessionId, {
+						baseUrl: ctx.baseUrl,
+						modelId: ctx.modelId,
+						signal: params.signal,
+					}),
+					headers: ctx.headers,
+				};
+		const apiKey = activeCredentials.apiKey;
+		const headers = { ...(activeCredentials.headers ?? ctx.headers ?? {}) };
+		if (apiKey && !hasHeader(headers, "authorization")) headers.Authorization = `Bearer ${apiKey}`;
+		if (!hasHeader(headers, "authorization")) {
+			throw new SearchProviderError(this.id, `No credentials for ${ctx.provider}`, 401);
+		}
+		if (!hasHeader(headers, "content-type")) headers["Content-Type"] = "application/json";
 		const model = ctx.wireModelId ?? ctx.modelId;
 		const baseUrl = ctx.baseUrl ?? "";
-		const headers = { ...(ctx.headers ?? {}), Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" };
 		const messages = [
 			{ role: "system", content: params.systemPrompt },
 			{ role: "user", content: params.query },