@warlock.js/ai-google 4.13.0 → 4.15.0

package/CHANGELOG.md

@@ -4,6 +4,41 @@ All notable changes to `@warlock.js/ai-google` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 4.15.0
+
+### Added
+
+- **`GeminiImageModel` — a Gemini-native image path over `ai.models.generateContent`** (new `src/gemini-image.ts`, exported as `GeminiImageModel`). Requests `responseModalities: ["TEXT", "IMAGE"]` (override the list verbatim with `options.responseModalities`), maps `aspectRatio` / `imageSize` / `personGeneration` onto Gemini's `config.imageConfig`, and reshapes inline image parts that come back into the **same** `GeneratedImage[]` (`{ type: "base64", base64, mediaType }`, `image/png` fallback) the Imagen path emits — so `ai.image()`'s envelope is unchanged for callers
+- **Token usage is passed through on the Gemini image path instead of hard-zeroed.** Whatever `usageMetadata` Google attaches becomes `usage.input` / `output` / `total` (plus `cachedTokens` / `reasoningTokens` when reported `> 0`); only an absent block collapses to zeros. The Imagen path stays a flat zero because Imagen reports no tokens at all. Price these models with `{ input, output }` rather than `{ perImage }`, and check the first live `usage` — whether these models report tokens is not confirmed here. The mapping is now a shared `applyGoogleUsage` util used by both the chat model and the image model, so one rule decides what a Gemini token report means package-wide
+- A response with **no image part is never a silent empty success**: a blocked prompt (`promptFeedback.blockReason`) or a safety/policy `finishReason` (`SAFETY`, `IMAGE_SAFETY`, `PROHIBITED_CONTENT`, `IMAGE_PROHIBITED_CONTENT`, `RECITATION`, `IMAGE_RECITATION`, `BLOCKLIST`, `SPII`) throws `ContentFilterError` carrying the reason; a text-only answer throws `ProviderError` **quoting the text the model returned**; anything else throws `ProviderError` naming the part count and finish reason
+
+### Fixed
+
+- **`google.image({ name: "gemini-…" })` no longer hits the endpoint that 404s it.** `ai.models.generateImages` routes to `{model}:predict` (`generateImages` → `generateImagesInternal` → `formatMap('{model}:predict', …)` in `@google/genai`'s bundle), which does not serve the Gemini image models — the call came back `404 models/… is not found for API version v1beta, or is not supported for predict`. `GoogleSDK.image()` now picks the transport from the id: a `gemini-` id (with an optional `models/` resource prefix) gets the new `generateContent` implementation, everything else keeps `GoogleImageModel` / `generateImages`. **Scope of the proof:** two levels. Measured here — on the new transport such an id got as far as a quota error (HTTP 429) instead of the 404, which establishes that the endpoint accepts the id. Reported by the maintainer — once billing was enabled on the project, the path returned an image end-to-end from an application running a locally linked build of this package. No test in this package calls Google; the suite proves the request shape and the error mapping, not the round trip
+
+### Deprecated
+
+- **Google has deprecated `generateImages`, the transport the `imagen-*` path still uses.** Verbatim from the `@google/genai` runtime warning: *"The generateImages method is deprecated and will be removed in the next major release (not before Jan. 1 2027). Please use the generateContent method with image models instead. See https://ai.google.dev/gemini-api/docs/deprecations#imagen-models and https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/capabilities/image-generation#generate-images"* (`editImage` carries the same notice.) Nothing breaks today and the Imagen path is unchanged, but it is on a clock: new image work should prefer a `gemini-` id. The warning is emitted by `@google/genai` ≥ 2.17; with the bump below, this package now prints it whenever the `imagen-*` path is used
+
+### Changed
+
+- **`@google/genai` moves from `^2.4.0` to `^2.17.1`** (2.17.1 is what installs today). The Gemini image path does not depend on the bump — `models.generateContent` exists in both — but the older range predates the deprecation notice above and predates `ai.interactions`, so staying on it meant documenting an SDK surface the package could not reach. The 11 suites / 149 specs in this package pass unchanged on 2.17.1. Note this re-resolved the whole workspace lockfile, not just this package's dependency
+- `GoogleSDK.image()` returns `GeminiImageModel` for a `gemini-` id. This is **routing, not validation** — no id is rejected locally: an id matching neither family takes the `generateImages` route, the only route that existed before, so every id that reached Google before still reaches Google the same way and still fails (or succeeds) at the provider
+
+### Not included
+
+- **The `interactions` API is not used.** `@google/genai` ≥ 2.17 adds `ai.interactions.create({ model, input, response_format: { type: "image", … } })` with images at `interaction.output_image.data` and a different snake_case usage shape (`total_input_tokens` …). It is reachable now that the SDK is on 2.17.1, but nothing in this package calls it: it would need its own usage mapper and its own error surface, and its own request type already marks `response_modalities` / `response_mime_type` deprecated. If it lands it will be an **opt-in config flag**, not id routing
+
+## 4.14.0
+
+### Removed
+
+- **BREAKING — `isGoogleImageModel()` and `GOOGLE_IMAGE_MODEL_PREFIXES` are gone from the public API.** Both were dropped from the package entrypoint and the module deleted; importing either from `@warlock.js/ai-google` is now a compile error. With the construction-time guard gone (below) they enforced nothing and only invited callers to re-implement a model allow-list the framework does not own — a model id is the provider's to rule on, so there is nothing left for a local list to say. Callers that branched on the Imagen family should match on the id themselves (`name.startsWith("imagen-")`) or, better, stop branching and let the provider answer
+
+### Changed
+
+- `google.image({ name })` no longer rejects a non-`imagen-*` model id at construction — the id is passed through to `ai.models.generateImages` as given, so an id Google does not serve now fails as a typed provider error instead of a local `InvalidRequestError`
+
 ## 4.12.0
 
 ### Changed

package/cjs/index.cjs

@@ -3,6 +3,34 @@ let _google_genai = require("@google/genai");
 let _warlock_js_ai = require("@warlock.js/ai");
 let _warlock_js_logger = require("@warlock.js/logger");
 
+//#region ../ai-google/src/utils/apply-google-usage.ts
+/**
+* Fold a Gemini `usageMetadata` block into a running neutral `Usage`
+* accumulator. Shared by every `generateContent`-backed surface — the
+* chat model's `complete()`, its streaming loop (where the final chunk
+* carries cumulative totals), and the Gemini image model — so one
+* mapping decides what a Gemini token report means package-wide.
+*
+* Cache-read hits (`cachedContentTokenCount`, implicit or explicit
+* context caching) surface as `cachedTokens`; the thinking-phase tokens
+* of a reasoning model (`thoughtsTokenCount`) surface as
+* `reasoningTokens`. Both are emitted only when reported `> 0` so an
+* absent channel leaves the field undefined rather than a false zero.
+*
+* `total` falls back to `input + output` when Google omits
+* `totalTokenCount`.
+*/
+function applyGoogleUsage(usage, raw) {
+	usage.input = raw.promptTokenCount ?? usage.input;
+	usage.output = raw.candidatesTokenCount ?? usage.output;
+	usage.total = raw.totalTokenCount ?? usage.input + usage.output;
+	const cached = raw.cachedContentTokenCount;
+	if (cached && cached > 0) usage.cachedTokens = cached;
+	const reasoning = raw.thoughtsTokenCount;
+	if (reasoning && reasoning > 0) usage.reasoningTokens = reasoning;
+}
+
+//#endregion
 //#region ../ai-google/src/utils/map-finish-reason.ts
 const finishReasonMap = {
 	STOP: "stop",
@@ -301,7 +329,7 @@ function buildContext(shape) {
 
 //#endregion
 //#region ../ai-google/src/embedder.ts
-const LOG_MODULE$2 = "ai.google";
+const LOG_MODULE$3 = "ai.google";
 /**
 * Token usage is not returned by Gemini's `embedContent`, so every
 * embedding result reports a zeroed `EmbeddingUsage` (honest absence,
@@ -367,7 +395,7 @@ var GoogleEmbedder = class {
 	* and return the raw vectors in input order.
 	*/
 	async request(inputs) {
-		this.logger.debug(LOG_MODULE$2, "embedder.request", "embedContent", {
+		this.logger.debug(LOG_MODULE$3, "embedder.request", "embedContent", {
 			model: this.name,
 			count: inputs.length
 		});
@@ -380,7 +408,7 @@ var GoogleEmbedder = class {
 			});
 		} catch (thrown) {
 			const wrapped = wrapGoogleError(thrown);
-			this.logger.error(LOG_MODULE$2, "embedder.error", wrapped.message, {
+			this.logger.error(LOG_MODULE$3, "embedder.error", wrapped.message, {
 				code: wrapped.code,
 				context: wrapped.context
 			});
@@ -388,7 +416,7 @@ var GoogleEmbedder = class {
 		}
 		const vectors = (response.embeddings ?? []).map((embedding) => embedding.values ?? []);
 		if (this.dimensions === 0 && vectors[0]) this.dimensions = vectors[0].length;
-		this.logger.debug(LOG_MODULE$2, "embedder.response", "embedContent returned", {
+		this.logger.debug(LOG_MODULE$3, "embedder.response", "embedContent returned", {
 			count: vectors.length,
 			dimensions: this.dimensions
 		});
@@ -397,34 +425,226 @@ var GoogleEmbedder = class {
 };
 
 //#endregion
-//#region ../ai-google/src/known-image-models.ts
+//#region ../ai-google/src/gemini-image.ts
+const LOG_MODULE$2 = "ai.google";
+/**
+* Response modalities requested when the caller names none.
+*
+* `IMAGE` is the modality this adapter extracts; `TEXT` rides along so
+* a model that narrates what it drew is not answering outside the set
+* it was granted (the narration is then dropped — only inline image
+* parts become `GeneratedImage`s).
+*
+* *Unverified:* which pairing any individual Gemini image model
+* requires is not established here — no spec or run in this package
+* touches the live API. `options.responseModalities` replaces this list
+* verbatim for a model that wants something else.
+*/
+const DEFAULT_RESPONSE_MODALITIES = ["TEXT", "IMAGE"];
 /**
-* Model-id prefixes Google exposes through the **Imagen** image API
-* (`ai.models.generateImages`) — `imagen-3.0-*`, `imagen-4.0-*`, and
-* their fast/ultra variants. All are per-image-metered and return
-* base64 bytes.
-*
-* Gemini's *native* image output (`gemini-2.5-flash-image`) is a
-* different surface (`generateContent` with `responseModalities`) and
-* is intentionally NOT routed here — `google.image()` targets the
-* dedicated Imagen endpoint only.
-*
-* Used by {@link isGoogleImageModel} for the construction-time guard so
-* `google.image({ name: "gemini-2.5-flash" })` fails fast with a
-* curated error rather than a downstream 400.
+* Gemini `finishReason` values that mean generation was stopped by a
+* safety / policy rule rather than by the model simply not drawing.
+* Taken from the `FinishReason` enum in `@google/genai`'s own type
+* declarations, whose doc comments describe each of these as content
+* or image generation being "stopped" for safety, prohibited content,
+* recitation, blocklist, or SPII.
 */
-const GOOGLE_IMAGE_MODEL_PREFIXES = ["imagen-"];
+const FILTERED_FINISH_REASONS = new Set([
+	"SAFETY",
+	"IMAGE_SAFETY",
+	"PROHIBITED_CONTENT",
+	"IMAGE_PROHIBITED_CONTENT",
+	"RECITATION",
+	"IMAGE_RECITATION",
+	"BLOCKLIST",
+	"SPII"
+]);
+/** How much of a text-only answer to quote back inside the error message. */
+const TEXT_EXCERPT_LIMIT = 200;
 /**
-* True when `name` is a recognized Google Imagen model. A prefix match
-* so dated/variant ids (`imagen-4.0-ultra-generate-001`) are covered
-* without an exact-list maintenance burden.
+* Gemini-native implementation of `ImageModelContract`, via
+* `ai.models.generateContent` with `config.responseModalities`
+* including `"IMAGE"`.
+*
+* **Why a second image adapter.** `GoogleImageModel` calls
+* `ai.models.generateImages`, which the `@google/genai` bundle routes
+* to `{model}:predict` (`generateImages` → `generateImagesInternal` →
+* `formatMap('{model}:predict', …)`). A Gemini image model is not
+* served there: asking for one returns Google's
+* `404 … is not found for API version v1beta, or is not supported for
+* predict`. `generateContent` is the SDK's own named replacement — its
+* runtime deprecation notice for `generateImages` reads "Please use the
+* generateContent method with image models instead" — so that is the
+* transport this class speaks, hence a separate class rather than a
+* branch inside `image.ts`.
+*
+* **Same envelope.** Inline image parts are mapped to the identical
+* `GeneratedImage[]` shape `GoogleImageModel` produces, so `ai.image()`
+* callers see no difference between the two paths.
+*
+* **Token usage is passed through, not zeroed.** The Imagen path
+* returns a hard `{ 0, 0, 0 }` because Imagen reports no tokens at all;
+* here, whatever `usageMetadata` Google attaches is mapped by the same
+* {@link applyGoogleUsage} the chat model uses, and only an absent
+* block collapses to zeros. Price accordingly.
+*
+* **No model-id validation.** `config.name` is forwarded to
+* `generateContent` exactly as given; nothing here inspects it. An id
+* Google does not serve fails at Google, wrapped into the typed
+* `AIError` hierarchy — never with a local throw.
+*
+* **Evidence, in two tiers.** No spec in this package calls Google.
+* *Measured here:* a `gemini-*` image id, which 404s on the `predict`
+* transport, reached the model on this one and came back with a quota
+* error (HTTP 429) — the endpoint accepts the id. *Reported by the
+* maintainer:* once billing was enabled on the project, an image came
+* back end-to-end from an application running a locally linked build.
+* *Still unestablished:* whether these models report token usage — no
+* `usageMetadata` from a successful image call has been observed, so
+* the pass-through above is untested against a real response.
 *
 * @example
-* isGoogleImageModel("imagen-4.0-generate-001"); // true
-* isGoogleImageModel("gemini-2.5-flash");         // false
+* const model = new GeminiImageModel(ai, { name: "gemini-3.1-flash-lite-image" });
+* const { images, usage } = await model.generate("a red bicycle on a white background");
 */
-function isGoogleImageModel(name) {
-	return GOOGLE_IMAGE_MODEL_PREFIXES.some((prefix) => name.startsWith(prefix));
+var GeminiImageModel = class {
+	constructor(ai, config, provider = "google") {
+		this.logger = _warlock_js_logger.log;
+		this.ai = ai;
+		this.name = config.name;
+		this.provider = provider;
+		this.pricing = config.pricing;
+	}
+	async generate(prompt, options) {
+		const config = this.buildConfig(options);
+		this.logger.debug(LOG_MODULE$2, "image.request", "models.generateContent", {
+			model: this.name,
+			responseModalities: config.responseModalities
+		});
+		let response;
+		try {
+			response = await this.ai.models.generateContent({
+				model: this.name,
+				contents: prompt,
+				config
+			});
+		} catch (thrown) {
+			const wrapped = wrapGoogleError(thrown);
+			this.logger.error(LOG_MODULE$2, "image.error", wrapped.message, {
+				code: wrapped.code,
+				context: wrapped.context
+			});
+			throw wrapped;
+		}
+		const parts = collectParts(response);
+		const images = toGeneratedImages(parts);
+		if (images.length === 0) throw this.noImageError(response, parts);
+		const usage = {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		if (response.usageMetadata) applyGoogleUsage(usage, response.usageMetadata);
+		this.logger.debug(LOG_MODULE$2, "image.response", "models.generateContent succeeded", {
+			images: images.length,
+			usage
+		});
+		return {
+			images,
+			usage
+		};
+	}
+	/**
+	* Assemble the `GenerateContentConfig` for an image turn: the
+	* requested modalities, the image-specific knobs Gemini exposes under
+	* `imageConfig`, and the cancellation handle.
+	*
+	* Three neutral options are deliberately NOT forwarded, because
+	* `GenerateContentConfig` / `ImageConfig` in `@google/genai` expose
+	* no equivalent for them on this path: `count` (no per-request image
+	* count — every inline image part the model does return is mapped),
+	* `negativePrompt` (an Imagen-only field), and `format`
+	* (`ImageConfig.outputMimeType` is documented "not supported in
+	* Gemini API"). Fold those intentions into the prompt instead.
+	*/
+	buildConfig(options) {
+		const imageConfig = {};
+		if (options?.aspectRatio !== void 0) imageConfig.aspectRatio = options.aspectRatio;
+		if (typeof options?.imageSize === "string") imageConfig.imageSize = options.imageSize;
+		if (typeof options?.personGeneration === "string") imageConfig.personGeneration = options.personGeneration;
+		const requested = options?.responseModalities;
+		return {
+			responseModalities: Array.isArray(requested) ? requested : DEFAULT_RESPONSE_MODALITIES,
+			...Object.keys(imageConfig).length > 0 ? { imageConfig } : {},
+			...options?.signal ? { abortSignal: options.signal } : {}
+		};
+	}
+	/**
+	* Build the typed error for a response that carried no inline image
+	* part. Never a silent empty success: the caller asked for an image
+	* and got something else, so the error names what actually came back.
+	*
+	* - A blocked prompt (`promptFeedback.blockReason`) or a
+	*   safety/policy `finishReason` → `ContentFilterError` carrying the
+	*   reason, matching how the Imagen path reports `raiFilteredReason`.
+	* - A text-only answer → `ProviderError` quoting the text, so the
+	*   log says what the model replied instead of guessing.
+	* - Anything else → `ProviderError` naming the finish reason and how
+	*   many parts arrived.
+	*/
+	noImageError(response, parts) {
+		const blockReason = response.promptFeedback?.blockReason;
+		if (blockReason) return new _warlock_js_ai.ContentFilterError(`Gemini blocked the prompt for ${this.name}: ${blockReason}`, { reason: blockReason });
+		const finishReason = response.candidates?.[0]?.finishReason;
+		if (finishReason && FILTERED_FINISH_REASONS.has(finishReason)) return new _warlock_js_ai.ContentFilterError(`Gemini filtered the image for ${this.name}: ${finishReason}`, { reason: finishReason });
+		const text = collectText(parts);
+		if (text) return new _warlock_js_ai.ProviderError(`Gemini returned no image for ${this.name} — the response was text only: "${excerpt(text)}"`, { context: {
+			model: this.name,
+			...finishReason ? { finishReason } : {}
+		} });
+		return new _warlock_js_ai.ProviderError(`Gemini returned no image part for ${this.name} (parts: ${parts.length}${finishReason ? `, finishReason: ${finishReason}` : ""}).`, { context: {
+			model: this.name,
+			parts: parts.length
+		} });
+	}
+};
+/**
+* Flatten every candidate's content parts into one list. Read off
+* `candidates[].content.parts` rather than the response's convenience
+* getters: `response.text` covers only the first candidate's text and
+* there is no getter for inline image data at all.
+*/
+function collectParts(response) {
+	const parts = [];
+	for (const candidate of response.candidates ?? []) parts.push(...candidate.content?.parts ?? []);
+	return parts;
+}
+/**
+* Map the inline image parts to the neutral `GeneratedImage[]` — the
+* same `{ type: "base64", base64, mediaType }` shape the Imagen path
+* emits, including its `image/png` fallback for a part that arrives
+* without a declared mime type.
+*/
+function toGeneratedImages(parts) {
+	const images = [];
+	for (const part of parts) {
+		const data = part.inlineData?.data;
+		if (!data) continue;
+		images.push({
+			type: "base64",
+			base64: data,
+			mediaType: part.inlineData?.mimeType ?? "image/png"
+		});
+	}
+	return images;
+}
+/** Join the text parts of a response — what the model said instead of drawing. */
+function collectText(parts) {
+	return parts.map((part) => part.text).filter((text) => typeof text === "string" && text.length > 0).join(" ").trim();
+}
+/** Trim a quoted model answer so an error message stays readable. */
+function excerpt(text) {
+	return text.length > TEXT_EXCERPT_LIMIT ? `${text.slice(0, TEXT_EXCERPT_LIMIT)}…` : text;
 }
 
 //#endregion
@@ -445,10 +665,13 @@ function mediaTypeFor(format) {
 * `ai.models.generateImages`. Imagen is per-image-metered and returns
 * base64 image bytes (no hosted URL, no token usage).
 *
-* **Capability guard.** The constructor rejects a non-Imagen model id
-* up front — `google.image({ name: "gemini-2.5-flash" })` throws a
-* typed `InvalidRequestError` instead of a downstream 400 (Gemini's
-* native image output is a different API and not routed here).
+* **No model-id validation.** `config.name` is passed through to
+* `ai.models.generateImages` exactly as given — the constructor never
+* inspects it. Google adds and retires image model ids on its own
+* schedule, so an id this adapter does not recognize is not the
+* adapter's call to refuse; an unsupported id surfaces as a provider
+* error from Google (wrapped into the typed `AIError` hierarchy by
+* `generate()`), not as a local one.
 *
 * **Safety filtering.** When Imagen filters every candidate for safety
 * (`raiFilteredReason`), this surfaces a typed `ContentFilterError`
@@ -461,7 +684,6 @@ function mediaTypeFor(format) {
 var GoogleImageModel = class {
 	constructor(ai, config, provider = "google") {
 		this.logger = _warlock_js_logger.log;
-		if (!isGoogleImageModel(config.name)) throw new _warlock_js_ai.InvalidRequestError(`"${config.name}" is not a known Google Imagen model. Use an \`imagen-*\` model with google.image({ name }).`);
 		this.ai = ai;
 		this.name = config.name;
 		this.provider = provider;
@@ -716,7 +938,7 @@ var GoogleModel = class {
 				}
 				const candidateFinish = chunk.candidates?.[0]?.finishReason;
 				if (candidateFinish) rawFinishReason = candidateFinish;
-				if (chunk.usageMetadata) this.applyUsage(usage, chunk.usageMetadata);
+				if (chunk.usageMetadata) applyGoogleUsage(usage, chunk.usageMetadata);
 			}
 		} catch (thrown) {
 			throw this.logAndWrap(thrown);
@@ -829,9 +1051,10 @@ var GoogleModel = class {
 		};
 	}
 	/**
-	* Normalize Gemini's `usageMetadata` into the neutral `Usage` shape.
-	* Cache-read tokens are surfaced as `cachedTokens` only when
-	* non-zero. Absent usage collapses to zeros.
+	* Normalize Gemini's `usageMetadata` into the neutral `Usage` shape
+	* via the shared {@link applyGoogleUsage} mapper (the same one the
+	* streaming loop and the Gemini image model use). Absent usage
+	* collapses to zeros.
 	*/
 	extractUsage(response) {
 		const usage = {
@@ -839,30 +1062,10 @@ var GoogleModel = class {
 			output: 0,
 			total: 0
 		};
-		if (response.usageMetadata) this.applyUsage(usage, response.usageMetadata);
+		if (response.usageMetadata) applyGoogleUsage(usage, response.usageMetadata);
 		return usage;
 	}
 	/**
-	* Fold a Gemini `usageMetadata` block into the running neutral
-	* `Usage` accumulator. Shared by `complete()` and the streaming
-	* loop (where the final chunk carries cumulative totals).
-	*
-	* Cache-read hits (`cachedContentTokenCount`, implicit or explicit
-	* context caching) surface as `cachedTokens`; the thinking-phase
-	* tokens of a reasoning model (`thoughtsTokenCount`) surface as
-	* `reasoningTokens`. Both are emitted only when reported `> 0` so an
-	* absent channel leaves the field undefined.
-	*/
-	applyUsage(usage, raw) {
-		usage.input = raw.promptTokenCount ?? usage.input;
-		usage.output = raw.candidatesTokenCount ?? usage.output;
-		usage.total = raw.totalTokenCount ?? usage.input + usage.output;
-		const cached = raw.cachedContentTokenCount;
-		if (cached && cached > 0) usage.cachedTokens = cached;
-		const reasoning = raw.thoughtsTokenCount;
-		if (reasoning && reasoning > 0) usage.reasoningTokens = reasoning;
-	}
-	/**
 	* Wrap a thrown provider error into the typed `AIError` hierarchy
 	* and emit the standard error log line before it propagates.
 	*/
@@ -879,6 +1082,36 @@ var GoogleModel = class {
 //#endregion
 //#region ../ai-google/src/sdk.ts
 /**
+* Pick the transport for an image model id.
+*
+* `ai.models.generateImages` calls `{model}:predict`, and a `gemini-`
+* id sent there comes back `404 … is not supported for predict`
+* (observed verbatim from Google). `generateContent` is what the SDK
+* itself points `generateImages` users at — its deprecation notice
+* reads "Please use the generateContent method with image models
+* instead" — so the id has to choose the transport.
+*
+* Runs in this package establish where a `gemini-` id is ACCEPTED, not
+* what it returns: on this transport such an id got as far as a quota
+* error (HTTP 429) instead of the 404. That an image
+* comes back end-to-end once billing is enabled is reported by the
+* maintainer from a locally linked build, not measured here. Whether
+* these models report token usage is still unknown.
+*
+* This is ROUTING, not validation — no id is refused here. An id this
+* function does not recognize takes the `generateImages` route, the
+* only route that existed before Gemini image support landed, so every
+* id that reached Google before still reaches Google the same way and
+* still fails (or succeeds) at the provider.
+*
+* A leading `models/` resource prefix is tolerated, matching the id
+* shapes `inferVisionCapability` already accepts
+* (`models/gemini-1.5-flash-001`).
+*/
+function usesGeminiImageTransport(name) {
+	return name.toLowerCase().replace(/^models\//, "").startsWith("gemini-");
+}
+/**
 * Google Gemini-backed implementation of `SDKAdapterContract`.
 *
 * **Role.** The package entry point for Gemini models via the
@@ -946,18 +1179,27 @@ var GoogleSDK = class {
 		return new GoogleEmbedder(this.ai, config, this.provider);
 	}
 	/**
-	* Build a `GoogleImageModel` (Imagen) bound to this SDK's client for
-	* use with `ai.image({ model, prompt })`. Accepts the `imagen-*`
-	* family; a non-Imagen model id is rejected at construction.
+	* Build an image model bound to this SDK's client for use with
+	* `ai.image({ model, prompt })`. `config.name` decides the transport
+	* (see {@link usesGeminiImageTransport}) — a `gemini-` id gets the
+	* `generateContent` implementation, everything else the Imagen
+	* `generateImages` one. No id is rejected locally either way, so an
+	* unsupported model fails at Google, not here.
+	*
+	* The two differ in what usage they can report, which is what the
+	* caller must price for: the Imagen path always returns a zero token
+	* `Usage` (Imagen reports none — price with `{ perImage }`), while the
+	* Gemini path passes through whatever `usageMetadata` Google attaches
+	* (price with `{ input, output }` when tokens come back).
 	*
 	* Pricing resolution mirrors `model()`: per-model `config.pricing`
 	* wins, otherwise the SDK-level registry entry keyed by `config.name`,
-	* otherwise `undefined`. Imagen is per-image-metered, so the registry
-	* entry typically carries `{ perImage }`.
+	* otherwise `undefined`.
 	*
 	* @example
-	* const model = google.image({ name: "imagen-4.0-generate-001" });
-	* const { data } = await ai.image({ model, prompt: "a watercolor lighthouse" });
+	* const imagen = google.image({ name: "imagen-4.0-generate-001" });
+	* const gemini = google.image({ name: "gemini-3.1-flash-lite-image" });
+	* const { data } = await ai.image({ model: gemini, prompt: "a red bicycle" });
 	*/
 	image(config) {
 		const resolvedPricing = config.pricing ?? this.pricing?.[config.name];
@@ -965,13 +1207,13 @@ var GoogleSDK = class {
 			...config,
 			pricing: resolvedPricing
 		};
+		if (usesGeminiImageTransport(config.name)) return new GeminiImageModel(this.ai, resolvedConfig, this.provider);
 		return new GoogleImageModel(this.ai, resolvedConfig, this.provider);
 	}
 };
 
 //#endregion
-exports.GOOGLE_IMAGE_MODEL_PREFIXES = GOOGLE_IMAGE_MODEL_PREFIXES;
+exports.GeminiImageModel = GeminiImageModel;
 exports.GoogleImageModel = GoogleImageModel;
 exports.GoogleSDK = GoogleSDK;
-exports.isGoogleImageModel = isGoogleImageModel;
 //# sourceMappingURL=index.cjs.map