@effect-uai/google 0.12.1 → 0.14.0

package/dist/index.d.mts

@@ -1,9 +1,10 @@
 import { t as codec_d_exports } from "./codec.mjs";
 import { t as GeminiTools_d_exports } from "./GeminiTools.mjs";
-import { GeminiTtsModel, GeminiVoiceName, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaModel } from "./models.mjs";
+import { GeminiImageModel, GeminiTtsModel, GeminiVoiceName, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaModel } from "./models.mjs";
 import { t as Gemini_d_exports } from "./Gemini.mjs";
 import { t as GeminiEmbedding_d_exports } from "./GeminiEmbedding.mjs";
+import { t as GeminiImageGenerator_d_exports } from "./GeminiImageGenerator.mjs";
 import { t as GeminiSynthesizer_d_exports } from "./GeminiSynthesizer.mjs";
 import { t as GoogleDeepResearch_d_exports } from "./GoogleDeepResearch.mjs";
 import { t as LyriaGenerator_d_exports } from "./LyriaGenerator.mjs";
-export { Gemini_d_exports as Gemini, GeminiEmbedding_d_exports as GeminiEmbedding, GeminiSynthesizer_d_exports as GeminiSynthesizer, GeminiTools_d_exports as GeminiTools, GeminiTtsModel, GeminiVoiceName, GoogleDeepResearch_d_exports as GoogleDeepResearch, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaGenerator_d_exports as LyriaGenerator, LyriaModel, codec_d_exports as codec };
+export { Gemini_d_exports as Gemini, GeminiEmbedding_d_exports as GeminiEmbedding, GeminiImageGenerator_d_exports as GeminiImageGenerator, GeminiImageModel, GeminiSynthesizer_d_exports as GeminiSynthesizer, GeminiTools_d_exports as GeminiTools, GeminiTtsModel, GeminiVoiceName, GoogleDeepResearch_d_exports as GoogleDeepResearch, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaGenerator_d_exports as LyriaGenerator, LyriaModel, codec_d_exports as codec };

package/dist/index.mjs

@@ -2,8 +2,9 @@ import { t as GeminiTools_exports } from "./GeminiTools.mjs";
 import { t as codec_exports } from "./codec.mjs";
 import { t as Gemini_exports } from "./Gemini.mjs";
 import { t as GeminiEmbedding_exports } from "./GeminiEmbedding.mjs";
+import { t as GeminiImageGenerator_exports } from "./GeminiImageGenerator.mjs";
 import { t as GeminiSynthesizer_exports } from "./GeminiSynthesizer.mjs";
 import { t as GoogleDeepResearch_exports } from "./GoogleDeepResearch.mjs";
 import { t as LyriaGenerator_exports } from "./LyriaGenerator.mjs";
 import "./models.mjs";
-export { Gemini_exports as Gemini, GeminiEmbedding_exports as GeminiEmbedding, GeminiSynthesizer_exports as GeminiSynthesizer, GeminiTools_exports as GeminiTools, GoogleDeepResearch_exports as GoogleDeepResearch, LyriaGenerator_exports as LyriaGenerator, codec_exports as codec };
+export { Gemini_exports as Gemini, GeminiEmbedding_exports as GeminiEmbedding, GeminiImageGenerator_exports as GeminiImageGenerator, GeminiSynthesizer_exports as GeminiSynthesizer, GeminiTools_exports as GeminiTools, GoogleDeepResearch_exports as GoogleDeepResearch, LyriaGenerator_exports as LyriaGenerator, codec_exports as codec };

package/dist/models.d.mts

@@ -6,7 +6,20 @@
  *
  * Reference: https://ai.google.dev/gemini-api/docs/models
  */
-type GoogleModel = "gemini-3.1-pro-preview" | "gemini-3-flash-preview" | "gemini-3.1-flash-lite-preview" | "gemini-3.1-flash-live-preview" | "gemini-3.1-flash-tts-preview" | "gemini-2.5-pro" | "gemini-2.5-flash" | "gemini-2.5-flash-lite" | (string & {});
+type GoogleModel = "gemini-3.1-pro-preview" | "gemini-3-flash-preview" | "gemini-3.1-flash-lite-preview" | "gemini-3.1-flash-live-preview" | "gemini-3.1-flash-tts-preview" | "gemini-2.5-pro" | "gemini-2.5-flash" | "gemini-2.5-flash-lite" | "gemini-3.1-flash-image" | "gemini-3.1-flash-lite-image" | "gemini-3-pro-image" | (string & {});
+/**
+ * Known Gemini image-generation model identifiers. The `-preview` ids
+ * were shut down 2026-06-25 and are not listed; neither is the
+ * previous-generation `gemini-2.5-flash-image`, which the `(string & {})`
+ * tail still accepts.
+ *
+ * - `gemini-3.1-flash-image` — 512 / 1K / 2K / 4K, web and image search.
+ * - `gemini-3.1-flash-lite-image` — 1K only, cheapest, no search.
+ * - `gemini-3-pro-image` — 1K / 2K / 4K, the most reference images.
+ *
+ * Reference: https://ai.google.dev/gemini-api/docs/models
+ */
+type GeminiImageModel = "gemini-3.1-flash-image" | "gemini-3.1-flash-lite-image" | "gemini-3-pro-image" | (string & {});
 /**
  * Deep-research agent identifiers for the Interactions API (`POST
  * /v1beta/interactions`). `-preview` is the fast tier, `-max-` the
@@ -58,5 +71,5 @@ type GeminiVoiceName = "Zephyr" | "Puck" | "Charon" | "Kore" | "Fenrir" | "Leda"
 type LyriaModel = "lyria-3-clip-preview" | "lyria-3-pro-preview" | (string & {});
 type GoogleEmbeddingModel = "gemini-embedding-2" | "gemini-embedding-001" | (string & {});
 //#endregion
-export { GeminiTtsModel, GeminiVoiceName, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaModel };
+export { GeminiImageModel, GeminiTtsModel, GeminiVoiceName, GoogleDeepResearchModel, GoogleEmbeddingModel, GoogleModel, LyriaModel };
 //# sourceMappingURL=models.d.mts.map

package/dist/models.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"models.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;;;;;;;KAOY;;;;;;;;;;KAqBA;;;;;;;;;;;;;;;;;;;;;KA0BA;;;;;;;;KAcA;;;;;;;;;;KAyCA;KAMA"}
+{"version":3,"file":"models.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;;;;;;;KAOY;;;;;;;;;;;;;KA6BA;;;;;;;;;;KAgBA;;;;;;;;;;;;;;;;;;;;;KA0BA;;;;;;;;KAcA;;;;;;;;;;KAyCA;KAMA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/google",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "Google Gemini provider for @effect-uai/core.",
   "keywords": [
     "ai",
@@ -42,6 +42,10 @@
       "types": "./dist/GeminiEmbedding.d.mts",
       "import": "./dist/GeminiEmbedding.mjs"
     },
+    "./GeminiImageGenerator": {
+      "types": "./dist/GeminiImageGenerator.d.mts",
+      "import": "./dist/GeminiImageGenerator.mjs"
+    },
     "./GeminiSynthesizer": {
       "types": "./dist/GeminiSynthesizer.d.mts",
       "import": "./dist/GeminiSynthesizer.mjs"
@@ -61,7 +65,7 @@
   "devDependencies": {
     "effect": "4.0.0-rc.111",
     "typescript": "^7.0.2",
-    "@effect-uai/core": "0.12.1"
+    "@effect-uai/core": "0.14.0"
   },
   "peerDependencies": {
     "@effect-uai/core": ">=0.2.0 <1",

package/src/Gemini.ts

@@ -17,11 +17,13 @@ export { codeExecutionTool, googleSearchTool, urlContextTool } from "./GeminiToo
 import {
   type ChunkPart,
   type GenerationConfig,
+  type ImageConfig,
   WireChunk,
   accumulatorToTurn,
   buildRequestBody,
   emptyAccumulator,
   hasUrlImageSource,
+  httpStatusError as sharedHttpStatusError,
   ingestChunk,
 } from "./codec.js"
 import { Match } from "effect"
@@ -52,8 +54,25 @@ export type GeminiRequest = Omit<CommonRequest, "model"> & {
    * `generationConfig.thinkingConfig.thinkingBudget`.
    */
   readonly thinkingBudget?: number
+  /**
+   * What the model may answer with. Image models default to
+   * `["TEXT", "IMAGE"]`; set this to ask a non-image model for images, or
+   * to hold an image model to prose.
+   */
+  readonly responseModalities?: ReadonlyArray<"TEXT" | "IMAGE">
+  /** Shape and size of images the model draws. Image models only. */
+  readonly imageConfig?: ImageConfig
 }
 
+/**
+ * Image models answer in prose unless the IMAGE modality is asked for,
+ * which is a silent disappointment rather than an error, so the adapter
+ * asks on their behalf. Detection is Google's naming convention, which
+ * holds across the family and keeps a future id working without an SDK
+ * update; an explicit `responseModalities` always wins.
+ */
+const drawsImages = (model: string): boolean => model.endsWith("-image")
+
 export type GeminiService = {
   /**
    * Stream the provider's native event vocabulary (post-SSE-decode). For
@@ -103,7 +122,11 @@ export type Config = {
 // Request body
 // ---------------------------------------------------------------------------
 
+const TEXT_AND_IMAGE: ReadonlyArray<"TEXT" | "IMAGE"> = ["TEXT", "IMAGE"]
+
 const buildGenerationConfig = (request: GeminiRequest): Option.Option<GenerationConfig> => {
+  const modalities =
+    request.responseModalities ?? (drawsImages(request.model) ? TEXT_AND_IMAGE : undefined)
   const cfg: GenerationConfig = {
     ...(request.temperature !== undefined && { temperature: request.temperature }),
     ...(request.maxOutputTokens !== undefined && { maxOutputTokens: request.maxOutputTokens }),
@@ -111,6 +134,8 @@ const buildGenerationConfig = (request: GeminiRequest): Option.Option<Generation
     ...(request.thinkingBudget !== undefined && {
       thinkingConfig: { thinkingBudget: request.thinkingBudget },
     }),
+    ...(modalities !== undefined && { responseModalities: modalities }),
+    ...(request.imageConfig !== undefined && { imageConfig: request.imageConfig }),
     ...(request.structured !== undefined && {
       responseMimeType: "application/json",
       responseJsonSchema: request.structured.schema["~standard"].jsonSchema.input({
@@ -139,25 +164,21 @@ const parseJsonUnknown = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema
 const sseEventToChunk = (ev: SSE.Event) =>
   parseJsonUnknown(ev.data).pipe(
     Effect.mapError((cause) => new JsonParseError({ line: ev.data, cause })),
-    Effect.flatMap(decodeChunk),
+    Effect.flatMap((json) =>
+      // A `SchemaError` alone says nothing about which part shape we failed
+      // to read, and image models add part shapes text-only ones never send.
+      // Carry the line so the mismatch is legible.
+      decodeChunk(json).pipe(
+        Effect.mapError((cause) => new JsonParseError({ line: ev.data.slice(0, 2000), cause })),
+      ),
+    ),
   )
 
 // ---------------------------------------------------------------------------
 // Service implementation
 // ---------------------------------------------------------------------------
 
-const httpStatusError = (status: number, body: string): AiError.AiError => {
-  const provider = "gemini"
-  const raw = body
-  if (status === 429) return new AiError.RateLimited({ provider, raw })
-  if (status === 408 || status === 504) return new AiError.Timeout({ provider, raw })
-  if (status === 401) return new AiError.AuthFailed({ provider, subtype: "auth", raw })
-  if (status === 403) return new AiError.AuthFailed({ provider, subtype: "permission", raw })
-  if (status === 402) return new AiError.AuthFailed({ provider, subtype: "billing", raw })
-  if (status === 413) return new AiError.ContextLengthExceeded({ provider, raw })
-  if (status >= 500) return new AiError.Unavailable({ provider, status, raw })
-  return new AiError.InvalidRequest({ provider, raw })
-}
+const httpStatusError = sharedHttpStatusError("gemini")
 
 const buildNativeStream = (cfg: Config) => {
   const baseUrl = cfg.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta"
@@ -256,6 +277,9 @@ const partToTurnEvents = (
       reasoning: (p): ReadonlyArray<TurnEvent> => [
         TurnEvent.ReasoningDelta({ text: p.text, kind: "trace" }),
       ],
+      // Gemini sends the image whole, so there is no `partialIndex`: the
+      // one event that arrives is the finished picture.
+      image: (p): ReadonlyArray<TurnEvent> => [TurnEvent.ImageOutput({ image: p.source })],
       function_call: (p): ReadonlyArray<TurnEvent> => {
         const call_id = callIdAt(p.name, 0)
         return [

package/src/GeminiImageGenerator.ts

@@ -0,0 +1,390 @@
+import { Context, Effect, Encoding, Layer, Match, Redacted, Schema, Stream } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import * as AiError from "@effect-uai/core/AiError"
+import * as Capabilities from "@effect-uai/core/Capabilities"
+import type {
+  GeneratedImage,
+  ImageBase64Source,
+  ImageBytesSource,
+  ImageSource,
+} from "@effect-uai/core/Image"
+import { imageBase64 } from "@effect-uai/core/Image"
+import type {
+  CommonImageEditRequest,
+  CommonImageGenerateRequest,
+  CommonStreamImageEditRequest,
+  CommonStreamImageRequest,
+  ImageGeneratorService,
+  ImageResponse,
+  ImageStreamEvent,
+  ImageUsage,
+} from "@effect-uai/core/ImageGenerator"
+import { ImageGenerator } from "@effect-uai/core/ImageGenerator"
+import { httpStatusError, transportFailure } from "./codec.js"
+import type { GeminiImageModel } from "./models.js"
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/** Wire knobs `generateContent` accepts alongside the portable request. */
+type GeminiImageKnobs = {
+  /**
+   * Sent as `imageConfig.imageSize`. Takes precedence over `resolution`,
+   * which is then warn-dropped. `"512"` is Flash-only.
+   */
+  readonly imageSize?: "512" | "1K" | "2K" | "4K"
+  /** Thinking is always on for image models; this only sets how long. */
+  readonly thinkingLevel?: "minimal" | "low" | "medium" | "high"
+  /** Ground the image in web results. Flash and Pro only. */
+  readonly googleSearch?: boolean
+}
+
+export type GeminiImageGenerateRequest = Omit<CommonImageGenerateRequest, "model"> & {
+  readonly model: GeminiImageModel
+} & GeminiImageKnobs
+
+/**
+ * Reference images for an edit. Narrowed off `ImageSource`: references
+ * ride in the request body as base64 `inlineData`, so a `url` variant has
+ * no wire representation short of pre-uploading through the Files API.
+ * A compile-time error rather than a 400; fetch it yourself and pass the
+ * bytes.
+ */
+export type GeminiImageRef = ImageBase64Source | ImageBytesSource
+
+export type GeminiImageEditRequest = Omit<CommonImageEditRequest, "model" | "images"> & {
+  readonly model: GeminiImageModel
+  /** 14 total, split between object / character / style refs per model. */
+  readonly images: ReadonlyArray<GeminiImageRef>
+} & GeminiImageKnobs
+
+export type GeminiImageGeneratorService = {
+  readonly generate: (
+    request: GeminiImageGenerateRequest,
+  ) => Effect.Effect<ImageResponse, AiError.AiError>
+  readonly edit: (request: GeminiImageEditRequest) => Effect.Effect<ImageResponse, AiError.AiError>
+  /** Both always `Unsupported`: `ImageStreaming` is not registered by {@link layer}. */
+  readonly streamGeneration: ImageGeneratorService["streamGeneration"]
+  readonly streamEdit: ImageGeneratorService["streamEdit"]
+}
+
+/**
+ * Provider-typed service tag. Yield this for `imageSize`, `thinkingLevel`
+ * and search grounding; yield the generic `ImageGenerator` tag for
+ * provider-portable code. Both are registered by {@link layer}.
+ */
+export class GeminiImageGenerator extends Context.Service<
+  GeminiImageGenerator,
+  GeminiImageGeneratorService
+>()("@betalyra/effect-uai/providers/google/GeminiImageGenerator") {}
+
+export type Config = {
+  readonly apiKey: Redacted.Redacted
+  readonly baseUrl?: string
+}
+
+const PROVIDER = "gemini"
+
+// ---------------------------------------------------------------------------
+// Codec - request
+//
+// Both ratio and tier are native here, so nothing is derived. Whether a
+// given model accepts the pair is the server's call: per-model limits
+// churn and we do not table them.
+// ---------------------------------------------------------------------------
+
+type ImageConfig = {
+  readonly aspectRatio?: string
+  readonly imageSize?: string
+}
+
+type RequestPart =
+  | { readonly text: string }
+  | { readonly inlineData: { readonly mimeType: string; readonly data: string } }
+
+export type WireBody = {
+  readonly contents: ReadonlyArray<{
+    readonly role: "user"
+    readonly parts: ReadonlyArray<RequestPart>
+  }>
+  readonly generationConfig: {
+    readonly responseModalities: ReadonlyArray<"TEXT" | "IMAGE">
+    readonly imageConfig?: ImageConfig
+    readonly thinkingConfig?: { readonly thinkingLevel: string }
+  }
+  readonly tools?: ReadonlyArray<{ readonly googleSearch: {} }>
+}
+
+const urlRefNotSupported: AiError.AiError = new AiError.InvalidRequest({
+  provider: PROVIDER,
+  param: "images",
+  raw: 'Reference images ride in the request body as base64, so a URL reference cannot be sent without pre-uploading it through the Files API. Fetch the URL yourself and pass `{ _tag: "bytes", bytes, mimeType }`.',
+})
+
+const referencePart: (image: ImageSource) => Effect.Effect<RequestPart, AiError.AiError> =
+  Match.type<ImageSource>().pipe(
+    Match.tag("base64", (i) =>
+      Effect.succeed<RequestPart>({ inlineData: { mimeType: i.mimeType, data: i.base64 } }),
+    ),
+    Match.tag("bytes", (i) =>
+      Effect.succeed<RequestPart>({
+        inlineData: { mimeType: i.mimeType, data: Encoding.encodeBase64(i.bytes) },
+      }),
+    ),
+    Match.tag("url", () => Effect.fail(urlRefNotSupported)),
+    Match.exhaustive,
+  )
+
+/**
+ * More than one image per call is bucket 1: `candidateCount` is a generic
+ * `generationConfig` field whose behaviour on image models is undocumented,
+ * and silently returning one image where several were asked for is a
+ * different result, not a smaller one.
+ */
+const rejectMultiple = (n: number | undefined): Effect.Effect<void, AiError.AiError> =>
+  n === undefined || n <= 1
+    ? Effect.void
+    : Effect.fail(
+        new AiError.Unsupported({
+          provider: PROVIDER,
+          capability: "n",
+          reason: `Gemini image models return one image per call; \`n: ${n}\` has no wire field. Run the request ${n} times, concurrently if you want them at once.`,
+        }),
+      )
+
+/** The typed `imageSize` wins over the portable tier, which is then dropped. */
+export const imageSizeOf = (
+  request: Pick<GeminiImageGenerateRequest, "imageSize" | "resolution">,
+): Effect.Effect<string | undefined> =>
+  request.imageSize === undefined
+    ? Effect.succeed(request.resolution)
+    : Effect.as(
+        Capabilities.warnDroppedWhen(request.resolution, {
+          provider: PROVIDER,
+          capability: "resolution",
+          field: "resolution",
+          reason: `\`imageSize: "${request.imageSize}"\` sets the tier directly.`,
+        }),
+        request.imageSize,
+      )
+
+export const buildBody = (
+  request: GeminiImageGenerateRequest,
+  images: ReadonlyArray<ImageSource>,
+): Effect.Effect<WireBody, AiError.AiError> =>
+  Effect.gen(function* () {
+    yield* rejectMultiple(request.n)
+    const imageSize = yield* imageSizeOf(request)
+    const refs = yield* Effect.forEach(images, referencePart)
+    const imageConfig: ImageConfig = {
+      ...(request.aspectRatio !== undefined && { aspectRatio: request.aspectRatio }),
+      ...(imageSize !== undefined && { imageSize }),
+    }
+    return {
+      contents: [{ role: "user", parts: [{ text: request.prompt }, ...refs] }],
+      generationConfig: {
+        responseModalities: ["TEXT", "IMAGE"],
+        ...(Object.keys(imageConfig).length > 0 && { imageConfig }),
+        ...(request.thinkingLevel !== undefined && {
+          thinkingConfig: { thinkingLevel: request.thinkingLevel.toUpperCase() },
+        }),
+      },
+      ...(request.googleSearch === true && { tools: [{ googleSearch: {} }] }),
+    }
+  })
+
+// ---------------------------------------------------------------------------
+// Codec - response
+// ---------------------------------------------------------------------------
+
+const InlineData = Schema.Struct({
+  mimeType: Schema.optional(Schema.String),
+  data: Schema.String,
+})
+
+const Part = Schema.Struct({
+  text: Schema.optional(Schema.String),
+  inlineData: Schema.optional(InlineData),
+  /** Interim images the model drew while thinking. Not the answer. */
+  thought: Schema.optional(Schema.Boolean),
+})
+
+const Candidate = Schema.Struct({
+  content: Schema.optional(Schema.Struct({ parts: Schema.optional(Schema.Array(Part)) })),
+  finishReason: Schema.optional(Schema.String),
+})
+
+const UsageMetadata = Schema.Struct({
+  promptTokenCount: Schema.optional(Schema.Number),
+  candidatesTokenCount: Schema.optional(Schema.Number),
+  totalTokenCount: Schema.optional(Schema.Number),
+})
+type UsageMetadata = typeof UsageMetadata.Type
+
+const Wire = Schema.Struct({
+  candidates: Schema.optional(Schema.Array(Candidate)),
+  promptFeedback: Schema.optional(Schema.Struct({ blockReason: Schema.optional(Schema.String) })),
+  usageMetadata: Schema.optional(UsageMetadata),
+})
+type Wire = typeof Wire.Type
+
+export const decodeWire = Schema.decodeUnknownEffect(Wire)
+
+/**
+ * Finish reasons that are a content decision rather than a failure. The
+ * generic safety codes appear when the prompt trips a filter, the
+ * `IMAGE_`-prefixed ones when the drawn image does. `NO_IMAGE` and
+ * `IMAGE_OTHER` are not here: they say the model produced nothing, not
+ * that it refused.
+ */
+const FILTERED_FINISH_REASONS: ReadonlySet<string> = new Set([
+  "SAFETY",
+  "RECITATION",
+  "BLOCKLIST",
+  "PROHIBITED_CONTENT",
+  "SPII",
+  "IMAGE_SAFETY",
+  "IMAGE_PROHIBITED_CONTENT",
+  "IMAGE_RECITATION",
+])
+
+const usageOf = (usage: UsageMetadata | undefined): ImageUsage => ({
+  ...(usage?.promptTokenCount !== undefined && { inputTokens: usage.promptTokenCount }),
+  ...(usage?.candidatesTokenCount !== undefined && { outputTokens: usage.candidatesTokenCount }),
+  ...(usage?.totalTokenCount !== undefined && { totalTokens: usage.totalTokenCount }),
+})
+
+/** Every Gemini image carries SynthID; Lite adds a C2PA manifest on top. */
+const generatedImage = (inline: typeof InlineData.Type): GeneratedImage => ({
+  image: imageBase64(inline.data, inline.mimeType ?? "image/png"),
+  watermark: "synthid",
+})
+
+export const toResponse = (wire: Wire): Effect.Effect<ImageResponse, AiError.AiError> => {
+  const blockReason = wire.promptFeedback?.blockReason
+  const finishReason = wire.candidates?.[0]?.finishReason
+  // A prompt-level block names itself; an output-level one shows up as the
+  // candidate's finish reason with no parts attached.
+  const filtered =
+    blockReason ??
+    (finishReason !== undefined && FILTERED_FINISH_REASONS.has(finishReason)
+      ? finishReason
+      : undefined)
+  if (filtered !== undefined) {
+    return Effect.fail(
+      new AiError.ContentFiltered({ provider: PROVIDER, reason: filtered, raw: wire }),
+    )
+  }
+  const images = (wire.candidates ?? [])
+    .flatMap((candidate) => candidate.content?.parts ?? [])
+    .flatMap((part) =>
+      part.thought === true || part.inlineData === undefined
+        ? []
+        : [generatedImage(part.inlineData)],
+    )
+  return images.length === 0
+    ? Effect.fail(
+        new AiError.GenerationFailed({
+          provider: PROVIDER,
+          ...(finishReason !== undefined && { code: finishReason }),
+          message: "Gemini returned no image part.",
+          raw: wire,
+        }),
+      )
+    : Effect.succeed({ images, usage: usageOf(wire.usageMetadata) })
+}
+
+// ---------------------------------------------------------------------------
+// HTTP
+// ---------------------------------------------------------------------------
+
+const host = (cfg: Config): string =>
+  cfg.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta"
+
+const requestImages = (
+  cfg: Config,
+  request: GeminiImageGenerateRequest,
+  images: ReadonlyArray<ImageSource>,
+): Effect.Effect<ImageResponse, AiError.AiError, HttpClient.HttpClient> =>
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient
+    const body = yield* buildBody(request, images)
+    const response = yield* client
+      .execute(
+        HttpClientRequest.post(`${host(cfg)}/models/${request.model}:generateContent`).pipe(
+          HttpClientRequest.setHeader("x-goog-api-key", Redacted.value(cfg.apiKey)),
+          HttpClientRequest.bodyJsonUnsafe(body),
+        ),
+      )
+      .pipe(Effect.mapError(transportFailure(PROVIDER)))
+    if (response.status >= 400) {
+      const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
+      return yield* httpStatusError(PROVIDER)(response.status, text)
+    }
+    const json = yield* response.json.pipe(Effect.mapError(transportFailure(PROVIDER)))
+    const wire = yield* decodeWire(json).pipe(Effect.mapError(transportFailure(PROVIDER)))
+    return yield* toResponse(wire)
+  })
+
+/**
+ * `generateContent` has no partial-image wire, so this never succeeds and
+ * {@link layer} does not register `ImageStreaming`. Code calling the
+ * top-level `streamGeneration` helper against this Layer alone fails to
+ * typecheck, which is the intended UX; this branch covers the service
+ * being used directly.
+ */
+const streamUnsupported = (capability: string): Stream.Stream<ImageStreamEvent, AiError.AiError> =>
+  Stream.fail(
+    new AiError.Unsupported({
+      provider: PROVIDER,
+      capability,
+      reason:
+        "Gemini image models have no partial-image wire; the image arrives whole. Use `generate` or `edit` and render when it resolves.",
+    }),
+  )
+
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+
+export const make = (
+  cfg: Config,
+): Effect.Effect<GeminiImageGeneratorService, never, HttpClient.HttpClient> =>
+  Effect.map(HttpClient.HttpClient, (client): GeminiImageGeneratorService => ({
+    generate: (request) =>
+      requestImages(cfg, request, []).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+    edit: (request) =>
+      requestImages(cfg, request, request.images).pipe(
+        Effect.provideService(HttpClient.HttpClient, client),
+      ),
+    streamGeneration: () => streamUnsupported("streamGeneration"),
+    streamEdit: () => streamUnsupported("streamEdit"),
+  }))
+
+/**
+ * Layer registering the provider-typed tag and the generic
+ * `ImageGenerator`. A `CommonImageGenerateRequest` is structurally a
+ * `GeminiImageGenerateRequest` with no vendor knobs set, so the generic
+ * registration forwards directly; a URL reference slipping through the
+ * generic `edit` fails `InvalidRequest` at encode time.
+ *
+ * Does NOT register `ImageStreaming`.
+ */
+export const layer = (
+  cfg: Config,
+): Layer.Layer<GeminiImageGenerator | ImageGenerator, never, HttpClient.HttpClient> =>
+  Layer.merge(
+    Layer.effect(GeminiImageGenerator, make(cfg)),
+    Layer.effect(
+      ImageGenerator,
+      Effect.map(make(cfg), (s): ImageGeneratorService => ({
+        generate: (request: CommonImageGenerateRequest) =>
+          s.generate(request as GeminiImageGenerateRequest),
+        edit: (request: CommonImageEditRequest) => s.edit(request as GeminiImageEditRequest),
+        streamGeneration: (_request: CommonStreamImageRequest) =>
+          streamUnsupported("streamGeneration"),
+        streamEdit: (_request: CommonStreamImageEditRequest) => streamUnsupported("streamEdit"),
+      })),
+    ),
+  )

package/src/LyriaGenerator.ts

@@ -24,6 +24,10 @@ import type {
 } from "@effect-uai/core/Music"
 import { singleVariant } from "@effect-uai/core/Music"
 import { MusicGenerator, type MusicGeneratorService } from "@effect-uai/core/MusicGenerator"
+import {
+  httpStatusError as sharedHttpStatusError,
+  transportFailure as sharedTransportFailure,
+} from "./codec.js"
 import type { LyriaModel } from "./models.js"
 
 // ---------------------------------------------------------------------------
@@ -198,43 +202,9 @@ const decodeWire = Schema.decodeUnknownEffect(Wire)
 const baseUrl = (cfg: Config): string =>
   cfg.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta"
 
-const transportFailure = (cause: unknown): AiError.AiError =>
-  new AiError.Unavailable({ provider: "lyria", raw: cause })
+const transportFailure = sharedTransportFailure("lyria")
 
-const httpStatusError: (status: number, body: string) => AiError.AiError = (status, body) =>
-  Match.value(status).pipe(
-    Match.when(
-      429,
-      (): AiError.AiError => new AiError.RateLimited({ provider: "lyria", raw: body }),
-    ),
-    Match.whenOr(
-      408,
-      504,
-      (): AiError.AiError => new AiError.Timeout({ provider: "lyria", raw: body }),
-    ),
-    Match.when(
-      401,
-      (): AiError.AiError =>
-        new AiError.AuthFailed({ provider: "lyria", subtype: "auth", raw: body }),
-    ),
-    Match.when(
-      403,
-      (): AiError.AiError =>
-        new AiError.AuthFailed({ provider: "lyria", subtype: "permission", raw: body }),
-    ),
-    Match.when(
-      402,
-      (): AiError.AiError =>
-        new AiError.AuthFailed({ provider: "lyria", subtype: "billing", raw: body }),
-    ),
-    Match.when(
-      (n) => n >= 500,
-      (n): AiError.AiError => new AiError.Unavailable({ provider: "lyria", status: n, raw: body }),
-    ),
-    Match.orElse(
-      (): AiError.AiError => new AiError.InvalidRequest({ provider: "lyria", raw: body }),
-    ),
-  )
+const httpStatusError = sharedHttpStatusError("lyria")
 
 const decodeBase64ToBytes = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>
   Result.match(Encoding.decodeBase64(b64), {