@goodandready/dsh-image-gen 0.10.23 → 0.10.25

package/lib/pattern-helpers.js

@@ -0,0 +1,87 @@
+// Pure helpers for generate_seamless_pattern (#178)
+
+export function buildSeamlessPrompt(motif, style, density) {
+  const d = String(density || 'medium').toLowerCase()
+  const densityHint = d === 'low'
+    ? 'sparse motif spacing with generous empty background'
+    : d === 'high'
+      ? 'dense repeating motif coverage with minimal empty background'
+      : 'balanced motif spacing'
+  const styleBit = style ? ` Style: ${style}.` : ''
+  return `Seamless tileable repeating pattern of ${motif}.${styleBit} `
+    + 'Motifs must wrap continuously across left/right and top/bottom edges so the image tiles without visible seams. '
+    + `Flat even lighting, orthographic top-down view, ${densityHint}. `
+    + 'No vignette, no border frame, no watermark, no text.'
+}
+
+export function buildPatternCss({ className, sizePx, imagePath }) {
+  const name = className || 'dsh-pattern'
+  const size = sizePx || 512
+  const url = imagePath || `./${name}.png`
+  return `/* dsh-image-gen seamless pattern */
+.${name} {
+  background-image: url('${url}');
+  background-repeat: repeat;
+  background-size: ${size}px ${size}px;
+}
+`
+}
+
+export function normalizeDensity(value) {
+  const v = String(value || 'medium').toLowerCase()
+  if (v === 'low' || v === 'high') return v
+  return 'medium'
+}
+
+
+/**
+ * Score edge wrap continuity on raw RGBA (or RGB) pixel rows.
+ * Returns 0..1 (1 = identical opposite edges). Used as a seam QA helper (#178).
+ * @param {Uint8Array} pixels
+ * @param {number} width
+ * @param {number} height
+ * @param {number} [channels=4]
+ */
+export function scoreEdgeWrap(pixels, width, height, channels = 4) {
+  if (!pixels || width < 1 || height < 1) return 0
+  const stride = width * channels
+  let sum = 0
+  let n = 0
+  // left vs right columns
+  for (let y = 0; y < height; y++) {
+    const row = y * stride
+    for (let c = 0; c < channels; c++) {
+      const l = pixels[row + c]
+      const r = pixels[row + (width - 1) * channels + c]
+      sum += 1 - Math.abs(l - r) / 255
+      n++
+    }
+  }
+  // top vs bottom rows
+  for (let x = 0; x < width; x++) {
+    for (let c = 0; c < channels; c++) {
+      const top = pixels[x * channels + c]
+      const bot = pixels[(height - 1) * stride + x * channels + c]
+      sum += 1 - Math.abs(top - bot) / 255
+      n++
+    }
+  }
+  return n ? sum / n : 0
+}
+
+/** Tile RGBA image into cols x rows buffer (for 2x2 / 3x3 seam visual QA). */
+export function tilePixels(pixels, width, height, channels, cols, rows) {
+  const outW = width * cols
+  const outH = height * rows
+  const out = new Uint8Array(outW * outH * channels)
+  for (let ry = 0; ry < rows; ry++) {
+    for (let cx = 0; cx < cols; cx++) {
+      for (let y = 0; y < height; y++) {
+        const srcOff = y * width * channels
+        const dstOff = ((ry * height + y) * outW + cx * width) * channels
+        out.set(pixels.subarray(srcOff, srcOff + width * channels), dstOff)
+      }
+    }
+  }
+  return { pixels: out, width: outW, height: outH }
+}

package/lib/prompt-polisher.js

@@ -185,10 +185,3 @@ export function polishPrompt(basePrompt, stylePreset = null, {
   }
 }
 
-export function listCuratedStyles() {
-  return Object.values(CURATED_STYLES).map(s => ({
-    id: s.id,
-    label: s.label,
-    guidanceScale: s.guidanceScale,
-  }))
-}

package/lib/provider-utils.js

@@ -0,0 +1,302 @@
+// lib/provider-utils.js
+// Shared provider utilities and size/format constants extracted from providers.js (#239)
+
+export function resolveApiKeyCandidates(ref) {
+  if (!ref) return []
+  const candidates = [ref]
+  if (ref === 'FAL_API_KEY') candidates.push('FAL_KEY')
+  else if (ref === 'FAL_KEY') candidates.push('FAL_API_KEY')
+  return candidates
+}
+
+
+export const PROVIDER_MAX_COUNTS = {
+  fal: 4,
+  replicate: 4,
+  custom: 10,
+  seedream: 10,
+  gemini: 4,
+  codex: 1,
+  grok: 1,
+  local: 4,
+}
+
+export function normalizeCount(count, max = 4) {
+  const n = Math.floor(Number(count))
+  if (!Number.isFinite(n)) return 1
+  return Math.max(1, Math.min(max, n))
+}
+
+/** @internal — test helper for validating provider count limits */
+export function clampProviderCount(provider, count) {
+  const max = PROVIDER_MAX_COUNTS[provider] || 4
+  return normalizeCount(count, max)
+}
+
+export function buildEndpointUrl(baseURL, pathSuffix) {
+  const base = String(baseURL || '').trim().replace(/\/+$/, '')
+  const suffix = String(pathSuffix || '').trim().replace(/^\/+/, '')
+  return `${base}/${suffix}`
+}
+
+/** @internal — test helper for abort signal simulation */
+export function createAbortError(message = 'Image generation cancelled') {
+  const err = new Error(message)
+  err.name = 'AbortError'
+  return err
+}
+
+
+/** Fast Laplacian-like sharpness and entropy estimator across image scanlines. */
+export function estimateSharpnessAndVariance(bytes) {
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes || [])
+  if (!buf || buf.length < 64) {
+    return { score: 0, passed: false, isBlank: true, reason: 'Empty or corrupt image buffer' }
+  }
+  let sum = 0
+  let diffSum = 0
+  const sampleStep = Math.max(1, Math.floor(buf.length / 4096))
+  let count = 0
+  for (let i = 8; i < buf.length - sampleStep; i += sampleStep) {
+    const v = buf[i]
+    const nextV = buf[i + sampleStep]
+    sum += v
+    diffSum += Math.abs(v - nextV)
+    count++
+  }
+  const avgDiff = count > 0 ? diffSum / count : 0
+  if (avgDiff < 2) {
+    return { score: 0.1, passed: false, isBlank: true, reason: 'Image appears blank or solid monochrome' }
+  }
+  const score = Math.min(0.98, Math.max(0.3, +(0.5 + (avgDiff / 255) * 0.5).toFixed(2)))
+  return { score, passed: score >= 0.5, isBlank: false, avgDiff: +avgDiff.toFixed(2) }
+}
+
+/** Adaptive color palette quantizer for SVG vectorization. */
+export function quantizePalette(colorMode = 'color', paletteSize = 16) {
+  if (colorMode === 'binary') return ['#000000', '#ffffff']
+  if (colorMode === 'grayscale') return ['#000000', '#444444', '#888888', '#cccccc', '#ffffff']
+  // Standard vibrant UI vector palette
+  return [
+    '#000000', '#ffffff', '#e11d48', '#2563eb',
+    '#16a34a', '#ca8a04', '#9333ea', '#0891b2',
+    '#475569', '#64748b', '#94a3b8', '#cbd5e1'
+  ].slice(0, Math.max(2, paletteSize))
+}
+
+
+/** Format parameters in standard Automatic1111 / ComfyUI text format for drag-and-drop support. */
+export function formatA1111Parameters(metadata = {}) {
+  if (typeof metadata === 'string') return metadata
+  const prompt = metadata.prompt || ''
+  const neg = metadata.negative_prompt || metadata.negativePrompt || ''
+  const seed = metadata.seed ?? ''
+  const size = metadata.size || (metadata.width && metadata.height ? `${metadata.width}x${metadata.height}` : '1024x1024')
+  const model = metadata.model || metadata.provider || ''
+  const steps = metadata.steps || 20
+  const cfg = metadata.cfg_scale || metadata.guidance_scale || 7
+
+  let out = prompt
+  if (neg) out += `\nNegative prompt: ${neg}`
+  out += `\nSteps: ${steps}, Sampler: Euler, CFG scale: ${cfg}, Seed: ${seed}, Size: ${size}, Model: ${model}`
+  return out
+}
+
+
+import { createHash } from 'node:crypto'
+
+/** Deterministic sha256 hash for image generation caching. */
+export function computeGenerationHash({ provider, model, prompt, seed, size, style }) {
+  const norm = [
+    String(provider || '').trim().toLowerCase(),
+    String(model || '').trim().toLowerCase(),
+    String(prompt || '').trim(),
+    String(seed ?? ''),
+    String(size || '').trim().toLowerCase(),
+    String(style || '').trim().toLowerCase(),
+  ].join('|')
+  return createHash('sha256').update(norm).digest('hex')
+}
+
+// Image generation provider implementations.
+//
+// A provider receives a generation job and returns finished image bytes. Everything
+// that follows (attachments, workspace files, links, card rendering) is shared
+// across all providers and lives in index.js.
+//
+// Network is injected via fetchImpl and keys via resolveKey, enabling fully isolated unit tests.
+
+export const PROVIDER_KEYS = ['fal', 'custom', 'codex', 'grok', 'local', 'seedream', 'gemini', 'replicate']
+
+/** Clamp count from tool arguments to range 1..4. */
+/** Provider fallback ordering: primary provider first, followed by PROVIDER_KEYS. */
+export function fallbackOrder(primary) {
+  return [primary, ...PROVIDER_KEYS.filter((k) => k !== primary)]
+}
+
+/**
+ * Iterates through candidate generators, returning the first successful result.
+ * Throws an aggregate error if all candidates fail.
+ * @param generators - array of (key, seed) => Promise<generated> functions.
+ * @param order - candidate key evaluation order.
+ */
+
+/** Calculate exponential backoff delay with jitter. */
+export function calculateBackoff(attempt, baseInterval = 500, maxInterval = 5000, jitterFactor = 0.2) {
+  const exp = Math.min(maxInterval, baseInterval * Math.pow(1.3, attempt))
+  const jitter = exp * jitterFactor * (Math.random() * 2 - 1)
+  return Math.max(100, Math.floor(exp + jitter))
+}
+
+/** Check if an error is a fatal client error that should NOT be cascaded to other providers. */
+export function isFatalClientError(error) {
+  const msg = (error?.message || String(error || '')).toLowerCase()
+  return (
+    msg.includes('content policy') ||
+    msg.includes('safety system') ||
+    msg.includes('nsfw') ||
+    msg.includes('moderation') ||
+    msg.includes('bad request (http 400') ||
+    msg.includes('invalid_prompt') ||
+    msg.includes('prompt is required') ||
+    msg.includes('unsupported image format') ||
+    msg.includes('402 payment required') ||
+    msg.includes('insufficient_quota') ||
+    msg.includes('insufficient credits') ||
+    msg.includes('exceeded your current quota') ||
+    msg.includes('balance is insufficient')
+  )
+}
+
+/**
+ * Safely extract a human-readable message from any error, object, or response.
+ * Completely eliminates "[object Object]" and prevents duplicate provider prefixes (e.g. "codex: codex: ...").
+ */
+export function formatErrorMessage(e, providerKey = '') {
+  if (e === null || e === undefined) {
+    return providerKey ? `${providerKey}: unknown error` : 'unknown error'
+  }
+
+  let msg = ''
+  if (typeof e === 'string') {
+    msg = e
+  } else if (typeof e === 'object') {
+    if (typeof e.message === 'string' && e.message && e.message !== '[object Object]') {
+      msg = e.message
+    } else if (typeof e.detail === 'string' && e.detail) {
+      msg = e.detail
+    } else if (e.error) {
+      if (typeof e.error === 'string') msg = e.error
+      else if (typeof e.error.message === 'string') msg = e.error.message
+      else if (typeof e.error.detail === 'string') msg = e.error.detail
+      else {
+        try { msg = JSON.stringify(e.error) } catch { msg = String(e.error) }
+      }
+    } else if (typeof e.statusText === 'string' && e.statusText) {
+      msg = `HTTP ${e.status || ''} ${e.statusText}`.trim()
+    } else if (typeof e.cause === 'string') {
+      msg = e.cause
+    } else if (e.cause && typeof e.cause.message === 'string') {
+      msg = e.cause.message
+    }
+
+    if (!msg || msg === '[object Object]') {
+      try {
+        const json = JSON.stringify(e)
+        if (json && json !== '{}') {
+          msg = json.slice(0, 500)
+        }
+      } catch { /* response body not JSON; use raw text */ }
+    }
+
+    if (!msg || msg === '[object Object]') {
+      const keys = Object.getOwnPropertyNames(e)
+      if (keys.length) {
+        msg = `error [${keys.join(', ')}]`
+      } else {
+        msg = String(e)
+      }
+    }
+  } else {
+    msg = String(e)
+  }
+
+  msg = String(msg || 'unknown error').trim()
+
+  if (providerKey) {
+    const prefixRegex = new RegExp(`^${providerKey}\\s*:\\s*`, 'i')
+    while (prefixRegex.test(msg)) {
+      msg = msg.replace(prefixRegex, '').trim()
+    }
+  }
+
+  if (!msg || msg === '[object Object]') {
+    msg = 'unknown error object'
+  } else if (msg.includes('[object Object]')) {
+    msg = msg.replace(/\[object Object\]/g, 'unknown error object').trim()
+  }
+
+  if (providerKey) {
+    return `${providerKey}: ${msg}`
+  }
+
+  return msg
+}
+
+export function resolveSubscriptionSize(size, aspectPixels, aspectRatio) {
+  if (size && SUBSCRIPTION_SIZES[size]) {
+    return SUBSCRIPTION_SIZES[size]
+  }
+  const ratio = String(aspectRatio || '').trim()
+  if (ratio === '16:9' || ratio === '3:2' || ratio === '4:3') {
+    return '1536x1024'
+  }
+  if (ratio === '9:16' || ratio === '2:3' || ratio === '3:4') {
+    return '1024x1536'
+  }
+  if (ratio === '1:1') {
+    return '1024x1024'
+  }
+  if (Array.isArray(aspectPixels) && aspectPixels.length === 2) {
+    const [w, h] = aspectPixels
+    if (w > h) return '1536x1024'
+    if (h > w) return '1024x1536'
+    return '1024x1024'
+  }
+  return '1024x1024'
+}
+
+export const SUBSCRIPTION_SIZES = {
+  square_hd: '1024x1024',
+  square: '1024x1024',
+  portrait_4_3: '1024x1536',
+  portrait_16_9: '1024x1536',
+  landscape_4_3: '1536x1024',
+  landscape_16_9: '1536x1024',
+}
+
+/** Image sizes accepted by fal-ai/flux-2/klein (and most FAL flux models). */
+export const IMAGE_SIZES = [
+  'square_hd',
+  'square',
+  'portrait_4_3',
+  'portrait_16_9',
+  'landscape_4_3',
+  'landscape_16_9',
+]
+
+/** Output formats accepted by the model. */
+export const OUTPUT_FORMATS = ['png', 'jpeg', 'webp']
+
+// Named sizes are a unified abstraction across all providers.
+// FAL accepts named identifiers; OpenAI-compatible gateways require WxH resolution.
+export const SIZE_PIXELS = {
+  square_hd: '1024x1024',
+  square: '512x512',
+  portrait_4_3: '768x1024',
+  portrait_16_9: '576x1024',
+  landscape_4_3: '1024x768',
+  landscape_16_9: '1024x576',
+}
+
+/** Normalize a raw key into a FAL `Authorization: Key <key>` value. */

package/lib/providers/backends/custom.js

@@ -0,0 +1,93 @@
+import {
+  normalizeMediaType,
+  buildEditForm,
+  SIZE_PIXELS,
+  formatErrorMessage,
+  buildEndpointUrl,
+} from '../shared-helpers.js'
+
+/**
+ * @param {fetchImpl: Function, resolveKey: Function, cfg: object} deps
+ * @param {prompt?: string, size?: string, format?: string, seed?: number, signal?: AbortSignal,
+ *   negativePrompt?: string, guidanceScale?: number, source?: object, mask?: object, strength?: number,
+ *   quality?: string, style?: string, aspectPixels?: number[], aspectRatio?: string} job
+ */
+export function createCustomGenerator(deps, job) {
+  const { fetchImpl, resolveKey, cfg } = deps
+  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio } = job
+
+  async function custom(seedArg = seed, promptArg = prompt) {
+    const base = String(cfg.customBaseURL || '').replace(/\/+$/, '')
+    if (!base) throw new Error('Custom image provider: base URL is not configured (Settings → Image generation)')
+    if (!cfg.customModel) throw new Error('Custom image provider: model is not configured')
+
+    // Empty key reference indicates unauthenticated gateway.
+    const key = cfg.customKeyEnv ? await resolveKey(cfg.customKeyEnv) : ''
+    const headers = { 'Content-Type': 'application/json' }
+    if (key) headers.Authorization = `Bearer ${key}`
+
+    // Omit response_format; modern models return either base64 or URL.
+    const endpoint = buildEndpointUrl(base, source ? 'images/edits' : 'images/generations')
+    const res = await fetchImpl(endpoint, {
+      method: 'POST',
+      headers,
+      body: source
+        ? buildEditForm({ source, mask, prompt: promptArg, size: cfg.customSize || (aspectPixels ? aspectPixels.join('x') : SIZE_PIXELS[size]) || size, strength })
+        : JSON.stringify({
+            model: cfg.customModel,
+            prompt: promptArg,
+            n: 1,
+            size: cfg.customSize || (aspectPixels ? aspectPixels.join('x') : SIZE_PIXELS[size]) || size,
+            ...(negativePrompt !== undefined ? { negative_prompt: negativePrompt } : {}),
+            ...(guidanceScale !== undefined ? { guidance_scale: guidanceScale } : {}),
+            ...(quality && quality !== 'auto' ? { quality } : {}),
+          }),
+      signal,
+    })
+    const data = await res.json().catch(() => ({}))
+    if (!res.ok) {
+      if (res.status === 503) {
+        const msg = (data?.error?.message || JSON.stringify(data)).toLowerCase()
+        if (msg.includes('no available channel') || msg.includes('model_not_found')) {
+          throw new Error(`Custom image API has no provisioned channel for "${cfg.customModel}" (HTTP 503); check gateway channel and routing configuration`)
+        }
+      }
+      const detail = formatErrorMessage(data?.error || data)
+      throw new Error(`Image API failed (HTTP ${res.status}): ${detail}`)
+    }
+    const item = data?.data?.[0]
+    if (!item) {
+      throw new Error(`Image API returned no images: ${JSON.stringify(data).slice(0, 600)}`)
+    }
+
+    if (item.b64_json) {
+      return {
+        bytes: Buffer.from(item.b64_json, 'base64'),
+        mediaType: normalizeMediaType(data.output_format || '', format),
+        width: 0,
+        height: 0,
+        seed: seedArg ?? 0,
+        sourceUrl: '',
+      }
+    }
+    if (!item.url) {
+      throw new Error(`Image API returned neither b64_json nor url: ${JSON.stringify(item).slice(0, 300)}`)
+    }
+    const download = await fetchImpl(item.url, { signal })
+    if (!download.ok) {
+      throw new Error(`Failed to download generated image (HTTP ${download.status})`)
+    }
+    const contentType = download.headers && typeof download.headers.get === 'function'
+      ? download.headers.get('content-type')
+      : ''
+    return {
+      bytes: Buffer.from(await download.arrayBuffer()),
+      mediaType: normalizeMediaType(contentType, format),
+      width: 0,
+      height: 0,
+      seed: seedArg ?? 0,
+      sourceUrl: item.url,
+    }
+  }
+  return custom
+}

package/lib/providers/backends/fal.js

@@ -0,0 +1,67 @@
+import {
+  falAuthHeader,
+  normalizeMediaType,
+  submitJob,
+  pollStatus,
+} from '../shared-helpers.js'
+
+/**
+ * @param {fetchImpl: Function, resolveKey: Function, cfg: object} deps
+ * @param {prompt?: string, size?: string, format?: string, seed?: number, signal?: AbortSignal,
+ *   negativePrompt?: string, guidanceScale?: number, source?: object, mask?: object, strength?: number,
+ *   quality?: string, style?: string, aspectPixels?: number[], aspectRatio?: string} job
+ */
+export function createFalGenerator(deps, job) {
+  const { fetchImpl, resolveKey, cfg } = deps
+  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio } = job
+
+  async function fal(seedArg = seed, promptArg = prompt) {
+    const key = await resolveKey(cfg.apiKeyEnv)
+    const isEdit = Boolean(source && source.bytes)
+    const targetModel = isEdit
+      ? (mask && mask.bytes ? 'fal-ai/flux-pro/v1/inpaint' : 'fal-ai/flux/dev/image-to-image')
+      : cfg.model
+    const body = { prompt: promptArg, image_size: size, num_images: 1 }
+    if (seedArg !== undefined) body.seed = seedArg
+    if (negativePrompt !== undefined) body.negative_prompt = negativePrompt
+    if (guidanceScale !== undefined) body.guidance_scale = guidanceScale
+    if (format !== 'png') body.output_format = format
+    if (isEdit) {
+      body.image_url = `data:${source.mediaType || 'image/png'};base64,${Buffer.from(source.bytes).toString('base64')}`
+      if (mask && mask.bytes) {
+        body.mask_url = `data:${mask.mediaType || 'image/png'};base64,${Buffer.from(mask.bytes).toString('base64')}`
+      }
+      if (strength !== undefined) {
+        body.strength = strength
+      }
+    }
+
+    const submit = await submitJob(fetchImpl, cfg.baseURL, targetModel, key, body, signal)
+    const statusUrl = submit.status_url || `${cfg.baseURL}/${cfg.model}/requests/${submit.request_id}/status`
+    const statusBody = await pollStatus(fetchImpl, statusUrl, key, signal, cfg.pollIntervalMs, cfg.timeoutMs)
+
+    const resultRes = await fetchImpl(statusBody.response_url, {
+      headers: { Authorization: falAuthHeader(key) },
+      signal,
+    })
+    const result = await resultRes.json().catch(() => ({}))
+    const image = result.images && result.images[0]
+    if (!image || !image.url) {
+      throw new Error(`FAL returned no images: ${JSON.stringify(result).slice(0, 600)}`)
+    }
+    const download = await fetchImpl(image.url, { signal })
+    if (!download.ok) {
+      throw new Error(`Failed to download generated image (HTTP ${download.status})`)
+    }
+    return {
+      bytes: Buffer.from(await download.arrayBuffer()),
+      mediaType: normalizeMediaType(image.content_type, format),
+      width: image.width ?? 0,
+      height: image.height ?? 0,
+      seed: result.seed ?? seedArg ?? 0,
+      sourceUrl: image.url,
+      cost: result.cost,
+    }
+  }
+  return fal
+}

package/lib/providers/backends/gemini.js

@@ -0,0 +1,37 @@
+import {
+  normalizeMediaType,
+} from '../shared-helpers.js'
+
+/**
+ * @param {fetchImpl: Function, resolveKey: Function, cfg: object} deps
+ * @param {prompt?: string, size?: string, format?: string, seed?: number, signal?: AbortSignal,
+ *   negativePrompt?: string, guidanceScale?: number, source?: object, mask?: object, strength?: number,
+ *   quality?: string, style?: string, aspectPixels?: number[], aspectRatio?: string} job
+ */
+export function createGeminiGenerator(deps, job) {
+  const { fetchImpl, resolveKey, cfg } = deps
+  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio } = job
+
+  async function gemini(seedArg = seed, promptArg = prompt) {
+    const key = await resolveKey(cfg.geminiKeyEnv)
+    const model = cfg.geminiModel || 'gemini-2.0-flash-exp-image-generation'
+    const res = await fetchImpl(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${encodeURIComponent(key)}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: promptArg }] }],
+        generationConfig: { responseModalities: ['IMAGE'], ...(quality !== undefined ? { imageConfig: { imageQuality: quality } } : {}), ...(style !== undefined ? { imageConfig: { imageStyle: style } } : {}) },
+      }),
+      signal,
+    })
+    const data = await res.json().catch(() => ({}))
+    if (!res.ok) {
+      const detail = data?.error?.message || JSON.stringify(data).slice(0, 600)
+      throw new Error(`Gemini failed (HTTP ${res.status}): ${detail}`)
+    }
+    const part = data?.candidates?.[0]?.content?.parts?.find((p) => p.inlineData?.data)
+    if (!part) throw new Error('Gemini returned no image')
+    return { bytes: Buffer.from(part.inlineData.data, 'base64'), mediaType: normalizeMediaType(part.inlineData.mimeType || 'image/png', format), width: 0, height: 0, seed: seedArg ?? 0, sourceUrl: '' }
+  }
+  return gemini
+}