@oh-my-pi/pi-coding-agent 15.9.67 → 15.10.1

package/src/tools/grouped-file-output.ts

@@ -6,10 +6,127 @@ function isUrlLikePath(filePath: string): boolean {
 	return URL_LIKE_PATH_RE.test(filePath);
 }
 
+// =============================================================================
+// Multi-level path tree
+// =============================================================================
+//
+// File listings (grep / ast-grep / ast-edit / lsp diagnostics / find) used to
+// group by the *immediate* parent directory and print the full directory path in
+// every header. For results spread across a deep tree — or rooted outside cwd,
+// where paths stay absolute — that repeated the shared prefix on every line. The
+// tree below folds single-child directory chains (so the common prefix collapses
+// into one header) and nests the rest, charging the model one token per path
+// segment instead of one per file.
+
+interface PathTreeNode {
+	/** Direct file leaves, in first-seen order. */
+	files: Array<{ name: string; key: string }>;
+	/** Dedup set for `files` (a glob can surface the same path twice on retry). */
+	fileNames: Set<string>;
+	/** Child directories, in first-seen order. */
+	subdirs: Array<{ name: string; node: PathTreeNode }>;
+	/** Dedup index for `subdirs`. */
+	dirIndex: Map<string, PathTreeNode>;
+}
+
+export interface PathTreeInput {
+	/** Path string; absolute, cwd-relative, or url-like. Backslashes are normalized. */
+	path: string;
+	/** Whether the leaf itself is a directory (trailing-slash match from find). */
+	isDir: boolean;
+	/** Opaque key carried onto file events for section lookup. Defaults to `path`. */
+	key?: string;
+}
+
+/** One node emitted while walking the tree: a folded directory or a file leaf. */
+export interface GroupedTreeEvent {
+	kind: "dir" | "file";
+	/** 0-based nesting depth (root children are depth 0). */
+	depth: number;
+	/** Folded chain for dirs (e.g. `a/b/c`, no trailing slash); basename for files. */
+	name: string;
+	/** File key for `kind === "file"`; empty string for directories. */
+	key: string;
+}
+
+function createNode(): PathTreeNode {
+	return { files: [], fileNames: new Set(), subdirs: [], dirIndex: new Map() };
+}
+
+function addFile(node: PathTreeNode, name: string, key: string): void {
+	if (node.fileNames.has(name)) return;
+	node.fileNames.add(name);
+	node.files.push({ name, key });
+}
+
+/**
+ * Build a directory tree from a flat list of paths. URL-like entries are kept
+ * whole as root-level file leaves (they have no meaningful directory structure).
+ * Absolute paths carry a leading empty segment so they share a common `/` root
+ * and fold like any other prefix.
+ */
+export function buildPathTree(entries: Iterable<PathTreeInput>): PathTreeNode {
+	const root = createNode();
+	for (const { path: rawPath, isDir, key } of entries) {
+		const normalized = rawPath.replace(/\\/g, "/");
+		const fileKey = key ?? rawPath;
+		if (isUrlLikePath(normalized)) {
+			addFile(root, normalized, fileKey);
+			continue;
+		}
+		const trimmed = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+		if (trimmed.length === 0) continue;
+		const segments = trimmed.split("/");
+		const dirCount = isDir ? segments.length : segments.length - 1;
+		let node = root;
+		for (let i = 0; i < dirCount; i++) {
+			const segment = segments[i]!;
+			let child = node.dirIndex.get(segment);
+			if (!child) {
+				child = createNode();
+				node.dirIndex.set(segment, child);
+				node.subdirs.push({ name: segment, node: child });
+			}
+			node = child;
+		}
+		if (!isDir) {
+			addFile(node, segments[segments.length - 1]!, fileKey);
+		}
+	}
+	return root;
+}
+
+/**
+ * Depth-first walk yielding directory and file events. Directories collapse their
+ * single-child chains (`a` → `a/b` → `a/b/c`) so a shared prefix becomes one
+ * header. Each node's direct files are emitted before its subdirectories, keeping
+ * a file unambiguously attached to the header above it.
+ */
+export function* walkPathTree(node: PathTreeNode, depth = 0): Generator<GroupedTreeEvent> {
+	for (const file of node.files) {
+		yield { kind: "file", depth, name: file.name, key: file.key };
+	}
+	for (const subdir of node.subdirs) {
+		let dirNode = subdir.node;
+		const parts = [subdir.name];
+		while (dirNode.files.length === 0 && dirNode.subdirs.length === 1) {
+			const only = dirNode.subdirs[0]!;
+			parts.push(only.name);
+			dirNode = only.node;
+		}
+		yield { kind: "dir", depth, name: parts.join("/"), key: "" };
+		yield* walkPathTree(dirNode, depth + 1);
+	}
+}
+
+// =============================================================================
+// Grouped file output (grep / ast-grep / ast-edit / lsp diagnostics)
+// =============================================================================
+
 /**
  * One file's contribution to a grouped file output. The header itself is generated
- * by `formatGroupedFiles` (single `#` for root files, `##` for files inside a dir);
- * use `headerSuffix` to tack on extras like ` (1 replacement)`.
+ * by `formatGroupedFiles` (one `#` per nesting level); use `headerSuffix` to tack
+ * on extras like ` (1 replacement)`.
  */
 export interface GroupedFileSection {
 	/** Optional suffix appended to the file header. */
@@ -28,76 +145,183 @@ export interface GroupedFilesOutput {
 }
 
 /**
- * Render a list of files as directory-grouped sections shared by grep, ast-grep,
- * ast-edit, and the LSP diagnostic formatter.
+ * Render a list of files as a multi-level, prefix-folded directory tree shared by
+ * grep, ast-grep, ast-edit, and the LSP diagnostic formatter.
  *
- * Layout:
- *   # dir/
- *   ## file.ts
+ * Layout (one `#` per level; the shared prefix folds into the top header):
+ *   # packages/pkg/src/
+ *   ## root.ts
  *   …body…
- *
- *   # otherdir/
- *   ## other.ts
+ *   ## nested/
+ *   ### child.ts
  *   …body…
  *
- * Files in the project root (directory `.`) become single-`#` headers without a
- * `## file` line, matching the existing convention.
+ * Files in the (folded) project root become single-`#` headers with no parent
+ * directory line. A blank line precedes every directory header and every
+ * root-level file so the renderers can split the output into collapsible groups.
  */
 export function formatGroupedFiles(
 	files: string[],
 	renderFile: (filePath: string) => GroupedFileSection,
 ): GroupedFilesOutput {
-	const filesByDirectory = new Map<string, string[]>();
+	const sections = new Map<string, GroupedFileSection>();
+	const inputs: PathTreeInput[] = [];
 	for (const filePath of files) {
-		const directory = isUrlLikePath(filePath) ? "." : path.dirname(filePath).replace(/\\/g, "/");
-		if (!filesByDirectory.has(directory)) {
-			filesByDirectory.set(directory, []);
-		}
-		filesByDirectory.get(directory)!.push(filePath);
+		if (sections.has(filePath)) continue;
+		const section = renderFile(filePath);
+		if (section.skip) continue;
+		sections.set(filePath, section);
+		inputs.push({ path: filePath, isDir: false, key: filePath });
 	}
 
+	const tree = buildPathTree(inputs);
 	const model: string[] = [];
 	const display: string[] = [];
+	let emitted = false;
 
-	const pushSeparatorIfNeeded = () => {
-		if (model.length > 0) {
+	for (const event of walkPathTree(tree)) {
+		const hashes = "#".repeat(event.depth + 1);
+		const needsSeparator = emitted && (event.depth === 0 || event.kind === "dir");
+		if (needsSeparator) {
 			model.push("");
 			display.push("");
 		}
+		emitted = true;
+		if (event.kind === "dir") {
+			const header = `${hashes} ${event.name}/`;
+			model.push(header);
+			display.push(header);
+			continue;
+		}
+		const section = sections.get(event.key)!;
+		const header = `${hashes} ${event.name}${section.headerSuffix ?? ""}`;
+		model.push(header, ...section.modelLines);
+		display.push(header, ...(section.displayLines ?? section.modelLines));
+	}
+
+	return { model, display };
+}
+
+// =============================================================================
+// Parsing grouped output back into per-line context (TUI renderers)
+// =============================================================================
+
+const GROUPED_HEADER_RE = /^(#+)\s+(.*)$/;
+const HEADER_SUFFIX_RE = /\s+\([^)]*\)\s*$/;
+const HEADER_HASH_TAG_RE = /#[0-9a-f]+$/i;
+
+/** Per-line classification of grouped output, used by renderers for hyperlinks. */
+export interface GroupedLineContext {
+	/** Directory header, file header, or any non-header body/content line. */
+	kind: "dir" | "file" | "content";
+	/** Number of leading `#` for headers; 0 for content lines. */
+	depth: number;
+	/** Resolved absolute path of the dir/file a header points at (when resolvable). */
+	headerPath?: string;
+	/** For content lines, the absolute path of the owning file (line hyperlinks). */
+	filePath?: string;
+	/** Header is an internal/url-like target the caller resolves itself. */
+	isUrl?: boolean;
+}
+
+function resolveGroupedPath(parent: string | undefined, name: string): string | undefined {
+	if (parent === undefined) return undefined;
+	if (name === "" || name === ".") return parent;
+	// `path.resolve` keeps an absolute `name` intact (out-of-cwd results) while
+	// joining a relative folded chain (`packages/pkg/src`) onto the parent.
+	return path.resolve(parent, name);
+}
+
+/**
+ * Walk grouped output lines, tracking a directory stack keyed by header depth, so
+ * each header and body line can be linked back to its absolute filesystem path.
+ * Reconstruction is stack-based (not per-blank-group) so nested directory headers
+ * resolve correctly across the whole output.
+ *
+ * `headerBase` is the directory the displayed (folded) header paths are relative
+ * to — for grep/ast tools that is the session cwd, since display paths are
+ * formatted relative to cwd regardless of the (sub)directory the search was
+ * scoped to. `fileScope` is the initial owning file for body lines that appear
+ * before any header (single-file scopes have no `#` headers); it defaults to
+ * `headerBase` and should be passed the scoped file's absolute path.
+ */
+export function classifyGroupedLines(
+	lines: readonly string[],
+	headerBase: string | undefined,
+	fileScope: string | undefined = headerBase,
+): GroupedLineContext[] {
+	const result: GroupedLineContext[] = [];
+	const dirAtDepth = new Map<number, string>();
+	// Body lines before any header (single-file scopes) link to the scoped file.
+	let currentFile = fileScope;
+
+	const clearDeeper = (depth: number) => {
+		for (const key of dirAtDepth.keys()) {
+			if (key >= depth) dirAtDepth.delete(key);
+		}
 	};
 
-	for (const [directory, dirFiles] of filesByDirectory) {
-		if (directory === ".") {
-			for (const filePath of dirFiles) {
-				const section = renderFile(filePath);
-				if (section.skip) continue;
-				pushSeparatorIfNeeded();
-				const headerName = isUrlLikePath(filePath) ? filePath : path.basename(filePath);
-				const header = `# ${headerName}${section.headerSuffix ?? ""}`;
-				model.push(header, ...section.modelLines);
-				display.push(header, ...(section.displayLines ?? section.modelLines));
-			}
+	for (const line of lines) {
+		const match = GROUPED_HEADER_RE.exec(line);
+		if (!match) {
+			result.push({ kind: "content", depth: 0, filePath: currentFile });
 			continue;
 		}
-
-		const sections: Array<{ filePath: string; section: GroupedFileSection }> = [];
-		for (const filePath of dirFiles) {
-			const section = renderFile(filePath);
-			if (section.skip) continue;
-			sections.push({ filePath, section });
+		const depth = match[1]!.length;
+		const rest = match[2]!.trimEnd();
+		if (isUrlLikePath(rest)) {
+			clearDeeper(depth);
+			currentFile = undefined;
+			result.push({ kind: "file", depth, isUrl: true });
+			continue;
 		}
-		if (sections.length === 0) continue;
-
-		pushSeparatorIfNeeded();
-		const dirHeader = `# ${directory}/`;
-		model.push(dirHeader);
-		display.push(dirHeader);
-		for (const { filePath, section } of sections) {
-			const fileHeader = `## ${path.basename(filePath)}${section.headerSuffix ?? ""}`;
-			model.push(fileHeader, ...section.modelLines);
-			display.push(fileHeader, ...(section.displayLines ?? section.modelLines));
+		const parent = depth > 1 ? dirAtDepth.get(depth - 1) : headerBase;
+		if (rest.endsWith("/")) {
+			const name = rest.slice(0, -1).replace(HEADER_SUFFIX_RE, "");
+			const abs = resolveGroupedPath(parent, name);
+			clearDeeper(depth);
+			if (abs !== undefined) dirAtDepth.set(depth, abs);
+			currentFile = undefined;
+			result.push({ kind: "dir", depth, headerPath: abs });
+			continue;
 		}
+		const name = rest.replace(HEADER_SUFFIX_RE, "").replace(HEADER_HASH_TAG_RE, "");
+		const abs = name ? resolveGroupedPath(parent, name) : undefined;
+		currentFile = abs;
+		result.push({ kind: "file", depth, headerPath: abs });
 	}
 
-	return { model, display };
+	return result;
+}
+
+/**
+ * Split line indices into blank-line-separated groups, mirroring
+ * `splitGroupsByBlankLine`: when any blank line is present, break on runs of
+ * blanks; otherwise return a single group of the non-empty lines. Returning
+ * indices lets callers slice parallel arrays (raw lines, styled lines, contexts).
+ */
+export function groupLineIndicesByBlank(rawLines: readonly string[]): number[][] {
+	const hasSeparators = rawLines.some(line => line.trim().length === 0);
+	const groups: number[][] = [];
+	if (hasSeparators) {
+		let current: number[] = [];
+		for (let i = 0; i < rawLines.length; i++) {
+			if (rawLines[i]!.trim().length === 0) {
+				if (current.length > 0) {
+					groups.push(current);
+					current = [];
+				}
+				continue;
+			}
+			current.push(i);
+		}
+		if (current.length > 0) groups.push(current);
+	} else {
+		const current: number[] = [];
+		for (let i = 0; i < rawLines.length; i++) {
+			if (rawLines[i]!.trim().length > 0) current.push(i);
+		}
+		if (current.length > 0) groups.push(current);
+	}
+	return groups;
 }

package/src/tools/image-gen.ts

@@ -1,6 +1,6 @@
 import * as os from "node:os";
 import * as path from "node:path";
-import { getAntigravityUserAgent, getEnvApiKey, type Model } from "@oh-my-pi/pi-ai";
+import { type ApiKey, getAntigravityUserAgent, getEnvApiKey, type Model, withAuth } from "@oh-my-pi/pi-ai";
 import {
 	CODEX_BASE_URL,
 	getCodexAccountId,
@@ -20,6 +20,7 @@ import {
 } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import packageJson from "../../package.json" with { type: "json" };
+
 import { isAuthenticated, type ModelRegistry } from "../config/model-registry";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import { ohMyPiXAIUserAgent, resolveXAIHttpCredentials } from "../lib/xai-http";
@@ -864,7 +865,10 @@ async function generateOpenAIHostedImage(
 
 	if (!response.ok) {
 		const errorText = await response.text();
-		throw new Error(`OpenAI image request failed (${response.status}): ${getOpenAIResponseErrorMessage(errorText)}`);
+		throw Object.assign(
+			new Error(`OpenAI image request failed (${response.status}): ${getOpenAIResponseErrorMessage(errorText)}`),
+			{ status: response.status },
+		);
 	}
 
 	const contentType = response.headers.get("content-type") ?? "";
@@ -1037,13 +1041,16 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 					throw new Error("Missing active GPT model for OpenAI image generation");
 				}
 
-				const parsed = await generateOpenAIHostedImage(
-					apiKey.apiKey,
-					apiKey.model,
-					params,
-					resolvedImages,
-					requestSignal,
+				const hostedModel = apiKey.model;
+				const hostedKey: ApiKey = ctx.modelRegistry.resolver(hostedModel.provider, {
 					sessionId,
+					baseUrl: hostedModel.baseUrl,
+				});
+
+				const parsed = await withAuth(
+					hostedKey,
+					key => generateOpenAIHostedImage(key, hostedModel, params, resolvedImages, requestSignal, sessionId),
+					{ signal: requestSignal },
 				);
 
 				if (parsed.images.length === 0) {
@@ -1088,38 +1095,57 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 				}
 
 				const prompt = assemblePrompt(params);
-				const requestBody = buildAntigravityRequest(
-					prompt,
-					model,
-					apiKey.projectId,
-					params.aspect_ratio,
-					params.image_size,
-					resolvedImages,
-				);
-
-				const response = await fetch(`${ANTIGRAVITY_ENDPOINT}/v1internal:streamGenerateContent?alt=sse`, {
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${apiKey.apiKey}`,
-						"Content-Type": "application/json",
-						Accept: "text/event-stream",
-						"User-Agent": getAntigravityUserAgent(),
-					},
-					body: JSON.stringify(requestBody),
-					signal: requestSignal,
+				const antigravityKey: ApiKey = ctx.modelRegistry.resolver("google-antigravity", {
+					sessionId,
 				});
 
-				if (!response.ok) {
-					const errorText = await response.text();
-					let message = errorText;
-					try {
-						const parsed = JSON.parse(errorText) as { error?: { message?: string } };
-						message = parsed.error?.message ?? message;
-					} catch {
-						// Keep raw text.
-					}
-					throw new Error(`Antigravity image request failed (${response.status}): ${message}`);
-				}
+				const response = await withAuth(
+					antigravityKey,
+					async key => {
+						// On a retry the resolver yields the raw stored credential JSON
+						// ({ token, projectId }); the initial seed is the already-parsed
+						// access token. Tolerate both, falling back to the seed projectId.
+						const rotated = parseAntigravityCredentials(key);
+						const bearer = rotated?.accessToken ?? key;
+						const projectId = rotated?.projectId ?? apiKey.projectId!;
+						const requestBody = buildAntigravityRequest(
+							prompt,
+							model,
+							projectId,
+							params.aspect_ratio,
+							params.image_size,
+							resolvedImages,
+						);
+
+						const resp = await fetch(`${ANTIGRAVITY_ENDPOINT}/v1internal:streamGenerateContent?alt=sse`, {
+							method: "POST",
+							headers: {
+								Authorization: `Bearer ${bearer}`,
+								"Content-Type": "application/json",
+								Accept: "text/event-stream",
+								"User-Agent": getAntigravityUserAgent(),
+							},
+							body: JSON.stringify(requestBody),
+							signal: requestSignal,
+						});
+
+						if (!resp.ok) {
+							const errorText = await resp.text();
+							let message = errorText;
+							try {
+								const parsedErr = JSON.parse(errorText) as { error?: { message?: string } };
+								message = parsedErr.error?.message ?? message;
+							} catch {
+								// Keep raw text.
+							}
+							throw Object.assign(new Error(`Antigravity image request failed (${resp.status}): ${message}`), {
+								status: resp.status,
+							});
+						}
+						return resp;
+					},
+					{ signal: requestSignal },
+				);
 
 				const parsed = await parseAntigravitySseForImage(response, requestSignal);
 				const responseText = parsed.text.length > 0 ? parsed.text.join(" ") : undefined;
@@ -1191,28 +1217,41 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 					: xaiBaseBody;
 				const xaiEndpoint = isEdit ? "/images/edits" : "/images/generations";
 
-				const xaiResponse = await fetch(`${xaiCreds.baseURL}${xaiEndpoint}`, {
-					method: "POST",
-					headers: {
-						Authorization: `Bearer ${xaiCreds.apiKey}`,
-						"Content-Type": "application/json",
-						"User-Agent": ohMyPiXAIUserAgent(),
-					},
-					body: JSON.stringify(xaiBody),
-					signal: requestSignal,
+				const xaiKey: ApiKey = ctx.modelRegistry.resolver(xaiCreds.provider, {
+					sessionId,
+					baseUrl: xaiCreds.baseURL,
 				});
 
-				const xaiRawText = await xaiResponse.text();
-				if (!xaiResponse.ok) {
-					let message = xaiRawText;
-					try {
-						const parsedErr = JSON.parse(xaiRawText) as { error?: { message?: string } };
-						message = parsedErr.error?.message ?? message;
-					} catch {
-						// Keep raw text.
-					}
-					throw new Error(`xAI image request failed (${xaiResponse.status}): ${message}`);
-				}
+				const xaiRawText = await withAuth(
+					xaiKey,
+					async key => {
+						const resp = await fetch(`${xaiCreds.baseURL}${xaiEndpoint}`, {
+							method: "POST",
+							headers: {
+								Authorization: `Bearer ${key}`,
+								"Content-Type": "application/json",
+								"User-Agent": ohMyPiXAIUserAgent(),
+							},
+							body: JSON.stringify(xaiBody),
+							signal: requestSignal,
+						});
+						const rawText = await resp.text();
+						if (!resp.ok) {
+							let message = rawText;
+							try {
+								const parsedErr = JSON.parse(rawText) as { error?: { message?: string } };
+								message = parsedErr.error?.message ?? message;
+							} catch {
+								// Keep raw text.
+							}
+							throw Object.assign(new Error(`xAI image request failed (${resp.status}): ${message}`), {
+								status: resp.status,
+							});
+						}
+						return rawText;
+					},
+					{ signal: requestSignal },
+				);
 
 				const xaiData = JSON.parse(xaiRawText) as {
 					data?: Array<{ b64_json?: string; url?: string }>;
@@ -1269,30 +1308,34 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 					messages: [{ role: "user" as const, content: contentParts }],
 				};
 
-				const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
-					method: "POST",
-					headers: {
-						"Content-Type": "application/json",
-						Authorization: `Bearer ${apiKey.apiKey}`,
-						"HTTP-Referer": "https://omp.sh/",
-						"X-OpenRouter-Title": "Oh-My-Pi",
-						"X-OpenRouter-Categories": "cli-agent",
-					},
-					body: JSON.stringify(requestBody),
-					signal: requestSignal,
-				});
-
-				const rawText = await response.text();
-				if (!response.ok) {
-					let message = rawText;
-					try {
-						const parsed = JSON.parse(rawText) as { error?: { message?: string } };
-						message = parsed.error?.message ?? message;
-					} catch {
-						// Keep raw text.
+				const rawText = await withAuth(apiKey.apiKey, async key => {
+					const resp = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							Authorization: `Bearer ${key}`,
+							"HTTP-Referer": "https://omp.sh/",
+							"X-OpenRouter-Title": "Oh-My-Pi",
+							"X-OpenRouter-Categories": "cli-agent",
+						},
+						body: JSON.stringify(requestBody),
+						signal: requestSignal,
+					});
+					const text = await resp.text();
+					if (!resp.ok) {
+						let message = text;
+						try {
+							const parsed = JSON.parse(text) as { error?: { message?: string } };
+							message = parsed.error?.message ?? message;
+						} catch {
+							// Keep raw text.
+						}
+						throw Object.assign(new Error(`OpenRouter image request failed (${resp.status}): ${message}`), {
+							status: resp.status,
+						});
 					}
-					throw new Error(`OpenRouter image request failed (${response.status}): ${message}`);
-				}
+					return text;
+				});
 
 				const data = JSON.parse(rawText) as OpenRouterResponse;
 				const message = data.choices?.[0]?.message;
@@ -1360,30 +1403,34 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 				generationConfig,
 			};
 
-			const response = await fetch(
-				`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`,
-				{
-					method: "POST",
-					headers: {
-						"Content-Type": "application/json",
-						"x-goog-api-key": apiKey.apiKey,
+			const rawText = await withAuth(apiKey.apiKey, async key => {
+				const resp = await fetch(
+					`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`,
+					{
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							"x-goog-api-key": key,
+						},
+						body: JSON.stringify(requestBody),
+						signal: requestSignal,
 					},
-					body: JSON.stringify(requestBody),
-					signal: requestSignal,
-				},
-			);
-
-			const rawText = await response.text();
-			if (!response.ok) {
-				let message = rawText;
-				try {
-					const parsed = JSON.parse(rawText) as { error?: { message?: string } };
-					message = parsed.error?.message ?? message;
-				} catch {
-					// Keep raw text.
+				);
+				const text = await resp.text();
+				if (!resp.ok) {
+					let message = text;
+					try {
+						const parsed = JSON.parse(text) as { error?: { message?: string } };
+						message = parsed.error?.message ?? message;
+					} catch {
+						// Keep raw text.
+					}
+					throw Object.assign(new Error(`Gemini image request failed (${resp.status}): ${message}`), {
+						status: resp.status,
+					});
 				}
-				throw new Error(`Gemini image request failed (${response.status}): ${message}`);
-			}
+				return text;
+			});
 
 			const data = JSON.parse(rawText) as GeminiGenerateContentResponse;
 			const responseParts = combineParts(data);