@gajae-code/coding-agent 0.15.5 → 0.16.0

package/src/tools/gh.ts

@@ -2806,6 +2806,14 @@ export interface PrDiffFile {
 	changeType: "modified" | "added" | "deleted" | "renamed" | "binary";
 	/** Pre-image path for renames/deletes; same as `path` otherwise. */
 	oldPath?: string;
+	/**
+	 * Set when `path` kept its C-style escaped source form because the quoted
+	 * token held invalid UTF-8 or a malformed escape; distinguishes it from a
+	 * valid path whose decoded text looks identical.
+	 */
+	pathEscaped?: boolean;
+	/** Same as {@link PrDiffFile.pathEscaped}, for `oldPath`. */
+	oldPathEscaped?: boolean;
 	/** Byte offset of the section's `diff --git` line in the unified diff. */
 	startOffset: number;
 	/** Byte offset of the next section (or end-of-text). */
@@ -2861,6 +2869,8 @@ export function parsePrUnifiedDiff(text: string): PrDiffPayload {
 interface ParsedDiffHeaderToken {
 	value: string;
 	nextIndex: number;
+	/** Set when the token kept its C-style escaped source form. */
+	escaped?: boolean;
 }
 
 function skipDiffHeaderSpaces(text: string, index: number): number {
@@ -2869,63 +2879,87 @@ function skipDiffHeaderSpaces(text: string, index: number): number {
 	return i;
 }
 
-function parseDiffQuotedEscape(text: string, slashIndex: number): ParsedDiffHeaderToken {
-	const next = text.charAt(slashIndex + 1);
-	if (next === "") return { value: "\\", nextIndex: slashIndex + 1 };
+interface ParsedDiffQuotedEscape {
+	byte: number;
+	nextIndex: number;
+}
 
-	if (next >= "0" && next <= "7") {
-		let end = slashIndex + 1;
-		while (end < text.length && end < slashIndex + 4) {
-			const digit = text.charAt(end);
-			if (digit < "0" || digit > "7") break;
-			end += 1;
-		}
-		return {
-			value: String.fromCharCode(Number.parseInt(text.slice(slashIndex + 1, end), 8)),
-			nextIndex: end,
-		};
-	}
+const DIFF_PATH_ENCODER = new TextEncoder();
+const DIFF_PATH_DECODER = new TextDecoder("utf-8", { fatal: true });
 
-	switch (next) {
-		case "a":
-			return { value: "\x07", nextIndex: slashIndex + 2 };
-		case "b":
-			return { value: "\b", nextIndex: slashIndex + 2 };
-		case "f":
-			return { value: "\f", nextIndex: slashIndex + 2 };
-		case "n":
-			return { value: "\n", nextIndex: slashIndex + 2 };
-		case "r":
-			return { value: "\r", nextIndex: slashIndex + 2 };
-		case "t":
-			return { value: "\t", nextIndex: slashIndex + 2 };
-		case "v":
-			return { value: "\v", nextIndex: slashIndex + 2 };
-		case "\\":
-		case '"':
-			return { value: next, nextIndex: slashIndex + 2 };
-		default:
-			return { value: next, nextIndex: slashIndex + 2 };
+const DIFF_NAMED_ESCAPE_BYTES: Record<string, number> = {
+	a: 0x07,
+	b: 0x08,
+	f: 0x0c,
+	n: 0x0a,
+	r: 0x0d,
+	t: 0x09,
+	v: 0x0b,
+	"\\": 0x5c,
+	'"': 0x22,
+};
+
+/**
+ * Git quotes paths C-style: its named escapes plus exactly three octal digits
+ * per byte (leading digit 0-3), so a multi-byte UTF-8 character arrives as
+ * consecutive octal escapes. Anything else is malformed for this grammar.
+ */
+function parseDiffQuotedEscape(text: string, slashIndex: number): ParsedDiffQuotedEscape | undefined {
+	const first = text.charAt(slashIndex + 1);
+	if (first >= "0" && first <= "3") {
+		const second = text.charAt(slashIndex + 2);
+		const third = text.charAt(slashIndex + 3);
+		if (second < "0" || second > "7" || third < "0" || third > "7") return undefined;
+		return { byte: Number.parseInt(text.slice(slashIndex + 1, slashIndex + 4), 8), nextIndex: slashIndex + 4 };
 	}
+	const named = DIFF_NAMED_ESCAPE_BYTES[first];
+	if (named === undefined) return undefined;
+	return { byte: named, nextIndex: slashIndex + 2 };
 }
 
+/**
+ * Escaped bytes are decoded as strict UTF-8. A token holding invalid UTF-8 or
+ * a malformed escape keeps its escaped source form, so distinct non-UTF-8
+ * byte sequences never collapse into one replacement-character path.
+ */
 function parseDiffQuotedToken(text: string, startIndex: number): ParsedDiffHeaderToken | undefined {
 	if (text.charAt(startIndex) !== '"') return undefined;
-	let value = "";
-	for (let i = startIndex + 1; i < text.length; i += 1) {
-		const ch = text.charAt(i);
-		if (ch === '"') return { value, nextIndex: i + 1 };
+	const bytes: number[] = [];
+	let malformed = false;
+	for (let i = startIndex + 1; i < text.length; ) {
+		const codePoint = text.codePointAt(i) as number;
+		const ch = String.fromCodePoint(codePoint);
+		if (ch === '"') {
+			if (!malformed) {
+				try {
+					return { value: DIFF_PATH_DECODER.decode(Uint8Array.from(bytes)), nextIndex: i + 1 };
+				} catch {}
+			}
+			return { value: text.slice(startIndex + 1, i), nextIndex: i + 1, escaped: true };
+		}
 		if (ch !== "\\") {
-			value += ch;
+			bytes.push(...DIFF_PATH_ENCODER.encode(ch));
+			i += ch.length;
 			continue;
 		}
 		const escaped = parseDiffQuotedEscape(text, i);
-		value += escaped.value;
-		i = escaped.nextIndex - 1;
+		if (escaped === undefined) {
+			malformed = true;
+			i += 2;
+			continue;
+		}
+		bytes.push(escaped.byte);
+		i = escaped.nextIndex;
 	}
 	return undefined;
 }
 
+function parseDiffPathLine(line: string, prefix: string): { value: string; escaped?: boolean } {
+	const rest = line.slice(prefix.length);
+	const token = parseDiffQuotedToken(rest, 0);
+	return token ? { value: token.value, escaped: token.escaped } : { value: rest };
+}
+
 function parseDiffHeaderToken(text: string, startIndex: number): ParsedDiffHeaderToken | undefined {
 	const start = skipDiffHeaderSpaces(text, startIndex);
 	if (start >= text.length) return undefined;
@@ -2940,7 +2974,14 @@ function stripPrDiffPathPrefix(value: string, prefix: "a/" | "b/"): string | und
 	return value.startsWith(prefix) ? value.slice(prefix.length) : undefined;
 }
 
-function parsePrDiffHeaderPaths(header: string): { oldPath?: string; newPath?: string } {
+interface PrDiffHeaderPaths {
+	oldPath?: string;
+	newPath?: string;
+	oldPathEscaped?: boolean;
+	newPathEscaped?: boolean;
+}
+
+function parsePrDiffHeaderPaths(header: string): PrDiffHeaderPaths {
 	const trail = header.slice("diff --git ".length);
 	if (trail.startsWith('"')) {
 		const oldToken = parseDiffQuotedToken(trail, 0);
@@ -2950,6 +2991,8 @@ function parsePrDiffHeaderPaths(header: string): { oldPath?: string; newPath?: s
 		return {
 			oldPath: stripPrDiffPathPrefix(oldToken.value, "a/"),
 			newPath: stripPrDiffPathPrefix(newToken.value, "b/"),
+			oldPathEscaped: oldToken.escaped,
+			newPathEscaped: newToken.escaped,
 		};
 	}
 
@@ -2980,6 +3023,8 @@ function parsePrDiffSection(section: string, startOffset: number, endOffset: num
 	const headerPaths = parsePrDiffHeaderPaths(header);
 	let oldPath = headerPaths.oldPath;
 	let newPath = headerPaths.newPath;
+	let oldPathEscaped = headerPaths.oldPathEscaped;
+	let newPathEscaped = headerPaths.newPathEscaped;
 
 	let changeType: PrDiffFile["changeType"] = "modified";
 	let isBinary = false;
@@ -2999,11 +3044,11 @@ function parsePrDiffSection(section: string, startOffset: number, endOffset: num
 		}
 		if (line.startsWith("rename from ")) {
 			changeType = "renamed";
-			oldPath = line.slice("rename from ".length);
+			({ value: oldPath, escaped: oldPathEscaped } = parseDiffPathLine(line, "rename from "));
 			continue;
 		}
 		if (line.startsWith("rename to ")) {
-			newPath = line.slice("rename to ".length);
+			({ value: newPath, escaped: newPathEscaped } = parseDiffPathLine(line, "rename to "));
 			continue;
 		}
 		if (line.startsWith("Binary files ") && line.endsWith(" differ")) {
@@ -3028,8 +3073,15 @@ function parsePrDiffSection(section: string, startOffset: number, endOffset: num
 		deletions = 0;
 	}
 
-	const displayPath =
-		changeType === "deleted" ? (oldPath ?? newPath ?? "(unknown)") : (newPath ?? oldPath ?? "(unknown)");
+	const preferOld = changeType === "deleted";
+	const displayPath = preferOld ? (oldPath ?? newPath ?? "(unknown)") : (newPath ?? oldPath ?? "(unknown)");
+	const displayEscaped = preferOld
+		? oldPath !== undefined
+			? oldPathEscaped
+			: newPathEscaped
+		: newPath !== undefined
+			? newPathEscaped
+			: oldPathEscaped;
 	const file: PrDiffFile = {
 		path: displayPath,
 		additions,
@@ -3038,8 +3090,12 @@ function parsePrDiffSection(section: string, startOffset: number, endOffset: num
 		startOffset,
 		endOffset,
 	};
-	if (oldPath && oldPath !== displayPath) {
+	if (displayEscaped) {
+		file.pathEscaped = true;
+	}
+	if (oldPath && (oldPath !== displayPath || oldPathEscaped !== displayEscaped)) {
 		file.oldPath = oldPath;
+		if (oldPathEscaped) file.oldPathEscaped = true;
 	}
 	return file;
 }

package/src/tools/github-cache.ts

@@ -103,7 +103,7 @@ export function openDb(): Database | null {
 		// than running an in-place ALTER dance.
 		const userVersion = (db.prepare("PRAGMA user_version").get() as { user_version?: number } | undefined)
 			?.user_version;
-		if (userVersion !== undefined && userVersion < 3) {
+		if (userVersion !== undefined && userVersion < 4) {
 			db.run("DROP TABLE IF EXISTS github_view_cache");
 		}
 		db.run(`
@@ -120,7 +120,7 @@ export function openDb(): Database | null {
 				PRIMARY KEY (auth_key, repo, kind, number, include_comments)
 			);
 			CREATE INDEX IF NOT EXISTS idx_github_view_cache_fetched ON github_view_cache(fetched_at);
-			PRAGMA user_version = 3;
+			PRAGMA user_version = 4;
 		`);
 		protectDbFiles(dbPath);
 		cachedDb = db;

package/src/tools/index.ts

@@ -17,6 +17,7 @@ import type {
 } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { ClientBridge } from "../session/client-bridge";
+import type { FoldAdapter } from "../session/fold-coordinator";
 import type { CustomMessage } from "../session/messages";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
 import type { SkillActiveEntry } from "../skill-state/active-state";
@@ -235,12 +236,13 @@ export interface ToolSession {
 	assertEvalExecutionAllowed?: () => void;
 	/** Track tool-owned eval work so session disposal can await/abort it like direct session eval runs. */
 	trackEvalExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
-	/** Register a safe request handler that asks a managed foreground bash call to fold into a background job. */
-	registerForegroundBashBackgroundRequestHandler?: (handler: () => void) => () => void;
-	/** Whether a managed foreground bash call is currently foldable into a background job. */
+	/** Register a foldable foreground wait so the fold chord can move it into a background job. */
+	registerForegroundFoldParticipant?: (adapter: FoldAdapter) => () => void;
+	/** Whether a foreground wait is currently foldable into a background job. */
 	hasForegroundBashBackgroundRequestHandler?: () => boolean;
-	/** Request that the active managed foreground bash call fold into a background job, if supported. */
-	requestForegroundBashBackground?: () => boolean;
+	/** Request that the active foreground wait fold into a background job, if supported. */
+	requestForegroundBashBackground?: () => Promise<boolean>;
+
 	/** Get the session-owned or inherited async job manager. */
 	getAsyncJobManager?: () => AsyncJobManager | undefined;
 	/** Resolves when the session queues user steering (or `signal` aborts) without consuming it; wait-style tools use this to end their observation early. */
@@ -269,6 +271,10 @@ export interface ToolSession {
 	bashAllowedPrefixes?: string[];
 	/** Restriction policy for sessions that deliberately expose a narrow bash surface. */
 	bashRestrictionProfile?: BashRestrictionProfile;
+	/** Process-local master capability injected into direct Bash children only. */
+	getMasterBashCapability?: () => string | undefined;
+	/** Stable master lineage identity used across session switches and branches. */
+	getMasterOwnerSessionId?: () => string | undefined;
 	/** Optional per-session allowlist for tools exposed through search_tool_bm25. */
 	discoverableToolAllowedNames?: readonly string[];
 	/** Throw instead of warn when toolNames contains an unknown name. */

package/src/tools/tool-catalog.generated.ts

@@ -2319,7 +2319,7 @@ export const TOOL_CATALOG: Readonly<Record<string, ToolCatalogEntry>> = {
 	"job": {
 		"name": "job",
 		"label": "Job",
-		"description": "Inspects, waits, or cancels async jobs.\n\nBackground job results are delivered automatically when complete. Jobs that back task subagents should be controlled via the `subagent` tool when it is available; use `job` for non-subagent jobs (async bash, monitors) and as a compatibility fallback. Running job output stays quiet by default to avoid flooding the conversation; use `tail` when you explicitly want to show/reopen retained output. Reach for this tool only when you need to inspect or intervene.\n\nIn the interactive TUI, supported managed foreground bash can be folded into a background job by pressing `Ctrl+B` twice while it is running. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.\n\n# Operations\n\n## `list: true`\nUse to inspect what's running.\n\n## `tail: [id, …]`\nShow the retained output buffer for one or more background jobs without waiting.\n- Use this to reopen/tail a backgrounded long-running bash/tool output after folding it away.\n- Output is bounded by the manager retention window; stale cursors may report that only the retained tail is available.\n- Prefer `tail` over polling when you only need to peek at progress, so the conversation can continue without flooding the TUI.\n\n## `poll: [id, …]`\nBlock until the specified jobs finish or the wait window (~30 s, not configurable) elapses.\n- Use when you are genuinely blocked on a result and have no other work to do.\n- Returns the current snapshot when the timer elapses; running jobs remain running.\n- Completed jobs include their final output in the returned snapshot.\n\n## `cancel: [id, …]`\nStop running jobs.\n- Use when a job is stalled, hung, or no longer needed.\n- Returns immediately after cancelling.",
+		"description": "Inspects, waits, or cancels async jobs.\n\nBackground job results are delivered automatically when complete. Jobs that back task subagents should be controlled via the `subagent` tool when it is available; use `job` for non-subagent jobs (async bash, monitors) and as a compatibility fallback. Running job output stays quiet by default to avoid flooding the conversation; use `tail` when you explicitly want to show/reopen retained output. Reach for this tool only when you need to inspect or intervene.\n\nIn the interactive TUI, a running foreground command can be folded into a background job by pressing the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via `app.tool.backgroundFold`). This covers managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded job keeps its original deadline, is never killed or restarted by folding, and its result wakes a later turn automatically; a folded PTY continues output-only and no longer accepts input. `task`/`subagent` waits are not foldable. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.\n\n# Operations\n\n## `list: true`\nUse to inspect what's running.\n\n## `tail: [id, …]`\nShow the retained output buffer for one or more background jobs without waiting.\n- Use this to reopen/tail a backgrounded long-running bash/tool output after folding it away.\n- Output is bounded by the manager retention window; stale cursors may report that only the retained tail is available.\n- Prefer `tail` over polling when you only need to peek at progress, so the conversation can continue without flooding the TUI.\n\n## `poll: [id, …]`\nBlock until the specified jobs finish or the wait window (~30 s, not configurable) elapses.\n- Use when you are genuinely blocked on a result and have no other work to do.\n- Returns the current snapshot when the timer elapses; running jobs remain running.\n- Completed jobs include their final output in the returned snapshot.\n\n## `cancel: [id, …]`\nStop running jobs.\n- Use when a job is stalled, hung, or no longer needed.\n- Returns immediately after cancelling.",
 		"parameters": {
 			"type": "object",
 			"properties": {

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;
+				}
 			}
 		}
 	}