@oh-my-pi/pi-ai 18.2.6 → 18.2.8

package/src/embeddings/openai-embeddings.ts

@@ -0,0 +1,141 @@
+import { calculateCost } from "@oh-my-pi/pi-catalog/models";
+import type { Api, FetchImpl, Model, Usage } from "@oh-my-pi/pi-catalog/types";
+import { type } from "@oh-my-pi/omptype";
+import { type ApiKey, withAuth } from "../auth-retry";
+import * as AIError from "../error";
+import type { EmbeddingRequest, EmbeddingResult } from "./types";
+
+export interface EmbeddingOptions {
+	apiKey: ApiKey;
+	fetch?: FetchImpl;
+	signal?: AbortSignal;
+}
+
+/** Non-2xx response from an OpenAI-compatible embeddings endpoint. */
+export class EmbeddingApiError extends AIError.ProviderHttpError {
+	override readonly name = "EmbeddingApiError";
+}
+
+const upstreamResponseSchema = type({
+	data: "object[]",
+	model: "string",
+	"usage?": "object",
+});
+
+interface UpstreamUsage {
+	prompt_tokens?: unknown;
+	total_tokens?: unknown;
+	cost?: unknown;
+}
+
+function finiteNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+function decodeUsage(model: Model<Api>, raw: unknown): Usage {
+	const upstream = raw && typeof raw === "object" ? (raw as UpstreamUsage) : {};
+	const input = finiteNumber(upstream.prompt_tokens) ?? 0;
+	const totalTokens = finiteNumber(upstream.total_tokens) ?? input;
+	const reportedCost = finiteNumber(upstream.cost);
+	const usage: Usage = {
+		input,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens,
+		...(reportedCost !== undefined && { credits: { cost: reportedCost } }),
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: reportedCost ?? 0 },
+	};
+	if (reportedCost === undefined) calculateCost(model, usage);
+	return usage;
+}
+
+function decodeEmbeddings(data: object[], model: Model<Api>): EmbeddingResult["embeddings"] {
+	return data.map((raw, position) => {
+		const index = Reflect.get(raw, "index");
+		const embedding = Reflect.get(raw, "embedding");
+		if (!Number.isInteger(index) || index < 0) {
+			throw new AIError.ProviderResponseError(
+				`${model.provider}/${model.id} embeddings response has an invalid index at data[${position}]`,
+				{ provider: model.provider, kind: "envelope" },
+			);
+		}
+		if (
+			typeof embedding !== "string" &&
+			(!Array.isArray(embedding) || !embedding.every(value => typeof value === "number" && Number.isFinite(value)))
+		) {
+			throw new AIError.ProviderResponseError(
+				`${model.provider}/${model.id} embeddings response has an invalid vector at data[${position}]`,
+				{ provider: model.provider, kind: "envelope" },
+			);
+		}
+		return { index, embedding };
+	});
+}
+
+async function responseError(response: Response, model: Model<Api>): Promise<EmbeddingApiError> {
+	const text = await response.text();
+	let detail = text;
+	let code: string | undefined;
+	try {
+		const parsed: unknown = JSON.parse(text);
+		if (parsed && typeof parsed === "object" && "error" in parsed) {
+			const error = parsed.error;
+			if (error && typeof error === "object") {
+				const envelope = error as { message?: unknown; code?: unknown; type?: unknown };
+				if (typeof envelope.message === "string") detail = envelope.message;
+				if (typeof envelope.code === "string") code = envelope.code;
+				else if (typeof envelope.type === "string") code = envelope.type;
+			}
+		}
+	} catch {}
+	return new EmbeddingApiError(
+		`${model.provider}/${model.id} embeddings API error (${response.status}): ${detail || response.statusText}`,
+		response.status,
+		{ headers: response.headers, code },
+	);
+}
+
+/** Call an OpenAI/OpenRouter-compatible embeddings endpoint. */
+export async function embedOpenAI(
+	model: Model<Api>,
+	request: EmbeddingRequest,
+	options: EmbeddingOptions,
+): Promise<EmbeddingResult> {
+	const fetchImpl = options.fetch ?? fetch;
+	const body = {
+		model: model.id,
+		input: request.input,
+		encoding_format: request.encodingFormat,
+		...(request.dimensions !== undefined && { dimensions: request.dimensions }),
+		...(request.user !== undefined && { user: request.user }),
+	};
+	const response = await withAuth(
+		options.apiKey,
+		async key => {
+			const attempt = await fetchImpl(`${model.baseUrl.replace(/\/+$/, "")}/embeddings`, {
+				method: "POST",
+				headers: { Authorization: `Bearer ${key}`, Accept: "application/json", "Content-Type": "application/json" },
+				body: JSON.stringify(body),
+				signal: options.signal,
+			});
+			if (!attempt.ok) throw await responseError(attempt, model);
+			return attempt;
+		},
+		{ signal: options.signal },
+	);
+
+	const raw: unknown = await response.json();
+	const parsed = upstreamResponseSchema(raw);
+	if (parsed instanceof type.errors) {
+		throw new AIError.ProviderResponseError(
+			`${model.provider}/${model.id} embeddings response is malformed: ${parsed.summary}`,
+			{ provider: model.provider, kind: "envelope" },
+		);
+	}
+	return {
+		embeddings: decodeEmbeddings(parsed.data, model),
+		model: parsed.model,
+		usage: decodeUsage(model, parsed.usage),
+	};
+}

package/src/embeddings/types.ts

@@ -0,0 +1,14 @@
+import type { Usage } from "@oh-my-pi/pi-catalog/types";
+
+export interface EmbeddingRequest {
+	input: string | string[] | number[] | number[][];
+	dimensions?: number;
+	encodingFormat: "float" | "base64";
+	user?: string;
+}
+
+export interface EmbeddingResult {
+	embeddings: Array<{ index: number; embedding: number[] | string }>;
+	model: string;
+	usage: Usage;
+}

package/src/error/auth-classify.ts

@@ -41,8 +41,16 @@ export function isAuthRetryableError(error: unknown): boolean {
 	if (isUsageLimit(error)) return true;
 	if (isAccountPolicyError(error)) return true;
 	if (isInvalidatedOAuthTokenError(error)) return true;
-	const httpStatus = extractHttpStatusFromError(error);
-	const message = error instanceof Error ? error.message : typeof error === "string" ? error : undefined;
+	let httpStatus = extractHttpStatusFromError(error);
+	let message = error instanceof Error ? error.message : typeof error === "string" ? error : undefined;
+	if (typeof error === "object" && error !== null) {
+		if (httpStatus === undefined && "errorStatus" in error && typeof error.errorStatus === "number") {
+			httpStatus = error.errorStatus;
+		}
+		if (message === undefined && "errorMessage" in error && typeof error.errorMessage === "string") {
+			message = error.errorMessage;
+		}
+	}
 	const embeddedStatus = message ? extractHttpStatusFromError({ message }) : undefined;
 	const status = httpStatus ?? embeddedStatus;
 	if (isConcurrencyCapExclusion(status, message)) return false;

package/src/error/classes.ts

@@ -90,8 +90,8 @@ export class AnthropicApiError extends ProviderHttpError {
 	declare readonly headers: Headers;
 	readonly requestId: string | null;
 
-	constructor(status: number, message: string, headers: Headers) {
-		super(message, status, { headers });
+	constructor(status: number, message: string, headers: Headers, options?: { code?: string; cause?: unknown }) {
+		super(message, status, { headers, code: options?.code, cause: options?.cause });
 		this.name = "AnthropicApiError";
 		this.requestId = headers.get("request-id");
 	}
@@ -176,7 +176,27 @@ export class AnthropicApiError extends ProviderHttpError {
 		}
 
 		const detail = bodyChunks.join("").trim() || "status code (no body)";
-		return new AnthropicApiError(response.status, `${response.status} ${detail}`, response.headers);
+		let code: string | undefined;
+		try {
+			const parsed: unknown = JSON.parse(detail);
+			if (parsed && typeof parsed === "object" && "error" in parsed) {
+				const err = parsed.error;
+				if (err && typeof err === "object") {
+					if (
+						"details" in err &&
+						err.details &&
+						typeof err.details === "object" &&
+						"error_code" in err.details &&
+						typeof err.details.error_code === "string"
+					) {
+						code = err.details.error_code;
+					} else if ("type" in err && typeof err.type === "string") {
+						code = err.type;
+					}
+				}
+			}
+		} catch {}
+		return new AnthropicApiError(response.status, `${response.status} ${detail}`, response.headers, { code });
 	}
 }
 

package/src/error/flags.ts

@@ -1,5 +1,5 @@
 import { isUnexpectedSocketCloseMessage } from "@oh-my-pi/pi-utils/fetch-retry";
-import type { Api, AssistantMessage } from "../types";
+import type { Api, AssistantMessage, Usage } from "../types";
 import { AwsCredentialsError } from "./aws";
 import {
 	AnthropicConnectionError,
@@ -194,6 +194,17 @@ const PROVIDER_FINISH_ERROR_PATTERN = /\bProvider (?:returned error finish_reaso
 const EMPTY_RESPONSE_PATTERN = /\bthought-only response without final output\b/i;
 const CONTENT_FILTER_PATTERN = /\b(?:incomplete:\s*)?content_filter\b/i;
 const ACCOUNT_POLICY_PATTERN = /\bcyber_policy\b|trusted access for cyber/i;
+export const ANTHROPIC_ACCOUNT_POLICY_PATTERN =
+	/\b(?:oauth_not_allowed_for_organization|permission_error)\b|\bOAuth authentication is currently not allowed for this organization\b/i;
+
+/** Whether an error message represents an Anthropic account-scoped permission/policy denial. */
+export function isAnthropicAccountPolicyText(text: string, provider?: string, statusArg?: number): boolean {
+	if (provider !== undefined && provider !== "anthropic") return false;
+	const statusCandidate = statusArg ?? (text ? status({ message: text }) : undefined);
+	if (statusCandidate !== undefined && statusCandidate !== 403) return false;
+	return ANTHROPIC_ACCOUNT_POLICY_PATTERN.test(text);
+}
+
 const CODEX_CHATGPT_ACCOUNT_MODEL_POLICY_PATTERN =
 	/\bThe ['"]([^'"\r\n]+)['"] model is not supported when using Codex with a ChatGPT account\./i;
 const CODEX_CHATGPT_ACCOUNT_MODEL_MAX_LENGTH = 256;
@@ -381,6 +392,9 @@ function statusInternal(error: unknown, depth: number): number | undefined {
 		if (typeof errObj.statusCode === "number" && errObj.statusCode >= 100 && errObj.statusCode <= 599) {
 			return errObj.statusCode;
 		}
+		if (typeof errObj.errorStatus === "number" && errObj.errorStatus >= 100 && errObj.errorStatus <= 599) {
+			return errObj.errorStatus;
+		}
 		if (typeof errObj.response === "object" && errObj.response !== null) {
 			const resp = errObj.response as Record<string, unknown>;
 			if (typeof resp.status === "number" && resp.status >= 100 && resp.status <= 599) {
@@ -490,6 +504,8 @@ function classifyText(
 		if (isProviderFinishErrorText(errorMessage)) kinds |= Flag.ProviderFinishError;
 		if (EMPTY_RESPONSE_PATTERN.test(errorMessage)) kinds |= Flag.EmptyResponse | Flag.Transient;
 		if (isContentBlockedText(errorMessage)) kinds |= Flag.ContentBlocked;
+		const statusClean = errorStatus ? errorStatus : (status({ message: errorMessage }) ?? undefined);
+
 		if (
 			ACCOUNT_POLICY_PATTERN.test(errorMessage) ||
 			isCodexChatGPTAccountPolicyText(errorMessage, provider, modelId) ||
@@ -497,9 +513,10 @@ function classifyText(
 		) {
 			kinds |= Flag.AccountPolicy | Flag.ContentBlocked;
 		}
+		if (isAnthropicAccountPolicyText(errorMessage, provider, statusClean)) {
+			kinds |= Flag.AccountPolicy;
+		}
 		if (isAuthFailureText(errorMessage)) kinds |= Flag.AuthFailed;
-
-		const statusClean = errorStatus ? errorStatus : (status({ message: errorMessage }) ?? undefined);
 		const cleanMessage = errorMessage;
 		const isOpaque = isOpaqueStatusBody(cleanMessage);
 
@@ -597,8 +614,12 @@ export function classify(error: unknown, api?: Api): number {
 			if ("errorId" in link && typeof (link as { errorId: unknown }).errorId === "number") {
 				kinds |= (link as { errorId: number }).errorId & KIND_MASK;
 			}
-			if ("code" in link && typeof link.code === "string" && ACCOUNT_POLICY_PATTERN.test(link.code)) {
-				kinds |= Flag.AccountPolicy | Flag.ContentBlocked;
+			if ("code" in link && typeof link.code === "string") {
+				if (ACCOUNT_POLICY_PATTERN.test(link.code)) {
+					kinds |= Flag.AccountPolicy | Flag.ContentBlocked;
+				} else if (ANTHROPIC_ACCOUNT_POLICY_PATTERN.test(link.code)) {
+					kinds |= Flag.AccountPolicy;
+				}
 			}
 		}
 
@@ -635,6 +656,13 @@ export function classify(error: unknown, api?: Api): number {
 			if (code === "overloaded_error" || code === "rate_limit_error") {
 				linkKinds |= Flag.Transient;
 			}
+			if (
+				code === "oauth_not_allowed_for_organization" ||
+				code === "permission_error" ||
+				(codeStatus === 403 && ANTHROPIC_ACCOUNT_POLICY_PATTERN.test(link.message))
+			) {
+				linkKinds |= Flag.AccountPolicy;
+			}
 			if (
 				(codeStatus === 401 || codeStatus === 403) &&
 				!(codeStatus === 403 && parseRateLimitReason(link.message) === "CONCURRENT_LIMIT")
@@ -655,12 +683,12 @@ export function classify(error: unknown, api?: Api): number {
 			linkMessage = link.message;
 		} else if (typeof link === "string") {
 			linkMessage = link;
-		} else if (
-			typeof link === "object" &&
-			"message" in link &&
-			typeof (link as { message: unknown }).message === "string"
-		) {
-			linkMessage = (link as { message: string }).message;
+		} else if (typeof link === "object") {
+			if ("message" in link && typeof link.message === "string") {
+				linkMessage = link.message;
+			} else if ("errorMessage" in link && typeof link.errorMessage === "string") {
+				linkMessage = link.errorMessage;
+			}
 		}
 
 		const linkStatus = status(link);
@@ -834,14 +862,21 @@ export function attach<E extends object>(error: E, id: number): E {
 	return error;
 }
 
+/** Overflow-classification evidence, including errors received before token usage is available. */
+export interface ContextOverflowMessage extends Pick<AssistantMessage, "errorId" | "stopReason" | "errorMessage"> {
+	readonly usage?: Pick<Usage, "input" | "cacheRead" | "cacheWrite">;
+}
+
 /** Provider-reported usage proves context-window excess — authoritative, compaction-owned (#9235). */
-export function isUsageBackedContextOverflow(message: AssistantMessage, contextWindow?: number): boolean {
-	if (!contextWindow) return false;
-	const inputTokens = message.usage.input + message.usage.cacheRead + message.usage.cacheWrite;
+export function isUsageBackedContextOverflow(message: ContextOverflowMessage, contextWindow?: number): boolean {
+	const usage = message.usage;
+	if (!contextWindow || !usage) return false;
+	const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
 	return inputTokens > contextWindow;
 }
 
-export function isContextOverflow(message: AssistantMessage, contextWindow?: number): boolean {
+/** Classify overflow from error flags, available token usage, or provider error text. */
+export function isContextOverflow(message: ContextOverflowMessage, contextWindow?: number): boolean {
 	if (is(message.errorId, Flag.ContextOverflow)) return true;
 	if (isUsageBackedContextOverflow(message, contextWindow)) return true;
 	return message.stopReason === "error" && !!message.errorMessage && matchesOverflowText(message.errorMessage);
@@ -861,7 +896,7 @@ export function isPayloadRejection(message: AssistantMessage): boolean {
  *  Usage-backed overflows are authoritative window excesses and never ambiguous. */
 export function isTextAmbiguousContextOverflow(
 	errorId: number,
-	message: AssistantMessage | undefined,
+	message: ContextOverflowMessage | undefined,
 	contextWindow?: number,
 ): boolean {
 	const overflowFlagged =

package/src/error/rate-limit.ts

@@ -306,7 +306,7 @@ export function calculateRateLimitBackoffMs(reason: RateLimitReason): number {
 
 /** Detect usage/quota limit errors in error messages (persistent, requires credential switch). */
 const USAGE_LIMIT_PATTERN =
-	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?(?:exceeded|reached|insufficient)|额度不足|额度耗尽|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)|balance.?exhausted|run out of credits|out of credits|spending[- _]?limit|personal-team-blocked|clinepass limit|free limit reached on model|access_terminated_error/i;
+	/usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?(?:exceeded|reached|insufficient)|额度不足|额度耗尽|resource.?exhausted|exhausted your capacity|quota will reset|insufficient.?(?:balance|quota)|balance.?exhausted|run out of credits|out of credits|out of (?:extra )?usage|spending[- _]?limit|personal-team-blocked|clinepass limit|free limit reached on model|access_terminated_error/i;
 
 /**
  * HTTP status codes that, absent richer body classification, represent an

package/src/images/google-antigravity.ts

@@ -0,0 +1,180 @@
+import {
+	ANTIGRAVITY_PRIMARY_ENDPOINT,
+	ANTIGRAVITY_SANDBOX_ENDPOINT,
+	fetchAntigravityImageModel,
+} from "@oh-my-pi/pi-catalog/discovery/antigravity";
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import { getAntigravityUserAgent } from "@oh-my-pi/pi-catalog/wire/gemini-headers";
+import { readSseJson } from "@oh-my-pi/pi-utils";
+import { withAuth } from "../auth-retry";
+import * as AIError from "../error";
+import { errorMessage, ImageApiError, usageFromWire } from "./shared";
+import type { GeneratedImage, ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types";
+
+const IMAGE_SYSTEM_INSTRUCTION =
+	"You are an AI image generator. Generate images based on user descriptions. Focus on creating high-quality, visually appealing images that match the user's request.";
+
+interface AntigravityCredentials {
+	accessToken: string;
+	projectId: string;
+}
+
+interface AntigravityTarget {
+	model: string;
+	endpoints: string[];
+}
+
+interface AntigravityChunk {
+	response?: {
+		candidates?: Array<{
+			content?: { parts?: Array<{ text?: string; inlineData?: { data?: string; mimeType?: string } }> };
+		}>;
+		usageMetadata?: { promptTokenCount?: number; candidatesTokenCount?: number };
+	};
+}
+
+export function parseAntigravityCredentials(raw: string): AntigravityCredentials | undefined {
+	try {
+		const parsed = JSON.parse(raw) as { token?: unknown; projectId?: unknown };
+		if (typeof parsed.token === "string" && typeof parsed.projectId === "string") {
+			return { accessToken: parsed.token, projectId: parsed.projectId };
+		}
+	} catch {
+		// Report the same validation error below.
+	}
+	return undefined;
+}
+
+function antigravityEndpoints(model: Model): string[] {
+	const configured = model.baseUrl.replace(/\/+$/, "");
+	return [...new Set([configured, ANTIGRAVITY_PRIMARY_ENDPOINT, ANTIGRAVITY_SANDBOX_ENDPOINT])];
+}
+
+async function resolveTarget(
+	model: Model,
+	credentials: AntigravityCredentials,
+	fetchImpl: ImageGenerationOptions["fetch"],
+	signal?: AbortSignal,
+): Promise<AntigravityTarget> {
+	const endpoints = antigravityEndpoints(model);
+	const advertised = await fetchAntigravityImageModel({
+		token: credentials.accessToken,
+		endpoint: endpoints.length === 1 ? endpoints[0] : undefined,
+		userAgent: getAntigravityUserAgent(),
+		signal,
+		fetcher: fetchImpl,
+	});
+	return advertised
+		? {
+				model: advertised.id,
+				endpoints: [advertised.endpoint, ...endpoints.filter(endpoint => endpoint !== advertised.endpoint)],
+			}
+		: { model: model.requestModelId ?? model.id, endpoints };
+}
+
+function buildRequest(request: ImageGenerationRequest, model: string, projectId: string): Record<string, unknown> {
+	const parts: Array<{ text?: string; inlineData?: GeneratedImage }> = (request.inputImages ?? []).map(image => ({
+		inlineData: image,
+	}));
+	parts.push({ text: request.prompt });
+	const imageConfig =
+		request.aspectRatio || request.imageSize
+			? { aspectRatio: request.aspectRatio, imageSize: request.imageSize }
+			: undefined;
+	return {
+		project: projectId,
+		model,
+		request: {
+			contents: [{ role: "user", parts }],
+			systemInstruction: { parts: [{ text: IMAGE_SYSTEM_INSTRUCTION }] },
+			generationConfig: {
+				responseModalities: ["IMAGE"],
+				...(imageConfig ? { imageConfig } : {}),
+				candidateCount: request.count ?? 1,
+			},
+			safetySettings: [
+				{ category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_ONLY_HIGH" },
+				{ category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_ONLY_HIGH" },
+				{ category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_ONLY_HIGH" },
+				{ category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_ONLY_HIGH" },
+				{ category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "BLOCK_ONLY_HIGH" },
+			],
+		},
+		requestType: "agent",
+		requestId: `agent-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+		userAgent: "antigravity",
+	};
+}
+
+async function parseSse(response: Response, signal?: AbortSignal): Promise<ImageGenerationResult> {
+	if (!response.body) {
+		throw new AIError.ProviderResponseError("Antigravity image response has no body", { kind: "empty-body" });
+	}
+	const images: GeneratedImage[] = [];
+	const texts: string[] = [];
+	let usage = usageFromWire(undefined);
+	for await (const chunk of readSseJson<AntigravityChunk>(response.body, signal)) {
+		for (const candidate of chunk.response?.candidates ?? []) {
+			for (const part of candidate.content?.parts ?? []) {
+				if (part.text) texts.push(part.text);
+				if (part.inlineData?.data && part.inlineData.mimeType) {
+					images.push({ data: part.inlineData.data, mimeType: part.inlineData.mimeType });
+				}
+			}
+		}
+		const metadata = chunk.response?.usageMetadata;
+		if (metadata) {
+			usage = usageFromWire({
+				input_tokens: metadata.promptTokenCount,
+				output_tokens: metadata.candidatesTokenCount,
+			});
+		}
+	}
+	const text = texts.join(" ").trim();
+	return { images, ...(text ? { text } : {}), usage };
+}
+
+export async function generateAntigravityImage(
+	model: Model,
+	request: ImageGenerationRequest,
+	options: ImageGenerationOptions,
+): Promise<ImageGenerationResult> {
+	const fetchImpl = options.fetch ?? fetch;
+	const response = await withAuth(
+		options.apiKey,
+		async rawKey => {
+			const credentials = parseAntigravityCredentials(rawKey);
+			if (!credentials) {
+				throw new AIError.ValidationError("Antigravity image credentials must contain token and projectId");
+			}
+			const target = await resolveTarget(model, credentials, fetchImpl, options.signal);
+			const body = buildRequest(request, target.model, credentials.projectId);
+			let lastError: ImageApiError | undefined;
+			for (let index = 0; index < target.endpoints.length; index++) {
+				const result = await fetchImpl(`${target.endpoints[index]}/v1internal:streamGenerateContent?alt=sse`, {
+					method: "POST",
+					headers: {
+						Authorization: `Bearer ${credentials.accessToken}`,
+						"Content-Type": "application/json",
+						Accept: "text/event-stream",
+						"User-Agent": getAntigravityUserAgent(),
+					},
+					body: JSON.stringify(body),
+					signal: options.signal,
+				});
+				if (result.ok) return result;
+				const text = await result.text();
+				lastError = new ImageApiError(
+					`${model.provider}/${model.id} image request failed (${result.status}): ${errorMessage(text)}`,
+					result.status,
+					{ headers: result.headers },
+				);
+				const retryable = result.status === 429 || result.status >= 500;
+				if (!retryable || index === target.endpoints.length - 1) throw lastError;
+			}
+			throw lastError ?? new AIError.ProviderResponseError("Antigravity image request failed");
+		},
+		{ signal: options.signal },
+	);
+	return parseSse(response, options.signal);
+}

package/src/images/google-generative-ai.ts

@@ -0,0 +1,92 @@
+import type { Model } from "@oh-my-pi/pi-catalog/types";
+import { withAuth } from "../auth-retry";
+import * as AIError from "../error";
+import { errorMessage, ImageApiError, imageBaseUrl, modelHeaders, usageFromWire } from "./shared";
+import type { GeneratedImage, ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types";
+
+interface GeminiPart {
+	text?: string;
+	inlineData?: { data?: string; mimeType?: string };
+}
+
+interface GeminiResponse {
+	candidates?: Array<{ content?: { parts?: GeminiPart[] } }>;
+	usageMetadata?: { promptTokenCount?: number; candidatesTokenCount?: number; totalTokenCount?: number };
+}
+
+export async function generateGoogleImage(
+	model: Model,
+	request: ImageGenerationRequest,
+	options: ImageGenerationOptions,
+): Promise<ImageGenerationResult> {
+	const fetchImpl = options.fetch ?? fetch;
+	const parts: Array<{ text?: string; inlineData?: GeneratedImage }> = (request.inputImages ?? []).map(image => ({
+		inlineData: image,
+	}));
+	parts.push({ text: request.prompt });
+	const imageConfig =
+		request.aspectRatio || request.imageSize
+			? { aspectRatio: request.aspectRatio, imageSize: request.imageSize }
+			: undefined;
+	const body = {
+		contents: [{ role: "user", parts }],
+		generationConfig: {
+			responseModalities: ["IMAGE"],
+			...(imageConfig ? { imageConfig } : {}),
+			...(request.count ? { candidateCount: request.count } : {}),
+		},
+	};
+	const response = await withAuth(
+		options.apiKey,
+		async key => {
+			const result = await fetchImpl(
+				`${imageBaseUrl(model)}/models/${encodeURIComponent(model.requestModelId ?? model.id)}:generateContent`,
+				{
+					method: "POST",
+					headers: {
+						...(await modelHeaders(model, options.signal)),
+						"Content-Type": "application/json",
+						"x-goog-api-key": key,
+					},
+					body: JSON.stringify(body),
+					signal: options.signal,
+				},
+			);
+			const text = await result.text();
+			if (!result.ok) {
+				throw new ImageApiError(
+					`${model.provider}/${model.id} image request failed (${result.status}): ${errorMessage(text)}`,
+					result.status,
+					{ headers: result.headers },
+				);
+			}
+			try {
+				return JSON.parse(text) as GeminiResponse;
+			} catch (cause) {
+				throw new AIError.ProviderResponseError("Gemini image API returned malformed JSON", {
+					provider: model.provider,
+					kind: "envelope",
+					cause,
+				});
+			}
+		},
+		{ signal: options.signal },
+	);
+	const responseParts = response.candidates?.flatMap(candidate => candidate.content?.parts ?? []) ?? [];
+	const images: GeneratedImage[] = [];
+	const textParts: string[] = [];
+	for (const part of responseParts) {
+		if (part.text) textParts.push(part.text);
+		if (part.inlineData?.data && part.inlineData.mimeType) {
+			images.push({ data: part.inlineData.data, mimeType: part.inlineData.mimeType });
+		}
+	}
+	const text = textParts.join("\n").trim();
+	const wireUsage = response.usageMetadata;
+	const usage = usageFromWire(
+		wireUsage
+			? { input_tokens: wireUsage.promptTokenCount, output_tokens: wireUsage.candidatesTokenCount }
+			: undefined,
+	);
+	return { images, ...(text ? { text } : {}), usage };
+}