Added image generation to blog writer

backend/services/llm_providers/image_generation/__init__.py

@@ -0,0 +1,15 @@
+from .base import ImageGenerationOptions, ImageGenerationResult, ImageGenerationProvider
+from .hf_provider import HuggingFaceImageProvider
+from .gemini_provider import GeminiImageProvider
+from .stability_provider import StabilityImageProvider
+
+__all__ = [
+    "ImageGenerationOptions",
+    "ImageGenerationResult",
+    "ImageGenerationProvider",
+    "HuggingFaceImageProvider",
+    "GeminiImageProvider",
+    "StabilityImageProvider",
+]
+
+

backend/services/llm_providers/image_generation/base.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, Protocol
+
+
+@dataclass
+class ImageGenerationOptions:
+    prompt: str
+    negative_prompt: Optional[str] = None
+    width: int = 1024
+    height: int = 1024
+    guidance_scale: Optional[float] = None
+    steps: Optional[int] = None
+    seed: Optional[int] = None
+    model: Optional[str] = None
+    extra: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class ImageGenerationResult:
+    image_bytes: bytes
+    width: int
+    height: int
+    provider: str
+    model: Optional[str] = None
+    seed: Optional[int] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class ImageGenerationProvider(Protocol):
+    """Protocol for image generation providers."""
+
+    def generate(self, options: ImageGenerationOptions) -> ImageGenerationResult:
+        ...
+
+

backend/services/llm_providers/image_generation/gemini_provider.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import io
+import os
+from typing import Optional
+
+from PIL import Image
+
+from .base import ImageGenerationOptions, ImageGenerationResult, ImageGenerationProvider
+from utils.logger_utils import get_service_logger
+
+
+logger = get_service_logger("image_generation.gemini")
+
+
+class GeminiImageProvider(ImageGenerationProvider):
+    """Google Gemini/Imagen backed image generation.
+
+    NOTE: Implementation should call the actual Gemini Images API used in the codebase.
+    Here we keep a minimal interface and expect the underlying client to be wired
+    similarly to other providers and return a PIL image or raw bytes.
+    """
+
+    def __init__(self) -> None:
+        api_key = os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            logger.warning("GOOGLE_API_KEY not set. Gemini image generation may fail at runtime.")
+        logger.info("GeminiImageProvider initialized")
+
+    def generate(self, options: ImageGenerationOptions) -> ImageGenerationResult:
+        # Placeholder implementation to be replaced by real Gemini/Imagen call.
+        # For now, generate a 1x1 transparent PNG to maintain interface consistency
+        img = Image.new("RGBA", (max(1, options.width), max(1, options.height)), (0, 0, 0, 0))
+        with io.BytesIO() as buf:
+            img.save(buf, format="PNG")
+            png = buf.getvalue()
+
+        return ImageGenerationResult(
+            image_bytes=png,
+            width=img.width,
+            height=img.height,
+            provider="gemini",
+            model=os.getenv("GEMINI_IMAGE_MODEL"),
+            seed=options.seed,
+        )
+
+

backend/services/llm_providers/image_generation/hf_provider.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import io
+import os
+from typing import Optional, Dict, Any
+
+from PIL import Image
+from huggingface_hub import InferenceClient
+
+from .base import ImageGenerationOptions, ImageGenerationResult, ImageGenerationProvider
+from utils.logger_utils import get_service_logger
+
+
+logger = get_service_logger("image_generation.huggingface")
+
+
+DEFAULT_HF_MODEL = os.getenv(
+    "HF_IMAGE_MODEL",
+    "black-forest-labs/FLUX.1-Krea-dev",
+)
+
+
+class HuggingFaceImageProvider(ImageGenerationProvider):
+    """Hugging Face Inference Providers (fal-ai) backed image generation.
+
+    API doc: https://huggingface.co/docs/inference-providers/en/tasks/text-to-image
+    """
+
+    def __init__(self, api_key: Optional[str] = None, provider: str = "fal-ai") -> None:
+        self.api_key = api_key or os.getenv("HF_TOKEN")
+        if not self.api_key:
+            raise RuntimeError("HF_TOKEN is required for Hugging Face image generation")
+        self.provider = provider
+        self.client = InferenceClient(provider=self.provider, api_key=self.api_key)
+        logger.info("HuggingFaceImageProvider initialized (provider=%s)", self.provider)
+
+    def generate(self, options: ImageGenerationOptions) -> ImageGenerationResult:
+        model = options.model or DEFAULT_HF_MODEL
+        params: Dict[str, Any] = {}
+        if options.guidance_scale is not None:
+            params["guidance_scale"] = options.guidance_scale
+        if options.steps is not None:
+            params["num_inference_steps"] = options.steps
+        if options.negative_prompt:
+            params["negative_prompt"] = options.negative_prompt
+        if options.seed is not None:
+            params["seed"] = options.seed
+
+        # The HF InferenceClient returns a PIL Image
+        logger.debug("HF generate: model=%s width=%s height=%s params=%s", model, options.width, options.height, params)
+        img: Image.Image = self.client.text_to_image(
+            options.prompt,
+            model=model,
+            width=options.width,
+            height=options.height,
+            **params,
+        )
+
+        with io.BytesIO() as buf:
+            img.save(buf, format="PNG")
+            image_bytes = buf.getvalue()
+
+        return ImageGenerationResult(
+            image_bytes=image_bytes,
+            width=img.width,
+            height=img.height,
+            provider="huggingface",
+            model=model,
+            seed=options.seed,
+            metadata={"provider": self.provider},
+        )
+
+

backend/services/llm_providers/image_generation/stability_provider.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import io
+import os
+from typing import Optional, Dict, Any
+
+import requests
+from PIL import Image
+
+from .base import ImageGenerationOptions, ImageGenerationResult, ImageGenerationProvider
+from utils.logger_utils import get_service_logger
+
+
+logger = get_service_logger("image_generation.stability")
+
+
+DEFAULT_STABILITY_MODEL = os.getenv("STABILITY_MODEL", "stable-diffusion-xl-1024-v1-0")
+
+
+class StabilityImageProvider(ImageGenerationProvider):
+    """Stability AI Images API provider (simple text-to-image).
+
+    This uses the v1 text-to-image endpoint format. Adjust to match your existing
+    Stability integration if different.
+    """
+
+    def __init__(self, api_key: Optional[str] = None) -> None:
+        self.api_key = api_key or os.getenv("STABILITY_API_KEY")
+        if not self.api_key:
+            logger.warning("STABILITY_API_KEY not set. Stability generation may fail at runtime.")
+        logger.info("StabilityImageProvider initialized")
+
+    def generate(self, options: ImageGenerationOptions) -> ImageGenerationResult:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        payload: Dict[str, Any] = {
+            "text_prompts": [
+                {"text": options.prompt, "weight": 1.0},
+            ],
+            "cfg_scale": options.guidance_scale or 7.0,
+            "steps": options.steps or 30,
+            "width": options.width,
+            "height": options.height,
+            "seed": options.seed,
+        }
+        if options.negative_prompt:
+            payload["text_prompts"].append({"text": options.negative_prompt, "weight": -1.0})
+
+        model = options.model or DEFAULT_STABILITY_MODEL
+        url = f"https://api.stability.ai/v1/generation/{model}/text-to-image"
+
+        logger.debug("Stability generate: model=%s payload_keys=%s", model, list(payload.keys()))
+        resp = requests.post(url, headers=headers, json=payload, timeout=60)
+        resp.raise_for_status()
+        data = resp.json()
+
+        # Expecting data["artifacts"][0]["base64"]
+        import base64
+
+        artifact = (data.get("artifacts") or [{}])[0]
+        b64 = artifact.get("base64", "")
+        image_bytes = base64.b64decode(b64)
+
+        # Confirm dimensions by loading once (optional)
+        img = Image.open(io.BytesIO(image_bytes))
+
+        return ImageGenerationResult(
+            image_bytes=image_bytes,
+            width=img.width,
+            height=img.height,
+            provider="stability",
+            model=model,
+            seed=options.seed,
+        )
+
+