Harden image generation as remote inference calls with provider fallback

Images already ran via HF Inference Providers (no GPU in the Space), but a
single provider being unavailable for the user's token would fail the step.
Now try auto routing then fall back across the providers that serve
FLUX.1-schnell (fal-ai, nscale, together, hf-inference, replicate, wavespeed),
one user-token client each, and surface a clear status if all fail.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

pipeline/config.py

@@ -13,8 +13,16 @@ MODEL_REASONING = os.environ.get("MODEL_REASONING", "openai/gpt-oss-120b")
 # Strong long-form writer for the actual blog post, with a fallback if unavailable.
 MODEL_WRITER = os.environ.get("MODEL_WRITER", "deepseek-ai/DeepSeek-V3-0324")
 MODEL_WRITER_FALLBACK = os.environ.get("MODEL_WRITER_FALLBACK", "Qwen/Qwen2.5-72B-Instruct")
-# Text-to-image model (as requested).
+# Text-to-image model (as requested). Generated via remote Inference Providers — this
+# Space has no GPU, so images are always produced by serverless inference calls.
 MODEL_IMAGE = os.environ.get("MODEL_IMAGE", "black-forest-labs/FLUX.1-schnell")
+# Providers that currently serve FLUX.1-schnell, tried in order after auto-routing.
+# One user-token InferenceClient per provider; billing follows the token.
+IMAGE_PROVIDERS = [
+    p.strip() for p in os.environ.get(
+        "IMAGE_PROVIDERS", "fal-ai,nscale,together,hf-inference,replicate,wavespeed"
+    ).split(",") if p.strip()
+]
 # Vision-language model for captioning generated images.
 MODEL_VISION = os.environ.get("MODEL_VISION", "Qwen/Qwen2.5-VL-72B-Instruct")
 

pipeline/images.py

@@ -1,8 +1,15 @@
-"""Step 6: turn each [IMAGE: ...] marker into a FLUX prompt and render it."""
+"""Step 6: turn each [IMAGE: ...] marker into a FLUX prompt and render it.
+
+Images are produced entirely by **remote HF Inference Provider calls** (FLUX.1-schnell)
+billed to the user's token — this Space has no GPU, so nothing is generated locally.
+The render tries auto provider routing first, then falls back across the providers that
+serve the model, so a single provider being unavailable for the user's token doesn't
+break the run.
+"""
 from __future__ import annotations
 
 from pathlib import Path
-from typing import List
+from typing import List, Optional, Tuple
 
 from huggingface_hub import InferenceClient
 
@@ -33,24 +40,51 @@ def _flux_prompt(client: InferenceClient, topic: str, scene: str) -> str:
         return f"{scene}, editorial photography, clean composition, natural lighting"
 
 
+def _render(hf_token: str, prompt: str) -> Tuple[Optional[object], Optional[str]]:
+    """Generate one image via Inference Providers, trying auto then explicit providers.
+
+    Returns (PIL image, None) on success or (None, error message) if every provider fails.
+    """
+    # None => let the router auto-select; then try each known provider explicitly.
+    attempts: List[Optional[str]] = [None] + config.IMAGE_PROVIDERS
+    errors: List[str] = []
+    for provider in attempts:
+        try:
+            client = (
+                InferenceClient(token=hf_token, provider=provider)
+                if provider
+                else InferenceClient(token=hf_token)
+            )
+            image = client.text_to_image(prompt=prompt, model=config.MODEL_IMAGE)
+            return image, None
+        except Exception as e:  # noqa: BLE001 - try the next provider
+            errors.append(f"{provider or 'auto'}: {e}")
+            continue
+    return None, " | ".join(errors[-3:])
+
+
 def generate_images(
     client: InferenceClient,
+    hf_token: str,
     topic: str,
     scenes: List[str],
     run_dir: Path,
 ) -> List[dict]:
-    """Render one image per scene. Returns [{scene, prompt, path|None, error?}]."""
+    """Render one image per scene via inference calls. Returns [{scene, prompt, path|None, error?}]."""
     run_dir.mkdir(parents=True, exist_ok=True)
     out: List[dict] = []
     for i, scene in enumerate(scenes):
         prompt = _flux_prompt(client, topic, scene)
         item = {"scene": scene, "prompt": prompt, "path": None}
-        try:
-            image = client.text_to_image(prompt=prompt, model=config.MODEL_IMAGE)
-            path = run_dir / f"image_{i + 1}.png"
-            image.save(path)
-            item["path"] = str(path)
-        except Exception as e:  # noqa: BLE001 - one bad image shouldn't kill the run
-            item["error"] = str(e)
+        image, err = _render(hf_token, prompt)
+        if image is not None:
+            try:
+                path = run_dir / f"image_{i + 1}.png"
+                image.save(path)
+                item["path"] = str(path)
+            except Exception as e:  # noqa: BLE001
+                item["error"] = f"save failed: {e}"
+        else:
+            item["error"] = err or "image generation failed"
         out.append(item)
     return out

pipeline/orchestrator.py

@@ -79,11 +79,16 @@ def run(
     (run_dir / "post.md").write_text(markdown, encoding="utf-8")
     result["markdown"] = markdown
 
-    # 6) generate images
+    # 6) generate images (remote FLUX.1-schnell inference calls, billed to the user)
     scenes = writer.parse_image_markers(markdown)
     yield 0.70, f"Generating {len(scenes)} images with FLUX.1-schnell…", result
-    imgs = images.generate_images(client, topic, scenes, run_dir)
+    imgs = images.generate_images(client, hf_token, topic, scenes, run_dir)
     result["images"] = imgs
+    n_ok = sum(1 for im in imgs if im.get("path"))
+    if n_ok == 0 and imgs:
+        yield 0.72, f"⚠ Image generation failed: {imgs[0].get('error', 'unknown error')}", result
+    else:
+        yield 0.72, f"Generated {n_ok}/{len(imgs)} images.", result
 
     # 7) caption images
     yield 0.85, "Captioning images…", result