@gajae-code/coding-agent 0.15.5 → 0.15.6

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

@@ -6,7 +6,14 @@
  */
 import type { AuthStorage } from "@gajae-code/ai/core";
 import { $credentialEnv, $env } from "@gajae-code/utils";
-import type { SearchCitation, SearchResponse, SearchSource, SearchUsage } from "../../../web/search/types";
+import type {
+	ActiveSearchModelContext,
+	ActiveSearchModelCredentials,
+	SearchCitation,
+	SearchResponse,
+	SearchSource,
+	SearchUsage,
+} from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
@@ -49,11 +56,13 @@ export interface XaiSearchParams {
 	signal?: AbortSignal;
 	authStorage: AuthStorage;
 	sessionId?: string;
+	activeModelContext?: ActiveSearchModelContext;
 }
 
 interface XaiAuth {
 	bearer: string;
 	mode: "api_key" | "oauth";
+	headers?: Record<string, string>;
 }
 
 interface PreparedXaiTools {
@@ -67,7 +76,53 @@ function asTrimmed(value: string | undefined): string | undefined {
 	return trimmed.length > 0 ? trimmed : undefined;
 }
 
-function getModel(): string {
+function isOpenAICompatWire(api: string): boolean {
+	return api === "openai-responses" || api === "openai-completions";
+}
+
+function looksXaiModelId(modelId: string | undefined): boolean {
+	if (!modelId) return false;
+	const id = modelId.toLowerCase();
+	return id.startsWith("grok-") || id.startsWith("x-ai/grok-") || id.startsWith("xai/grok-");
+}
+
+function isOfficialXaiBaseUrl(baseUrl: string | undefined): boolean {
+	if (!baseUrl?.trim()) return true;
+	try {
+		return new URL(baseUrl).hostname.toLowerCase().replace(/\.$/, "") === "api.x.ai";
+	} catch {
+		return false;
+	}
+}
+
+function isCustomXaiContext(ctx: ActiveSearchModelContext | undefined): ctx is ActiveSearchModelContext {
+	if (!ctx || !isOpenAICompatWire(ctx.api)) return false;
+	if (ctx.ownerAuthOverride) return true;
+	const provider = ctx.provider.toLowerCase();
+	if (provider === "xai" && !isOfficialXaiBaseUrl(ctx.baseUrl)) return true;
+	if (!looksXaiModelId(ctx.wireModelId) && !looksXaiModelId(ctx.modelId)) return false;
+	if (!isOfficialXaiBaseUrl(ctx.baseUrl)) return true;
+	return provider !== "xai";
+}
+
+function hasHeader(headers: Record<string, string>, name: string): boolean {
+	const normalized = name.toLowerCase();
+	return Object.keys(headers).some(key => key.toLowerCase() === normalized);
+}
+
+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;
+}
+
+function getModel(activeModelContext?: ActiveSearchModelContext): string {
+	const ctx = activeModelContext;
+	if (isCustomXaiContext(ctx)) {
+		return ctx.wireModelId ?? ctx.modelId;
+	}
 	return asTrimmed($env.PI_XAI_WEB_SEARCH_MODEL) ?? asTrimmed($env.XAI_WEB_SEARCH_MODEL) ?? DEFAULT_MODEL;
 }
 
@@ -76,12 +131,14 @@ export function resolveXaiSearchBaseUrlForTest(): string {
 	return getBaseUrl();
 }
 
-function getBaseUrl(): string {
+function getBaseUrl(activeModelContext?: ActiveSearchModelContext): string {
+	const ctx = activeModelContext;
+	if (isCustomXaiContext(ctx) && ctx.baseUrl) return ctx.baseUrl;
 	return asTrimmed($credentialEnv("XAI_SEARCH_BASE_URL")) ?? DEFAULT_BASE_URL;
 }
 
-function responsesEndpoint(): string {
-	return `${getBaseUrl().replace(/\/+$/, "")}/responses`;
+function responsesEndpoint(activeModelContext?: ActiveSearchModelContext): string {
+	return `${getBaseUrl(activeModelContext).replace(/\/+$/, "")}/responses`;
 }
 
 async function resolveXaiAuth(
@@ -89,7 +146,26 @@ async function resolveXaiAuth(
 	sessionId: string | undefined,
 	model: string,
 	signal: AbortSignal | undefined,
+	activeModelContext?: ActiveSearchModelContext,
 ): Promise<XaiAuth | null> {
+	const ctx = activeModelContext;
+	if (isCustomXaiContext(ctx)) {
+		const activeCredentials: ActiveSearchModelCredentials = ctx.resolveCredentials
+			? await ctx.resolveCredentials({ sessionId, signal })
+			: {
+					apiKey: await authStorage.getApiKey(ctx.provider, sessionId, {
+						baseUrl: ctx.baseUrl,
+						modelId: ctx.modelId,
+						signal,
+					}),
+					headers: ctx.headers,
+				};
+		const headers = { ...(activeCredentials.headers ?? ctx.headers ?? {}) };
+		const bearer = activeCredentials.apiKey ?? explicitCredentialHeader(headers);
+		if (!bearer) return null;
+		return { bearer, mode: "api_key", headers };
+	}
+
 	const credentialSessionId = sessionId ?? `xai-search:${crypto.randomUUID()}`;
 	const bearer = await authStorage.getApiKey("xai", credentialSessionId, {
 		baseUrl: getBaseUrl(),
@@ -409,8 +485,14 @@ function parseUsage(json: any): SearchUsage | undefined {
 
 /** Execute xAI web/X search through the Responses API search tools. */
 export async function searchXai(params: XaiSearchParams): Promise<SearchResponse> {
-	const model = getModel();
-	const auth = await resolveXaiAuth(params.authStorage, params.sessionId, model, params.signal);
+	const model = getModel(params.activeModelContext);
+	const auth = await resolveXaiAuth(
+		params.authStorage,
+		params.sessionId,
+		model,
+		params.signal,
+		params.activeModelContext,
+	);
 	if (!auth) {
 		throw new SearchProviderError(
 			"xai",
@@ -419,12 +501,15 @@ export async function searchXai(params: XaiSearchParams): Promise<SearchResponse
 		);
 	}
 
-	const response = await fetch(responsesEndpoint(), {
+	const headers = { ...(auth.headers ?? {}) };
+	if (!hasHeader(headers, "authorization") && !hasHeader(headers, "x-api-key")) {
+		headers.Authorization = `Bearer ${auth.bearer}`;
+	}
+	if (!hasHeader(headers, "content-type")) headers["Content-Type"] = "application/json";
+
+	const response = await fetch(responsesEndpoint(params.activeModelContext), {
 		method: "POST",
-		headers: {
-			Authorization: `Bearer ${auth.bearer}`,
-			"Content-Type": "application/json",
-		},
+		headers,
 		body: JSON.stringify(
 			buildXaiRequestBody({
 				query: params.query,
@@ -511,6 +596,7 @@ export class XaiProvider extends SearchProvider {
 			signal: params.signal,
 			authStorage: params.authStorage,
 			sessionId: params.sessionId,
+			activeModelContext: params.activeModelContext,
 		});
 	}
 }

package/src/web/search/types.ts

@@ -27,6 +27,18 @@ export type SearchProviderId =
 
 export type WebSearchMode = "on" | "off" | "auto";
 
+/** Credentials and request headers resolved for the active model. */
+export interface ActiveSearchModelCredentials {
+	apiKey?: string;
+	headers?: Record<string, string>;
+}
+
+/** Refresh-aware resolver supplied by the model registry for native search. */
+export type ActiveSearchModelCredentialResolver = (options: {
+	sessionId?: string;
+	signal?: AbortSignal;
+}) => Promise<ActiveSearchModelCredentials>;
+
 export interface ActiveSearchModelContext {
 	provider: string;
 	modelId: string;
@@ -34,6 +46,10 @@ export interface ActiveSearchModelContext {
 	api: string;
 	baseUrl?: string;
 	headers?: Record<string, string>;
+	/** Resolve the active model key and current headers before each native search. */
+	resolveCredentials?: ActiveSearchModelCredentialResolver;
+	/** True when registry-owned auth or transport overrides this active model. */
+	ownerAuthOverride?: boolean;
 	webSearch?: WebSearchMode;
 }