@oh-my-pi/pi-coding-agent 16.0.4 → 16.0.6

package/src/tools/tts.ts

@@ -5,7 +5,7 @@
 
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { type ApiKey, ProviderHttpError, withAuth } from "@oh-my-pi/pi-ai";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { settings } from "../config/settings";
 import type { CustomTool, CustomToolContext } from "../extensibility/custom-tools/types";
 import { ohMyPiXAIUserAgent, resolveXAIHttpCredentials } from "../lib/xai-http";
@@ -16,7 +16,6 @@ import { formatPathRelativeToCwd, resolveToCwd } from "./path-utils";
 
 // Hermes tts_tool.py L167-171
 const DEFAULT_XAI_VOICE_ID = "eve" as const;
-const DEFAULT_XAI_LANGUAGE = "en" as const;
 const DEFAULT_XAI_SAMPLE_RATE = 24_000;
 const DEFAULT_XAI_BIT_RATE = 128_000;
 const XAI_MAX_TEXT_LENGTH = 15_000;
@@ -31,15 +30,17 @@ const formatVoiceList = (): string =>
 type TtsCodec = "mp3" | "wav";
 type TtsBackend = "local" | "xai";
 
-const ttsSchema = z.object({
-	text: z.string().min(1).max(XAI_MAX_TEXT_LENGTH),
-	voice_id: z.string().default(DEFAULT_XAI_VOICE_ID),
-	language: z.string().default(DEFAULT_XAI_LANGUAGE),
-	output_path: z.string(),
-	sample_rate: z.number().int().optional(),
-	bit_rate: z.number().int().optional(),
+const ttsSchema = type({
+	text: "1 <= string <= 15000",
+	voice_id: "string = 'eve'",
+	language: "string = 'en'",
+	output_path: "string",
+	sample_rate: "number.integer?",
+	bit_rate: "number.integer?",
 });
 
+type TtsSchemaType = typeof ttsSchema.infer;
+
 interface TtsToolDetails {
 	bytes: number;
 	voiceId: string;
@@ -87,13 +88,13 @@ function readStringSetting(key: "providers.tts" | "tts.localModel" | "tts.localV
 }
 
 async function synthesizeXai(
-	params: z.infer<typeof ttsSchema>,
+	params: TtsSchemaType,
 	ctx: CustomToolContext,
 	outputPath: string,
 	displayPath: string,
 	codec: TtsCodec,
 	signal: AbortSignal | undefined,
-): Promise<AgentToolResult<TtsToolDetails, typeof ttsSchema>> {
+): Promise<AgentToolResult<TtsToolDetails, TtsSchemaType>> {
 	const creds = await resolveXAIHttpCredentials(ctx.modelRegistry);
 	if (!creds) {
 		return {
@@ -187,11 +188,11 @@ async function synthesizeXai(
 }
 
 async function synthesizeLocal(
-	params: z.infer<typeof ttsSchema>,
+	params: TtsSchemaType,
 	cwd: string,
 	outputPath: string,
 	signal: AbortSignal | undefined,
-): Promise<AgentToolResult<TtsToolDetails, typeof ttsSchema>> {
+): Promise<AgentToolResult<TtsToolDetails, TtsSchemaType>> {
 	const modelSetting = readStringSetting("tts.localModel");
 	const modelKey = modelSetting && isTtsLocalModelKey(modelSetting) ? modelSetting : DEFAULT_TTS_LOCAL_MODEL_KEY;
 	const voice = readStringSetting("tts.localVoice") || DEFAULT_TTS_VOICE;
@@ -242,11 +243,11 @@ export const ttsTool: CustomTool<typeof ttsSchema, TtsToolDetails> = {
 	parameters: ttsSchema,
 	async execute(
 		_toolCallId: string,
-		params: z.infer<typeof ttsSchema>,
+		params: TtsSchemaType,
 		_onUpdate,
 		ctx: CustomToolContext,
 		signal?: AbortSignal,
-	): Promise<AgentToolResult<TtsToolDetails, typeof ttsSchema>> {
+	): Promise<AgentToolResult<TtsToolDetails, TtsSchemaType>> {
 		const cwd = ctx.sessionManager.getCwd();
 		const outputPath = resolveToCwd(params.output_path, cwd);
 		const displayPath = formatPathRelativeToCwd(outputPath, cwd);

package/src/tools/write.ts

@@ -6,7 +6,7 @@ import { formatHashlineHeader, stripHashlinePrefixes } from "@oh-my-pi/hashline"
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { isEnoent, isRecord, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 
 import { canonicalSnapshotKey, getFileSnapshotStore } from "../edit/file-snapshot-store";
 import { normalizeToLF } from "../edit/normalize";
@@ -71,12 +71,12 @@ async function loadFflate(): Promise<typeof import("fflate")> {
 	return fflateModulePromise;
 }
 
-const writeSchema = z.object({
-	path: z.string().describe("file path"),
-	content: z.string().describe("file content"),
+const writeSchema = type({
+	path: type("string").describe("file path"),
+	content: type("string").describe("file content"),
 });
 
-export type WriteToolInput = z.infer<typeof writeSchema>;
+export type WriteToolInput = typeof writeSchema.infer;
 
 /** Details returned by the write tool for TUI rendering */
 export interface WriteToolDetails {

package/src/tui/code-cell.ts

@@ -33,6 +33,8 @@ export interface CodeCellOptions {
 	codeTail?: boolean;
 	expanded?: boolean;
 	width: number;
+	codeStartLine?: number;
+	codeLineNumbers?: Array<number | null>;
 }
 
 function getState(status?: CodeCellOptions["status"]): State | undefined {
@@ -99,7 +101,17 @@ function collapseCarriageReturns(line: string): string {
 	return idx < 0 ? line : line.slice(idx + 1);
 }
 export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[] {
-	const { code, language, output, expanded = false, outputMaxLines = 6, codeMaxLines = 12, width } = options;
+	const {
+		code,
+		language,
+		output,
+		expanded = false,
+		outputMaxLines = 6,
+		codeMaxLines = 12,
+		width,
+		codeStartLine,
+		codeLineNumbers,
+	} = options;
 	const { title, meta } = formatHeader(options, theme);
 	const state = getState(options.status);
 
@@ -111,16 +123,45 @@ export function renderCodeCell(options: CodeCellOptions, theme: Theme): string[]
 	const startIndex = tail ? rawCodeLines.length - maxCodeLines : 0;
 	const visibleCode = rawCodeLines.slice(startIndex, startIndex + maxCodeLines).join("\n");
 	const codeLines = highlightCode(visibleCode, language);
+
+	let visibleLineNumbers: Array<number | null> | undefined;
+	let lineNumberWidth = 0;
+	if (codeLineNumbers) {
+		visibleLineNumbers = codeLineNumbers.slice(startIndex, startIndex + maxCodeLines);
+	} else if (codeStartLine !== undefined) {
+		visibleLineNumbers = Array.from({ length: maxCodeLines }, (_, i) => codeStartLine + startIndex + i);
+	}
+
+	if (visibleLineNumbers) {
+		const validLineNums = visibleLineNumbers.filter((n): n is number => n !== null && n !== undefined);
+		const maxVal = validLineNums.length > 0 ? Math.max(...validLineNums) : 0;
+		if (maxVal > 0) {
+			lineNumberWidth = Math.max(2, String(maxVal).length);
+		}
+	}
+
+	if (lineNumberWidth > 0 && visibleLineNumbers) {
+		for (let i = 0; i < codeLines.length; i++) {
+			const lineNum = visibleLineNumbers[i];
+			const gutter =
+				lineNum !== null && lineNum !== undefined
+					? String(lineNum).padStart(lineNumberWidth, " ")
+					: " ".repeat(lineNumberWidth);
+			codeLines[i] = theme.fg("dim", `${gutter} `) + codeLines[i];
+		}
+	}
+
 	if (hiddenCodeLines > 0) {
 		const hint = formatExpandHint(theme, expanded, hiddenCodeLines > 0);
+		const gutterPad = lineNumberWidth > 0 ? " ".repeat(lineNumberWidth + 1) : "";
 		if (tail) {
 			// Earlier rows scrolled above the live tail window — mark them on top so
 			// the newest streamed line stays pinned to the bottom of the box.
 			const earlier = `… ${hiddenCodeLines} earlier line${hiddenCodeLines === 1 ? "" : "s"}${hint ? ` ${hint}` : ""}`;
-			codeLines.unshift(theme.fg("dim", earlier));
+			codeLines.unshift(theme.fg("dim", gutterPad + earlier));
 		} else {
 			const moreLine = `${formatMoreItems(hiddenCodeLines, "line")}${hint ? ` ${hint}` : ""}`;
-			codeLines.push(theme.fg("dim", moreLine));
+			codeLines.push(theme.fg("dim", gutterPad + moreLine));
 		}
 	}
 

package/src/tui/index.ts

@@ -10,3 +10,4 @@ export * from "./status-line";
 export * from "./tree-list";
 export * from "./types";
 export * from "./utils";
+export * from "./width-aware-text";

package/src/tui/width-aware-text.ts

@@ -0,0 +1,58 @@
+import { type Component, getPaddingX, Text } from "@oh-my-pi/pi-tui";
+
+/**
+ * Text whose content is (re)formatted against the actual render width.
+ *
+ * A plain `Text` receives an already-formatted string and only wraps it at
+ * render time, so width-dependent layout (per-line truncation, inline previews)
+ * has to be decided before the width is known. Renderers used to cope by
+ * hard-capping output lines at a fixed column count (e.g. 80), which truncated
+ * to roughly a third of a wide terminal. This defers formatting to
+ * `render(width)`: it computes the same content width the inner `Text` uses
+ * (mirroring its tight-layout flag so the budget can't desync), hands that to
+ * the formatter, and delegates margins/background/vertical padding to the inner
+ * `Text`. Lines the formatter caps at `contentWidth` fit exactly and so never
+ * wrap.
+ */
+export class WidthAwareText implements Component {
+	#format: (contentWidth: number) => string;
+	readonly #paddingX: number;
+	#inner: Text;
+	#cachedContentWidth = -1;
+	#cachedText: string | undefined;
+	#ignoreTight = false;
+
+	constructor(format: (contentWidth: number) => string, paddingX = 1, paddingY = 1) {
+		this.#format = format;
+		this.#paddingX = paddingX;
+		this.#inner = new Text("", paddingX, paddingY);
+	}
+
+	setCustomBgFn(customBgFn?: (text: string) => string): void {
+		this.#inner.setCustomBgFn(customBgFn);
+	}
+
+	setIgnoreTight(ignore: boolean): this {
+		this.#ignoreTight = ignore;
+		this.#inner.setIgnoreTight(ignore);
+		this.invalidate();
+		return this;
+	}
+
+	invalidate(): void {
+		this.#cachedContentWidth = -1;
+		this.#cachedText = undefined;
+		this.#inner.invalidate();
+	}
+
+	render(width: number): readonly string[] {
+		const paddingX = this.#ignoreTight ? this.#paddingX : getPaddingX(this.#paddingX);
+		const contentWidth = Math.max(1, width - paddingX * 2);
+		if (this.#cachedText === undefined || contentWidth !== this.#cachedContentWidth) {
+			this.#cachedContentWidth = contentWidth;
+			this.#cachedText = this.#format(contentWidth);
+			this.#inner.setText(this.#cachedText);
+		}
+		return this.#inner.render(width);
+	}
+}

package/src/utils/image-vision-fallback.ts

@@ -0,0 +1,197 @@
+/**
+ * Vision fallback for text-only models. When a user attaches an image to a model
+ * that cannot accept image input, this:
+ *  1. saves each image under the session `local://` root (for later analysis), and
+ *  2. asks a vision-capable model to describe it and injects that description as
+ *     a text block in place of the image:
+ *
+ *     <image path="local://image-<hash>.png">
+ *     <description>
+ *     </image>
+ *
+ * Without this the provider layer drops the image entirely (NON_VISION_IMAGE_PLACEHOLDER).
+ */
+import * as path from "node:path";
+import {
+	type AgentTelemetry,
+	type AgentTelemetryConfig,
+	instrumentedCompleteSimple,
+	resolveTelemetry,
+} from "@oh-my-pi/pi-agent-core";
+import type { Api, completeSimple, ImageContent, Model, TextContent } from "@oh-my-pi/pi-ai";
+import { logger, prompt, toError } from "@oh-my-pi/pi-utils";
+import { extractTextContent } from "../commit/utils";
+import type { ModelRegistry } from "../config/model-registry";
+import { expandRoleAlias, getModelMatchPreferences, resolveModelFromString } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+import { type LocalProtocolOptions, resolveLocalRoot } from "../internal-urls";
+import describeUserPrompt from "../prompts/tools/image-attachment-describe.md" with { type: "text" };
+import describeSystemPrompt from "../prompts/tools/image-attachment-describe-system.md" with { type: "text" };
+
+/** Telemetry tag for the oneshot vision-description calls. */
+const ONESHOT_KIND = "image_attachment_describe";
+
+const NO_VISION_MODEL_NOTE =
+	"[No vision-capable model is configured, so this image could not be described automatically. " +
+	"The image was saved; configure a vision model role (modelRoles.vision) and use the inspect_image tool to analyze it.]";
+
+const DESCRIPTION_UNAVAILABLE_NOTE =
+	"[Image description unavailable: the vision model returned no usable text. The image was saved for further analysis.]";
+
+/** Registry surface needed to resolve a vision model and authorize requests. */
+export type VisionFallbackRegistry = Pick<ModelRegistry, "getAvailable" | "getApiKey" | "resolver"> &
+	Partial<Pick<ModelRegistry, "resolveCanonicalModel" | "getCanonicalVariants" | "getCanonicalId">>;
+
+export interface DescribeAttachedImagesDeps {
+	/** Active (text-only) model the prompt is destined for. */
+	activeModel: Model<Api>;
+	modelRegistry: VisionFallbackRegistry;
+	settings: Settings;
+	/** Inputs for resolving the session-scoped `local://` root. */
+	localProtocolOptions: LocalProtocolOptions;
+	/** `provider/id` of the active model; a last-resort vision-model candidate (filtered to image-capable). */
+	activeModelString?: string;
+	telemetryConfig?: AgentTelemetryConfig;
+	sessionId?: string;
+	/** Test seam: overrides the underlying completeSimple call. */
+	completeImpl?: typeof completeSimple;
+}
+
+/** Map an image MIME type to a file extension for the saved artifact. */
+function extensionForMime(mimeType: string): string {
+	const subtype = mimeType.split("/")[1]?.toLowerCase() ?? "";
+	switch (subtype) {
+		case "jpeg":
+		case "jpg":
+			return "jpg";
+		case "png":
+			return "png";
+		case "gif":
+			return "gif";
+		case "webp":
+			return "webp";
+		default: {
+			const sanitized = subtype.replace(/[^a-z0-9]/g, "");
+			return sanitized || "png";
+		}
+	}
+}
+
+/** Content-addressed file name so re-pasting the same image reuses one artifact. */
+function imageFileName(image: ImageContent): string {
+	const hash = Bun.hash(image.data).toString(16);
+	return `image-${hash}.${extensionForMime(image.mimeType)}`;
+}
+
+/** Persist an image under the local root; returns its `local://` URL. */
+async function saveImage(image: ImageContent, localRoot: string): Promise<string> {
+	const fileName = imageFileName(image);
+	const filePath = path.join(localRoot, fileName);
+	// Content-addressed: identical bytes overwrite themselves harmlessly. Bun.write creates parent dirs.
+	await Bun.write(filePath, Buffer.from(image.data, "base64"));
+	return `local://${fileName}`;
+}
+
+function formatImageBlock(localUrl: string, description: string): string {
+	return `<image path="${localUrl}">\n${description}\n</image>`;
+}
+
+/**
+ * Resolve a vision-capable model, mirroring the inspect_image priority
+ * (`pi/vision` → `pi/default` → active → first image-capable available), but
+ * never returning a text-only model.
+ */
+function resolveVisionModel(deps: DescribeAttachedImagesDeps): Model<Api> | undefined {
+	const available = deps.modelRegistry.getAvailable();
+	if (available.length === 0) return undefined;
+	const preferences = getModelMatchPreferences(deps.settings);
+	const resolvePattern = (pattern: string | undefined): Model<Api> | undefined => {
+		if (!pattern) return undefined;
+		const expanded = expandRoleAlias(pattern, deps.settings);
+		const model = resolveModelFromString(expanded, available, preferences, deps.modelRegistry);
+		return model?.input.includes("image") ? model : undefined;
+	};
+	return (
+		resolvePattern("pi/vision") ??
+		resolvePattern("pi/default") ??
+		resolvePattern(deps.activeModelString) ??
+		available.find(model => model.input.includes("image"))
+	);
+}
+
+/** Run one vision-description round-trip; returns trimmed text or `null` on any failure. */
+async function describeImage(
+	image: ImageContent,
+	visionModel: Model<Api>,
+	deps: DescribeAttachedImagesDeps,
+	telemetry: AgentTelemetry | undefined,
+	signal: AbortSignal | undefined,
+): Promise<string | null> {
+	try {
+		const response = await instrumentedCompleteSimple(
+			visionModel,
+			{
+				systemPrompt: [prompt.render(describeSystemPrompt)],
+				messages: [
+					{
+						role: "user",
+						content: [
+							{ type: "image", data: image.data, mimeType: image.mimeType },
+							{ type: "text", text: prompt.render(describeUserPrompt) },
+						],
+						timestamp: Date.now(),
+					},
+				],
+			},
+			{ apiKey: deps.modelRegistry.resolver(visionModel, deps.sessionId), signal },
+			{ telemetry, oneshotKind: ONESHOT_KIND, completeImpl: deps.completeImpl },
+		);
+		if (response.stopReason === "error" || response.stopReason === "aborted") {
+			logger.warn("image attachment description did not complete", {
+				stopReason: response.stopReason,
+				model: `${visionModel.provider}/${visionModel.id}`,
+			});
+			return null;
+		}
+		const text = extractTextContent(response).trim();
+		return text.length > 0 ? text : null;
+	} catch (err) {
+		logger.warn("image attachment description failed", {
+			error: toError(err).message,
+			model: `${visionModel.provider}/${visionModel.id}`,
+		});
+		return null;
+	}
+}
+
+/**
+ * Save each attached image under `local://` and replace it with a descriptive
+ * text block. Returns one {@link TextContent} per input image, in order. Never
+ * throws for an individual image: a failed description falls back to a note while
+ * the saved-path block is still emitted.
+ */
+export async function describeAttachedImagesForTextModel(
+	images: readonly ImageContent[],
+	deps: DescribeAttachedImagesDeps,
+	signal?: AbortSignal,
+): Promise<TextContent[]> {
+	const localRoot = resolveLocalRoot(deps.localProtocolOptions);
+	const visionModel = resolveVisionModel(deps);
+	const apiKey = visionModel ? await deps.modelRegistry.getApiKey(visionModel, deps.sessionId) : undefined;
+	const canDescribe = Boolean(visionModel && apiKey);
+	const telemetry = resolveTelemetry(deps.telemetryConfig, deps.sessionId);
+
+	return Promise.all(
+		images.map(async (image): Promise<TextContent> => {
+			const localUrl = await saveImage(image, localRoot);
+			let description: string;
+			if (canDescribe && visionModel) {
+				description =
+					(await describeImage(image, visionModel, deps, telemetry, signal)) ?? DESCRIPTION_UNAVAILABLE_NOTE;
+			} else {
+				description = NO_VISION_MODEL_NOTE;
+			}
+			return { type: "text", text: formatImageBlock(localUrl, description) };
+		}),
+	);
+}

package/src/utils/markit.ts

@@ -8,6 +8,16 @@ export interface MarkitConversionResult {
 	error?: string;
 }
 
+export interface MarkitFileConversionOptions {
+	/**
+	 * Directory the PDF converter writes extracted images/diagrams into. When
+	 * set, each embedded image is rendered to `<id>.png` and referenced by path
+	 * in the markdown; when unset, markit emits an `<!-- image: <id> ... -->`
+	 * placeholder comment instead.
+	 */
+	imageDir?: string;
+}
+
 interface MuPdfWasmModuleConfig {
 	print?: (...values: unknown[]) => void;
 	printErr?: (...values: unknown[]) => void;
@@ -77,9 +87,14 @@ function finalizeConversion(markdown?: string): MarkitConversionResult {
 	return { content: "", ok: false, error: "Conversion produced no output" };
 }
 
-export async function convertFileWithMarkit(filePath: string, signal?: AbortSignal): Promise<MarkitConversionResult> {
+export async function convertFileWithMarkit(
+	filePath: string,
+	signal?: AbortSignal,
+	options?: MarkitFileConversionOptions,
+): Promise<MarkitConversionResult> {
+	const extra = options?.imageDir ? { imageDir: options.imageDir } : undefined;
 	try {
-		const result = await runMarkitConversion(markit => markit.convertFile(filePath), signal);
+		const result = await runMarkitConversion(markit => markit.convertFile(filePath, extra), signal);
 		return finalizeConversion(result.markdown);
 	} catch (error) {
 		if (error instanceof ToolAbortError) {

package/src/web/search/index.ts

@@ -7,7 +7,8 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
+import { settings } from "../../config/settings";
 import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import webSearchSystemPrompt from "../../prompts/system/web-search.md" with { type: "text" };
@@ -22,16 +23,16 @@ import type { SearchProviderId, SearchResponse } from "./types";
 import { SearchProviderError } from "./types";
 
 /** Web search tool parameters schema */
-export const webSearchSchema = z.object({
-	query: z.string().describe("search query"),
-	recency: z.enum(["day", "week", "month", "year"]).describe("recency filter").optional(),
-	limit: z.number().describe("max results").optional(),
-	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(),
+export const webSearchSchema = type({
+	query: "string",
+	recency: "'day' | 'week' | 'month' | 'year'?",
+	limit: "number?",
+	max_tokens: "number?",
+	temperature: "number?",
+	num_search_results: "number?",
 });
 
-export type SearchToolParams = z.infer<typeof webSearchSchema>;
+export type SearchToolParams = typeof webSearchSchema.infer;
 
 export interface SearchQueryParams extends SearchToolParams {
 	provider?: SearchProviderId | "auto";
@@ -153,6 +154,16 @@ async function executeSearch(
 		};
 	}
 
+	// Invariant across providers; read once and tolerate an uninitialized
+	// Settings singleton (e.g. `omp q ...` CLI path, unit tests) so the
+	// provider-fallback loop never aborts before any provider runs.
+	let antigravityEndpointMode: "auto" | "production" | "sandbox" | undefined;
+	try {
+		antigravityEndpointMode = settings.get("providers.antigravityEndpoint");
+	} catch {
+		antigravityEndpointMode = undefined;
+	}
+
 	const failures: Array<{ provider: SearchProvider; error: unknown }> = [];
 	let lastProvider = providers[0];
 	for (const provider of providers) {
@@ -169,6 +180,7 @@ async function executeSearch(
 				signal,
 				authStorage,
 				sessionId,
+				antigravityEndpointMode,
 			});
 
 			if (!hasRenderableSearchContent(response)) {

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

@@ -51,6 +51,7 @@ export interface SearchParams {
 	 * caller's agent session when available; otherwise omit.
 	 */
 	sessionId?: string;
+	antigravityEndpointMode?: "auto" | "production" | "sandbox";
 }
 
 /** Base class for web search providers. */

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

@@ -52,6 +52,7 @@ export interface GeminiSearchParams extends GeminiToolParams {
 	authStorage: AuthStorage;
 	sessionId?: string;
 	fetch?: FetchImpl;
+	antigravityEndpointMode?: "auto" | "production" | "sandbox";
 }
 
 export function buildGeminiRequestTools(params: GeminiToolParams): Array<Record<string, Record<string, unknown>>> {
@@ -163,6 +164,7 @@ async function callGeminiSearch(
 	toolParams: GeminiToolParams,
 	fetchImpl: FetchImpl | undefined,
 	signal: AbortSignal | undefined,
+	mode?: "auto" | "production" | "sandbox",
 ): Promise<{
 	answer: string;
 	sources: SearchSource[];
@@ -171,7 +173,19 @@ async function callGeminiSearch(
 	model: string;
 	usage?: { inputTokens: number; outputTokens: number; totalTokens: number };
 }> {
-	const endpoints = auth.isAntigravity ? ANTIGRAVITY_ENDPOINT_FALLBACKS : [DEFAULT_ENDPOINT];
+	let endpoints: string[];
+	if (auth.isAntigravity) {
+		const m = mode ?? "auto";
+		if (m === "sandbox") {
+			endpoints = [ANTIGRAVITY_SANDBOX_ENDPOINT];
+		} else if (m === "production") {
+			endpoints = [ANTIGRAVITY_DAILY_ENDPOINT];
+		} else {
+			endpoints = [...ANTIGRAVITY_ENDPOINT_FALLBACKS];
+		}
+	} else {
+		endpoints = [DEFAULT_ENDPOINT];
+	}
 	const headers = auth.isAntigravity ? { "User-Agent": getAntigravityUserAgent() } : getGeminiCliHeaders();
 
 	const requestMetadata = auth.isAntigravity
@@ -187,12 +201,7 @@ async function callGeminiSearch(
 
 	const normalizedSystemPrompt = systemPrompt?.toWellFormed();
 	const systemInstructionParts: Array<{ text: string }> = [
-		...(auth.isAntigravity
-			? [
-					{ text: ANTIGRAVITY_SYSTEM_INSTRUCTION },
-					{ text: `Please ignore following [ignore]${ANTIGRAVITY_SYSTEM_INSTRUCTION}[/ignore]` },
-				]
-			: []),
+		...(auth.isAntigravity ? [{ text: ANTIGRAVITY_SYSTEM_INSTRUCTION }] : []),
 		...(normalizedSystemPrompt ? [{ text: normalizedSystemPrompt }] : []),
 	];
 
@@ -238,16 +247,45 @@ async function callGeminiSearch(
 		body: JSON.stringify(requestBody),
 		signal: withHardTimeout(signal),
 	});
-	const urlFor = (attempt: number) =>
-		`${endpoints[Math.min(attempt, endpoints.length - 1)]}/v1internal:streamGenerateContent?alt=sse`;
-
-	const response = await fetchWithRetry(urlFor, {
-		...buildInit(),
-		fetch: fetchImpl,
-		maxAttempts: MAX_RETRIES + 1,
-		defaultDelayMs: attempt => BASE_DELAY_MS * 2 ** attempt,
-		maxDelayMs: RATE_LIMIT_BUDGET_MS,
-	});
+
+	let response: Response | undefined;
+
+	for (let i = 0; i < endpoints.length; i++) {
+		const endpoint = endpoints[i];
+		const isLastEndpoint = i === endpoints.length - 1;
+		try {
+			response = await fetchWithRetry(() => `${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
+				...buildInit(),
+				fetch: fetchImpl,
+				maxAttempts: isLastEndpoint ? MAX_RETRIES + 1 : 1,
+				defaultDelayMs: attempt => BASE_DELAY_MS * 2 ** attempt,
+				maxDelayMs: RATE_LIMIT_BUDGET_MS,
+			});
+
+			if (response.ok) {
+				break;
+			}
+
+			if (response.status === 429 || (response.status >= 500 && response.status < 600)) {
+				if (!isLastEndpoint) {
+					continue;
+				}
+			}
+			break;
+		} catch (error) {
+			if (isLastEndpoint) {
+				throw error;
+			}
+		}
+	}
+
+	if (!response?.ok) {
+		const errorText = response ? await response.text() : "Network error";
+		const status = response?.status ?? 502;
+		const classified = classifyProviderHttpError("gemini", status, errorText);
+		if (classified) throw classified;
+		throw new SearchProviderError("gemini", `Gemini Cloud Code API error (${status}): ${errorText}`, status);
+	}
 
 	if (!response.ok) {
 		const errorText = await response.text();
@@ -410,7 +448,6 @@ export async function searchGemini(params: GeminiSearchParams): Promise<SearchRe
 			// re-resolved access may omit projectId, in which case the seed's
 			// project is still the right tenant for the credential. The
 			// `fetchWithRetry` transport backoff stays INSIDE this attempt — auth
-			// retry wraps transport retry.
 			callGeminiSearch(
 				{
 					accessToken: access.accessToken,
@@ -428,6 +465,7 @@ export async function searchGemini(params: GeminiSearchParams): Promise<SearchRe
 				},
 				params.fetch,
 				params.signal,
+				params.antigravityEndpointMode,
 			),
 		{ sessionId: params.sessionId, signal: params.signal, seed: seed.access },
 	);