@goodandready/dsh-image-gen 0.10.24 → 0.10.26

package/lib/providers/backends/replicate.js

@@ -0,0 +1,83 @@
+import {
+  normalizeMediaType,
+  estimateCost,
+  pxSize,
+  calculateBackoff,
+  ASPECT_RATIOS,
+} 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 createReplicateGenerator(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 replicate(seedArg = seed, promptArg = prompt) {
+    const key = await resolveKey(cfg.replicateKeyEnv || 'REPLICATE_API_TOKEN')
+    if (!key) throw new Error('Replicate API token is not configured (Settings → Image generation → replicateKeyEnv)')
+    const model = cfg.replicateModel || 'black-forest-labs/flux-schnell'
+    const [width, height] = pxSize(aspectPixels, size)
+    const body = {
+      input: {
+        prompt: promptArg,
+        aspect_ratio: aspectPixels ? `${aspectPixels[0]}:${aspectPixels[1]}` : (ASPECT_RATIOS[size] || '1:1'),
+        seed: seedArg,
+        ...(negativePrompt ? { negative_prompt: negativePrompt } : {}),
+        ...(source && source.bytes ? {
+          image: `data:${source.mediaType || 'image/png'};base64,${Buffer.from(source.bytes).toString('base64')}`,
+          ...(mask && mask.bytes ? { mask: `data:${mask.mediaType || 'image/png'};base64,${Buffer.from(mask.bytes).toString('base64')}` } : {}),
+          ...(strength !== undefined ? { prompt_strength: strength } : {}),
+        } : {}),
+      },
+    }
+    const res = await fetchImpl(`https://api.replicate.com/v1/models/${model}/predictions`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${key}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+      signal,
+    })
+    const data = await res.json().catch(() => ({}))
+    if (!res.ok) {
+      throw new Error(`Replicate submit failed (HTTP ${res.status}): ${data.detail || JSON.stringify(data).slice(0, 300)}`)
+    }
+    let pred = data
+    if (pred.status !== 'succeeded') {
+      const pollUrl = pred.urls?.get || `https://api.replicate.com/v1/predictions/${pred.id}`
+      const deadline = Date.now() + (cfg.timeoutMs || 180000)
+      let attempt = 0
+    while (pred.status !== 'succeeded') {
+        if (signal?.aborted) throw new Error('Replicate generation cancelled')
+        if (Date.now() > deadline) throw new Error('Replicate generation timed out')
+        if (pred.status === 'failed' || pred.status === 'canceled') {
+          throw new Error(`Replicate failed: ${pred.error || 'unknown error'}`)
+        }
+        const repDelay = calculateBackoff(attempt++, cfg.pollIntervalMs || 1000, 5000)
+        await new Promise((r) => setTimeout(r, repDelay))
+        const pRes = await fetchImpl(pollUrl, { headers: { Authorization: `Bearer ${key}` }, signal })
+        pred = await pRes.json().catch(() => ({}))
+      }
+    }
+    const output = Array.isArray(pred.output) ? pred.output[0] : pred.output
+    if (!output) throw new Error('Replicate returned no image output')
+    const dl = await fetchImpl(output, { signal })
+    if (!dl.ok) throw new Error(`Replicate download failed (HTTP ${dl.status})`)
+    const bytes = Buffer.from(await dl.arrayBuffer())
+    return {
+      bytes,
+      mediaType: normalizeMediaType(dl.headers?.get?.('content-type') || 'image/png', format),
+      width,
+      height,
+      seed: seedArg ?? 0,
+      cost: estimateCost('replicate', model),
+      sourceUrl: output,
+    }
+  }
+  return replicate
+}

package/lib/providers/backends/seedream.js

@@ -0,0 +1,49 @@
+import {
+  normalizeMediaType,
+  SIZE_PIXELS,
+} 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 createSeedreamGenerator(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 seedream(seedArg = seed, promptArg = prompt) {
+    const key = await resolveKey(cfg.seedreamKeyEnv)
+    const base = (cfg.seedreamBaseURL || 'https://api.bytedanceapi.com/v1').replace(/\/+$/, '')
+    const res = await fetchImpl(`${base}/images/generations`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${key}` },
+      body: JSON.stringify({
+        model: cfg.seedreamModel || 'seedream-4.0',
+        prompt: promptArg,
+        n: 1,
+        size: (aspectPixels ? aspectPixels.join('x') : SIZE_PIXELS[size]) || size,
+        ...(negativePrompt !== undefined ? { negative_prompt: negativePrompt } : {}),
+        ...(quality !== undefined ? { quality } : {}),
+        ...(style !== undefined ? { 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(`Seedream failed (HTTP ${res.status}): ${detail}`)
+    }
+    const item = data?.data?.[0]
+    if (!item) throw new Error('Seedream returned no images')
+    if (item.b64_json) {
+      return { bytes: Buffer.from(item.b64_json, 'base64'), mediaType: normalizeMediaType('image/png', format), width: 0, height: 0, seed: seedArg ?? 0, sourceUrl: '' }
+    }
+    if (!item.url) throw new Error('Seedream returned neither b64_json nor url')
+    const dl = await fetchImpl(item.url, { signal })
+    if (!dl.ok) throw new Error(`Seedream download failed (HTTP ${dl.status})`)
+    return { bytes: Buffer.from(await dl.arrayBuffer()), mediaType: normalizeMediaType('image/png', format), width: 0, height: 0, seed: seedArg ?? 0, sourceUrl: item.url }
+  }
+  return seedream
+}

package/lib/providers/backends/subscription.js

@@ -0,0 +1,58 @@
+import {
+  formatErrorMessage,
+  resolveSubscriptionSize,
+} 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 createSubscriptionGenerator(deps, job) {
+  const { fetchImpl, resolveKey, cfg } = deps
+  const { prompt, size, format, seed, signal, negativePrompt, guidanceScale, source, mask, strength, quality, style, aspectPixels, aspectRatio } = job
+
+  function subscription(provider) {
+    return async function generate(seedArg = seed, promptArg = prompt) {
+      if (source) {
+        return { ok: false, provider, reason: `${provider}: does not support image editing — use fal, custom, or local` }
+      }
+      const images = deps.subscriptionImages
+      if (!images || typeof images.generate !== 'function') {
+        return {
+          ok: false,
+          provider,
+          reason: `${provider}: requires dsh-subscriptions plugin to manage session authentication`,
+        }
+      }
+      let produced
+      try {
+        produced = await images.generate({
+          provider,
+          prompt: promptArg,
+          size: resolveSubscriptionSize(size, aspectPixels, aspectRatio),
+          quality: cfg.subscriptionQuality || undefined,
+          signal,
+        })
+      } catch (e) {
+        return { ok: false, provider, reason: formatErrorMessage(e, provider) }
+      }
+      const first = Array.isArray(produced) ? produced[0] : null
+      if (!first || !first.b64_json) {
+        return { ok: false, provider, reason: `${provider}: no image returned in response` }
+      }
+      return {
+        bytes: Buffer.from(first.b64_json, 'base64'),
+        // Subscription outputs default to PNG media type.
+        mediaType: 'image/png',
+        width: 0,
+        height: 0,
+        seed: seedArg ?? 0,
+        sourceUrl: '',
+        revisedPrompt: first.revisedPrompt || '',
+      }
+    }
+  }
+  return subscription
+}

package/lib/providers/shared-helpers.js

@@ -0,0 +1,164 @@
+/**
+ * Shared provider HTTP/auth helpers used by per-backend factories.
+ * Extracted from providers.js for #218 modularization.
+ */
+import {
+  SIZE_PIXELS,
+  formatErrorMessage,
+  buildEndpointUrl,
+  resolveSubscriptionSize,
+  calculateBackoff,
+} from '../provider-utils.js'
+
+export {
+  SIZE_PIXELS,
+  formatErrorMessage,
+  buildEndpointUrl,
+  resolveSubscriptionSize,
+  calculateBackoff,
+}
+export function falAuthHeader(key) {
+  const trimmed = String(key ?? '').trim()
+  if (!trimmed) return ''
+  return trimmed.startsWith('Key ') || trimmed.startsWith('key ')
+    ? trimmed
+    : `Key ${trimmed}`
+}
+
+export function normalizeMediaType(contentType, fallbackFormat) {
+  const raw = String(contentType ?? '').toLowerCase()
+  if (raw.includes('jpeg') || raw.includes('jpg')) return 'image/jpeg'
+  if (raw.includes('webp')) return 'image/webp'
+  if (raw.includes('png')) return 'image/png'
+  if (fallbackFormat === 'jpeg') return 'image/jpeg'
+  if (fallbackFormat === 'webp') return 'image/webp'
+  return 'image/png'
+}
+
+export async function submitJob(fetchImpl, baseURL, model, key, body, signal) {
+  const res = await fetchImpl(`${baseURL}/${model}`, {
+    method: 'POST',
+    headers: {
+      Authorization: falAuthHeader(key),
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+    signal,
+  })
+  const data = await res.json().catch(() => ({}))
+  if (!res.ok || !data.request_id) {
+    const detail = typeof data.detail === 'string' ? data.detail : JSON.stringify(data).slice(0, 600)
+    throw new Error(`FAL submit failed (HTTP ${res.status}): ${detail}`)
+  }
+  return data
+}
+
+export async function pollStatus(fetchImpl, statusUrl, key, signal, pollIntervalMs = 500, timeoutMs = 180000) {
+  const deadline = Date.now() + timeoutMs
+  let attempt = 0
+  for (;;) {
+    if (signal?.aborted) throw new Error('FAL generation cancelled')
+    if (Date.now() > deadline) throw new Error(`FAL generation timed out after ${timeoutMs} ms`)
+    if (attempt > 0) {
+      const delay = calculateBackoff(attempt - 1, pollIntervalMs, 5000)
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, delay)
+        if (signal) {
+          signal.addEventListener('abort', () => {
+            clearTimeout(timer)
+            resolve()
+          }, { once: true })
+        }
+      })
+    }
+    attempt++
+    if (signal?.aborted) throw new Error('FAL generation cancelled')
+    const res = await fetchImpl(statusUrl, { headers: { Authorization: falAuthHeader(key) }, signal })
+    const data = await res.json().catch(() => ({}))
+    const status = data.status
+    if (status === 'COMPLETED') return data
+    if (status === 'ERROR' || data.error || data.detail) {
+      throw new Error(`FAL generation failed: ${JSON.stringify(data).slice(0, 600)}`)
+    }
+    if (status !== 'IN_QUEUE' && status !== 'IN_PROGRESS') {
+      throw new Error(`Unexpected FAL status "${status}": ${JSON.stringify(data).slice(0, 300)}`)
+    }
+  }
+}
+
+export function buildEditForm({ source, mask, prompt, size, strength }) {
+  const form = new FormData()
+  form.append('image', new Blob([source.bytes], { type: source.mediaType || 'image/png' }), 'source.png')
+  if (mask) form.append('mask', new Blob([mask.bytes], { type: mask.mediaType || 'image/png' }), 'mask.png')
+  form.append('prompt', prompt)
+  if (size) form.append('size', size)
+  if (strength !== undefined) form.append('strength', String(strength))
+  return form
+}
+
+export function estimateCost(provider, model, { count = 1 } = {}) {
+  const p = String(provider).toLowerCase()
+  if (p === 'fal') {
+    if (String(model).includes('schnell') || String(model).includes('klein')) return 0.003 * count
+    if (String(model).includes('dev')) return 0.025 * count
+    if (String(model).includes('clarity') || String(model).includes('upscale')) return 0.01 * count
+    return 0.005 * count
+  }
+  if (p === 'replicate') return 0.003 * count
+  if (p === 'seedream') return 0.004 * count
+  if (p === 'gemini') return 0.03 * count
+  if (p === 'codex' || p === 'grok' || p === 'local') return 0.0
+  return 0.01 * count
+}
+
+
+export function snapToMultipleOf64(dim, minVal = 256, maxVal = 2048) {
+  const n = Math.round(Number(dim) / 64) * 64
+  return Math.max(minVal, Math.min(maxVal, n))
+}
+
+export function snapDimensions(width, height) {
+  return [snapToMultipleOf64(width), snapToMultipleOf64(height)]
+}
+
+export function extractComfyNodeErrors(entry) {
+  if (!entry || typeof entry !== 'object') return ''
+  const status = entry.status
+  if (status && status.status_str === 'error') {
+    const msgs = status.messages || []
+    const errList = []
+    for (const m of msgs) {
+      if (Array.isArray(m) && m[0] === 'execution_error') {
+        const d = m[1] || {}
+        errList.push(`node ${d.node_id || 'unknown'} (${d.node_type || ''}): ${d.exception_message || d.exception_type || 'execution failed'}`)
+      }
+    }
+    if (errList.length) return errList.join('; ')
+    return status.status_str || 'execution error'
+  }
+  return ''
+}
+
+export function pxSize(aspectPixels, size) {
+  if (aspectPixels) return snapDimensions(aspectPixels[0], aspectPixels[1])
+  const [w, h] = sizeToPixels(size)
+  return snapDimensions(w, h)
+}
+
+export const ASPECT_RATIOS = {
+  '1:1': [1024, 1024],
+  '16:9': [1344, 768],
+  '9:16': [768, 1344],
+  '4:3': [1152, 896],
+  '3:4': [896, 1152],
+  '3:2': [1152, 768],
+  '2:3': [768, 1152],
+}
+
+export function sizeToPixels(size) {
+  const px = SIZE_PIXELS[size]
+  if (!px) return [1024, 1024]
+  const [w, h] = px.split('x').map(Number)
+  return [w, h]
+}
+