@gajae-code/coding-agent 0.5.4 → 0.6.1

package/src/tools/index.ts

@@ -33,9 +33,11 @@ import { AskTool } from "./ask";
 import { AstEditTool } from "./ast-edit";
 import { AstGrepTool } from "./ast-grep";
 import { BashTool } from "./bash";
+import type { BashRestrictionProfile } from "./bash-allowed-prefixes";
 import { BrowserTool } from "./browser";
 import { CalculatorTool } from "./calculator";
 import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
+import { ComputerTool, isComputerCallable, isComputerLoadablePlatform } from "./computer";
 import { CronCreateTool, CronDeleteTool, CronListTool } from "./cron";
 import { DebugTool } from "./debug";
 import { EvalTool } from "./eval";
@@ -73,6 +75,7 @@ export * from "./bash";
 export * from "./browser";
 export * from "./calculator";
 export * from "./checkpoint";
+export * from "./computer";
 export * from "./cron";
 export * from "./debug";
 export * from "./eval";
@@ -159,6 +162,12 @@ 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. */
+	hasForegroundBashBackgroundRequestHandler?: () => boolean;
+	/** Request that the active managed foreground bash call fold into a background job, if supported. */
+	requestForegroundBashBackground?: () => boolean;
 	/** Get session ID */
 	getSessionId?: () => string | null;
 	/** Get Hindsight runtime state for this agent session. */
@@ -171,8 +180,12 @@ export interface ToolSession {
 	getToolByName?: (name: string) => AgentTool | undefined;
 	/** Agent registry for IRC routing across live sessions. */
 	agentRegistry?: AgentRegistry;
-	/** Optional restricted bash command prefixes for read-only role agents. */
+	/** Optional restricted bash command prefixes for read-only role agents and constrained modes. */
 	bashAllowedPrefixes?: string[];
+	/** Restriction policy for sessions that deliberately expose a narrow bash surface. */
+	bashRestrictionProfile?: BashRestrictionProfile;
+	/** Optional per-session allowlist for tools exposed through search_tool_bm25. */
+	discoverableToolAllowedNames?: readonly string[];
 	/** Get artifacts directory for artifact:// URLs */
 	getArtifactsDir?: () => string | null;
 	/** Get the ArtifactManager backing this session (shared across parent + subagents). */
@@ -201,6 +214,8 @@ export interface ToolSession {
 	getGoalModeState?: () => GoalModeState | undefined;
 	/** Unattended workflow-gate emitter (present only when unattended mode is negotiated). */
 	getWorkflowGateEmitter?: () => WorkflowGateEmitter | undefined;
+	/** Optional per-session restriction for goal tool operations. */
+	goalToolAllowedOps?: readonly ("create" | "get" | "complete" | "resume" | "drop" | "pause")[];
 	/** Goal runtime for the active agent session. */
 	getGoalRuntime?: () => GoalRuntime | undefined;
 	/** Bridge to the connected client (e.g. ACP editor host). Tools should route fs/terminal/permission requests through this when available. */
@@ -312,6 +327,29 @@ export function computeEssentialBuiltinNames(settings: Settings): string[] {
  * Hindsight memory helpers are intentionally excluded: memory is a private backend
  * integration, not a public gajae-code tool surface.
  */
+export interface BuiltinCapabilityCatalogEntry {
+	name: string;
+	label: string;
+	summary: string;
+	docsPath: string;
+	callableBuiltin: boolean;
+	defaultEnabled: boolean;
+}
+
+export const BUILTIN_CAPABILITY_CATALOG: readonly BuiltinCapabilityCatalogEntry[] = isComputerLoadablePlatform()
+	? [
+			{
+				name: "computer",
+				label: "Computer",
+				summary:
+					"Apple Silicon macOS desktop screenshot and input control; enabled by default on supported hosts and supervisor-gated.",
+				docsPath: "docs/tools/computer.md",
+				callableBuiltin: false,
+				defaultEnabled: true,
+			},
+		]
+	: [];
+
 export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	read: s => new ReadTool(s),
 	bash: s => new BashTool(s),
@@ -330,6 +368,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	lsp: LspTool.createIf,
 	inspect_image: s => new InspectImageTool(s),
 	browser: s => new BrowserTool(s),
+	...(isComputerLoadablePlatform() ? { computer: ComputerTool.createIf } : {}),
 	checkpoint: CheckpointTool.createIf,
 	rewind: RewindTool.createIf,
 	task: s => TaskTool.create(s),
@@ -504,6 +543,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "calc") return session.settings.get("calc.enabled");
 		if (name === "skill") return session.settings.get("skill.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
+		if (name === "computer") return isComputerCallable(session);
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
 		if (name === "irc") {
 			if (!session.settings.get("irc.enabled")) return false;

package/src/tools/job.ts

@@ -26,6 +26,7 @@ const jobSchema = z.object({
 	poll: z.array(z.string()).optional().describe("job ids to wait for"),
 	cancel: z.array(z.string()).optional().describe("job ids to cancel"),
 	list: z.boolean().optional().describe("snapshot all jobs"),
+	tail: z.array(z.string()).optional().describe("job ids whose retained output should be shown without waiting"),
 });
 
 type JobParams = z.infer<typeof jobSchema>;
@@ -60,9 +61,19 @@ interface CancelOutcome {
 	message: string;
 }
 
+export interface JobOutputTail {
+	id: string;
+	status: AsyncJob["status"];
+	text: string;
+	startOffset: number;
+	nextOffset: number;
+	truncated: boolean;
+}
+
 export interface JobToolDetails {
 	jobs: JobSnapshot[];
 	cancelled?: { id: string; status: CancelStatus }[];
+	output?: JobOutputTail[];
 }
 
 export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
@@ -107,7 +118,21 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			if (params.cancel?.length || params.poll?.length) {
 				throw new ToolError("`list` cannot be combined with `poll` or `cancel`.");
 			}
-			return this.#buildResult(manager, manager.getAllJobs(ownerFilter), []);
+			return this.#buildResult(
+				manager,
+				manager.getAllJobs(ownerFilter),
+				[],
+				this.#readOutputTails(manager, params.tail, ownerFilter),
+			);
+		}
+
+		if (params.tail?.length && !params.poll?.length && !params.cancel?.length) {
+			return this.#buildResult(
+				manager,
+				this.#visibleJobs(manager, params.tail, ownerId),
+				[],
+				this.#readOutputTails(manager, params.tail, ownerFilter),
+			);
 		}
 
 		const cancelIds = params.cancel ?? [];
@@ -150,7 +175,12 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 
 		if (!shouldPoll) {
 			const cancelledJobs = this.#visibleJobs(manager, cancelIds, ownerId);
-			return this.#buildResult(manager, cancelledJobs, cancelOutcomes);
+			return this.#buildResult(
+				manager,
+				cancelledJobs,
+				cancelOutcomes,
+				this.#readOutputTails(manager, params.tail, ownerFilter),
+			);
 		}
 
 		// Resolve which jobs to watch.
@@ -163,7 +193,12 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		if (jobsToWatch.length === 0) {
 			if (cancelOutcomes.length > 0) {
 				const cancelledJobs = this.#visibleJobs(manager, cancelIds, ownerId);
-				return this.#buildResult(manager, cancelledJobs, cancelOutcomes);
+				return this.#buildResult(
+					manager,
+					cancelledJobs,
+					cancelOutcomes,
+					this.#readOutputTails(manager, params.tail, ownerFilter),
+				);
 			}
 			const message = requestedPollIds?.length
 				? `No matching jobs found for IDs: ${requestedPollIds.join(", ")}`
@@ -178,7 +213,12 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		const runningJobs = jobsToWatch.filter(j => j.status === "running");
 		if (runningJobs.length === 0) {
 			const cancelledJobs = cancelIds.map(id => manager.getJob(id)).filter(j => j != null);
-			return this.#buildResult(manager, [...cancelledJobs, ...jobsToWatch], cancelOutcomes);
+			return this.#buildResult(
+				manager,
+				[...cancelledJobs, ...jobsToWatch],
+				cancelOutcomes,
+				this.#readOutputTails(manager, params.tail, ownerFilter),
+			);
 		}
 
 		// Wait until at least one running job finishes, the wait duration elapses, or the call is aborted.
@@ -231,7 +271,12 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			if (progressTimer) clearInterval(progressTimer);
 		}
 
-		return this.#buildResult(manager, allTrackedJobs, cancelOutcomes);
+		return this.#buildResult(
+			manager,
+			allTrackedJobs,
+			cancelOutcomes,
+			this.#readOutputTails(manager, params.tail, ownerFilter),
+		);
 	}
 
 	/**
@@ -239,6 +284,28 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	 * Drops missing ids and ids owned by other agents, so cross-agent inspection
 	 * via the `job` tool is impossible.
 	 */
+	#readOutputTails(
+		manager: AsyncJobManager,
+		ids: string[] | undefined,
+		ownerFilter: { ownerId: string } | undefined,
+	): JobOutputTail[] {
+		if (!ids?.length) return [];
+		const out: JobOutputTail[] = [];
+		for (const id of Array.from(new Set(ids.map(value => value.trim()).filter(Boolean)))) {
+			const slice = manager.readOutputSince(id, 0, ownerFilter);
+			if (!slice) continue;
+			out.push({
+				id: slice.jobId,
+				status: slice.status,
+				text: slice.text,
+				startOffset: slice.startOffset,
+				nextOffset: slice.nextOffset,
+				truncated: slice.truncated,
+			});
+		}
+		return out;
+	}
+
 	#visibleJobs(manager: AsyncJobManager, ids: string[], ownerId: string | undefined): AsyncJob[] {
 		const out: AsyncJob[] = [];
 		for (const id of ids) {
@@ -290,6 +357,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			errorText?: string;
 		}[],
 		cancelOutcomes: CancelOutcome[],
+		outputTails: JobOutputTail[] = [],
 	): AgentToolResult<JobToolDetails> {
 		// Deduplicate by id (cancelled jobs may also appear in the watched set).
 		const seen = new Set<string>();
@@ -335,11 +403,21 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			}
 		}
 
+		if (outputTails.length > 0) {
+			lines.push("", `## Retained Output (${outputTails.length})\n`);
+			for (const tail of outputTails) {
+				lines.push(`### ${tail.id} — ${tail.status}`);
+				if (tail.truncated) lines.push(`(showing retained tail from byte ${tail.startOffset})`);
+				lines.push("```", tail.text || "(no retained output yet)", "```", `cursor: ${tail.nextOffset}`, "");
+			}
+		}
+
 		return {
 			content: [{ type: "text", text: lines.join("\n").trimEnd() }],
 			details: {
 				jobs: jobResults,
 				...(cancelOutcomes.length ? { cancelled: cancelOutcomes.map(({ id, status }) => ({ id, status })) } : {}),
+				...(outputTails.length ? { output: outputTails } : {}),
 			},
 		};
 	}
@@ -352,6 +430,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 interface JobRenderArgs {
 	poll?: string[];
 	cancel?: string[];
+	tail?: string[];
 }
 
 const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
@@ -391,6 +470,7 @@ function statusToColor(status: JobSnapshot["status"]): ToolUIColor {
 function describeTarget(args: JobRenderArgs | undefined): string {
 	const poll = args?.poll ?? [];
 	const cancel = args?.cancel ?? [];
+	const tail = args?.tail ?? [];
 	const parts: string[] = [];
 	if (cancel.length > 0) {
 		parts.push(cancel.length === 1 ? `cancel ${cancel[0]}` : `cancel ${cancel.length} jobs`);
@@ -398,6 +478,9 @@ function describeTarget(args: JobRenderArgs | undefined): string {
 	if (poll.length > 0) {
 		parts.push(poll.length === 1 ? `poll ${poll[0]}` : `poll ${poll.length} jobs`);
 	}
+	if (tail.length > 0) {
+		parts.push(tail.length === 1 ? `tail ${tail[0]}` : `tail ${tail.length} jobs`);
+	}
 	if (parts.length === 0) return "all running jobs";
 	return parts.join(", ");
 }

package/src/tools/json-tree.ts

@@ -81,6 +81,25 @@ function buildTreePrefix(theme: Theme, ancestors: readonly boolean[]): string {
 	return ancestors.map(hasNext => (hasNext ? `${theme.tree.vertical}  ` : "   ")).join("");
 }
 
+function splitByDisplayWidth(value: string, maxWidth: number): string[] {
+	const width = Math.max(1, maxWidth);
+	const fragments: string[] = [];
+	let current = "";
+	let currentWidth = 0;
+	for (const char of value) {
+		const charWidth = Math.max(1, Bun.stringWidth(char));
+		if (current && currentWidth + charWidth > width) {
+			fragments.push(current);
+			current = "";
+			currentWidth = 0;
+		}
+		current += char;
+		currentWidth += charWidth;
+	}
+	if (current || fragments.length === 0) fragments.push(current);
+	return fragments;
+}
+
 /**
  * Render a JSON value as tree lines.
  */
@@ -121,38 +140,32 @@ export function renderJsonTreeLines(
 			// Handle scalars
 			if (val === null || val === undefined || typeof val !== "object") {
 				const label = key ? theme.fg("muted", key) : theme.fg("muted", "value");
-
-				// Special handling for multiline strings
-				if (typeof val === "string" && val.includes("\n")) {
-					const strLines = val.split("\n");
-					const maxStrLines = Math.min(strLines.length, Math.max(1, maxLines - lines.length - 1));
+				if (typeof val === "string") {
+					const escaped = val.replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+					const marker = "…";
+					const firstFragmentWidth = Math.max(1, maxScalarLen - 2);
+					const continuationWidth = Math.max(1, maxScalarLen - Bun.stringWidth(marker) - 1);
+					const firstFragments = splitByDisplayWidth(escaped, firstFragmentWidth);
+					const firstFragment = firstFragments[0] ?? "";
+					const remainder = firstFragments.slice(1).join("");
+					const continuationFragments = remainder ? splitByDisplayWidth(remainder, continuationWidth) : [];
+					const fragments = [firstFragment, ...continuationFragments];
+					const lineBudget = Math.max(1, maxLines - lines.length);
+					const visibleCount = Math.min(fragments.length, lineBudget);
 					const continuePrefix = buildTreePrefix(theme, ancestors);
+					const isStringTruncated = visibleCount < fragments.length;
 
-					// First line with label
-					const firstLine = truncateToWidth(strLines[0], maxScalarLen);
-					pushLine(`${prefix}${iconScalar} ${label}: ${theme.fg("dim", `"${firstLine}`)}`);
-
-					// Subsequent lines indented
-					for (let i = 1; i < maxStrLines; i++) {
-						if (lines.length >= maxLines) {
-							truncated = true;
-							break;
-						}
-						const line = truncateToWidth(strLines[i], maxScalarLen);
-						pushLine(`${continuePrefix}   ${theme.fg("dim", ` ${line}`)}`);
-					}
-
-					// Show truncation and closing quote
-					if (strLines.length > maxStrLines) {
-						truncated = true;
-						pushLine(
-							`${continuePrefix}   ${theme.fg("dim", ` …(${strLines.length - maxStrLines} more lines)"`)}`,
-						);
-					} else {
-						// Add closing quote to last line - need to modify the last pushed line
-						const lastIdx = lines.length - 1;
-						lines[lastIdx] = `${lines[lastIdx]}${theme.fg("dim", '"')}`;
+					for (let i = 0; i < visibleCount; i++) {
+						const isFirst = i === 0;
+						const isFinalVisible = i === visibleCount - 1;
+						const suffix = isStringTruncated && isFinalVisible ? `${marker}"` : isFinalVisible ? '"' : "";
+						const rendered = isFirst ? `"${fragments[i]}${suffix}` : `↳ ${fragments[i]}${suffix}`;
+						const line = isFirst
+							? `${prefix}${iconScalar} ${label}: ${theme.fg("dim", rendered)}`
+							: `${continuePrefix}   ${theme.fg("dim", rendered)}`;
+						if (!pushLine(line)) break;
 					}
+					if (isStringTruncated) truncated = true;
 					return;
 				}
 

package/src/tools/renderers.ts

@@ -17,6 +17,7 @@ import { astGrepToolRenderer } from "./ast-grep";
 import { bashToolRenderer } from "./bash";
 import { browserToolRenderer } from "./browser/render";
 import { calculatorToolRenderer } from "./calculator";
+import { computerToolRenderer } from "./computer/render";
 import { debugToolRenderer } from "./debug";
 import { evalToolRenderer } from "./eval";
 import { findToolRenderer } from "./find";
@@ -52,6 +53,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	ast_edit: astEditToolRenderer as ToolRenderer,
 	bash: bashToolRenderer as ToolRenderer,
 	browser: browserToolRenderer as ToolRenderer,
+	computer: computerToolRenderer as ToolRenderer,
 	recipe: recipeToolRenderer as ToolRenderer,
 	debug: debugToolRenderer as ToolRenderer,
 	eval: evalToolRenderer as ToolRenderer,

package/src/tools/tool-timeouts.ts

@@ -11,6 +11,7 @@ export const TOOL_TIMEOUTS = {
 	bash: { default: 300, min: 1, max: 3600 },
 	eval: { default: 30, min: 1, max: 600 },
 	browser: { default: 30, min: 1, max: 300 },
+	computer: { default: 30, min: 1, max: 300 },
 	ssh: { default: 60, min: 1, max: 3600 },
 	fetch: { default: 20, min: 1, max: 45 },
 	lsp: { default: 20, min: 5, max: 60 },

package/src/web/search/index.ts

@@ -1,7 +1,7 @@
 /**
  * Unified Web Search Tool
  *
- * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, OpenAI code backend, Tavily, Kagi, Z.AI, SearXNG, and Synthetic
+ * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, OpenAI code backend, xAI, Tavily, Kagi, Z.AI, SearXNG, and Synthetic
  * providers with provider-specific parameters exposed conditionally.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
@@ -29,6 +29,20 @@ export const webSearchSchema = z.object({
 	max_tokens: z.number().describe("max output tokens").optional(),
 	temperature: z.number().describe("sampling temperature").optional(),
 	num_search_results: z.number().describe("number of search results").optional(),
+	xai_search_mode: z
+		.enum(["web", "x", "web_and_x"])
+		.describe("xAI only: use web_search, x_search, or both")
+		.optional(),
+	allowed_domains: z.array(z.string()).max(5).describe("xAI web_search only: allowed domains").optional(),
+	excluded_domains: z.array(z.string()).max(5).describe("xAI web_search only: excluded domains").optional(),
+	allowed_x_handles: z.array(z.string()).max(20).describe("xAI x_search only: allowed X handles").optional(),
+	excluded_x_handles: z.array(z.string()).max(20).describe("xAI x_search only: excluded X handles").optional(),
+	from_date: z.string().describe("xAI x_search only: start date in ISO8601 format").optional(),
+	to_date: z.string().describe("xAI x_search only: end date in ISO8601 format").optional(),
+	enable_image_understanding: z.boolean().describe("xAI only: analyze images encountered during search").optional(),
+	enable_image_search: z.boolean().describe("xAI web_search only: search for and embed image results").optional(),
+	enable_video_understanding: z.boolean().describe("xAI x_search only: analyze videos in X posts").optional(),
+	no_inline_citations: z.boolean().describe("xAI only: disable inline citation markdown in the answer").optional(),
 });
 
 export type SearchToolParams = z.infer<typeof webSearchSchema>;
@@ -153,6 +167,17 @@ async function executeSearch(
 				maxOutputTokens: params.max_tokens,
 				numSearchResults: params.num_search_results,
 				temperature: params.temperature,
+				xaiSearchMode: params.xai_search_mode,
+				allowedDomains: params.allowed_domains,
+				excludedDomains: params.excluded_domains,
+				allowedXHandles: params.allowed_x_handles,
+				excludedXHandles: params.excluded_x_handles,
+				fromDate: params.from_date,
+				toDate: params.to_date,
+				enableImageUnderstanding: params.enable_image_understanding,
+				enableImageSearch: params.enable_image_search,
+				enableVideoUnderstanding: params.enable_video_understanding,
+				noInlineCitations: params.no_inline_citations,
 				signal,
 				authStorage,
 				sessionId,
@@ -225,7 +250,7 @@ export async function runSearchQuery(
 /**
  * Web search tool implementation.
  *
- * Supports Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, OpenAI code backend, Z.AI, SearXNG, and Synthetic providers with automatic fallback.
+ * Supports Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, OpenAI code backend, xAI, Z.AI, SearXNG, and Synthetic providers with automatic fallback.
  */
 export class WebSearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {
 	readonly name = "web_search";

package/src/web/search/provider.ts

@@ -45,6 +45,7 @@ const PROVIDER_META: Record<SearchProviderId, ProviderMeta> = {
 		load: async () => new (await import("./providers/gemini")).GeminiProvider(),
 	},
 	codex: { id: "codex", label: "OpenAI", load: async () => new (await import("./providers/codex")).CodexProvider() },
+	xai: { id: "xai", label: "xAI", load: async () => new (await import("./providers/xai")).XaiProvider() },
 	tavily: {
 		id: "tavily",
 		label: "Tavily",
@@ -104,6 +105,7 @@ export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
 	"anthropic",
 	"gemini",
 	"codex",
+	"xai",
 	"zai",
 	"exa",
 	"parallel",
@@ -116,6 +118,7 @@ const MODEL_PROVIDER_TO_SEARCH: Record<string, SearchProviderId> = {
 	openai: "codex",
 	"openai-codex": "codex",
 	"openai-responses": "codex",
+	xai: "xai",
 	anthropic: "anthropic",
 	google: "gemini",
 	"google-gemini-cli": "gemini",
@@ -185,6 +188,16 @@ function looksOpenAIFamilyModelId(ctx: ActiveSearchModelContext): boolean {
 	return looksHostedModelId(ctx.wireModelId) || looksHostedModelId(ctx.modelId);
 }
 
+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 looksXaiFamilyModelId(ctx: ActiveSearchModelContext): boolean {
+	return looksXaiModelId(ctx.wireModelId) || looksXaiModelId(ctx.modelId);
+}
+
 export function isLocalBaseUrl(baseUrl: string | undefined): boolean {
 	if (!baseUrl) return false;
 	let url: URL;
@@ -226,6 +239,7 @@ export function inferNativeProviderFromModel(ctx: ActiveSearchModelContext | und
 	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";
 	}
@@ -290,7 +304,8 @@ export async function resolveProviderChain(options: ResolveProviderChainOptions)
 			await appendAvailable(chain, directId, authStorage);
 		const inferred = inferNativeProviderFromModel(activeModelContext);
 		if (inferred) await appendAvailable(chain, inferred, authStorage);
-		if (await shouldTryGenericOpenAICompat(authStorage, activeModelContext, sessionId, signal))
+		const hasNativeXai = chain.includes("xai");
+		if (!hasNativeXai && (await shouldTryGenericOpenAICompat(authStorage, activeModelContext, sessionId, signal)))
 			appendDeduped(chain, "openai-compatible");
 	}
 

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

@@ -33,6 +33,28 @@ export interface SearchParams {
 	maxOutputTokens?: number;
 	numSearchResults?: number;
 	temperature?: number;
+	/** xAI-specific search surface. Defaults to web_search when omitted. */
+	xaiSearchMode?: "web" | "x" | "web_and_x";
+	/** xAI web_search domain allow-list (max 5). */
+	allowedDomains?: string[];
+	/** xAI web_search domain deny-list (max 5). */
+	excludedDomains?: string[];
+	/** xAI x_search handle allow-list (max 20). */
+	allowedXHandles?: string[];
+	/** xAI x_search handle deny-list (max 20). */
+	excludedXHandles?: string[];
+	/** xAI x_search lower date bound, ISO8601 date such as YYYY-MM-DD. */
+	fromDate?: string;
+	/** xAI x_search upper date bound, ISO8601 date such as YYYY-MM-DD. */
+	toDate?: string;
+	/** xAI web_search/x_search image understanding. */
+	enableImageUnderstanding?: boolean;
+	/** xAI web_search image search result embedding. */
+	enableImageSearch?: boolean;
+	/** xAI x_search video understanding. */
+	enableVideoUnderstanding?: boolean;
+	/** xAI Responses include=["no_inline_citations"]. */
+	noInlineCitations?: boolean;
 	googleSearch?: Record<string, unknown>;
 	codeExecution?: Record<string, unknown>;
 	urlContext?: Record<string, unknown>;