Create api_providers.py

api_providers.py

@@ -0,0 +1,872 @@
+"""
+TimeLapseForge — Universal API Provider Layer
+Supports 15+ image generation APIs with a unified interface.
+Users provide their own API keys.
+"""
+
+import os
+import io
+import time
+import base64
+import tempfile
+import requests
+import httpx
+from PIL import Image
+from typing import Optional, Dict, List, Any, Tuple
+from abc import ABC, abstractmethod
+
+
+# ═══════════════════════════════════════════
+# BASE PROVIDER CLASS
+# ═══════════════════════════════════════════
+
+class BaseProvider(ABC):
+    """Abstract base class for all API providers."""
+
+    name: str = "base"
+    display_name: str = "Base Provider"
+    website: str = ""
+    supports_img2img: bool = False
+    supports_negative_prompt: bool = True
+    default_model: str = ""
+    available_models: List[str] = []
+    requires_api_key: bool = True
+
+    def __init__(self, api_key: str = ""):
+        self.api_key = api_key.strip()
+
+    @abstractmethod
+    def generate_image(
+        self,
+        prompt: str,
+        negative_prompt: str = "",
+        width: int = 1024,
+        height: int = 1024,
+        seed: Optional[int] = None,
+        model: Optional[str] = None,
+        **kwargs,
+    ) -> Image.Image:
+        """Generate an image from a text prompt."""
+        pass
+
+    def img2img(
+        self,
+        prompt: str,
+        image: Image.Image,
+        strength: float = 0.4,
+        negative_prompt: str = "",
+        seed: Optional[int] = None,
+        model: Optional[str] = None,
+        **kwargs,
+    ) -> Image.Image:
+        """Generate an image from another image + prompt. Falls back to txt2img."""
+        return self.generate_image(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            width=image.width,
+            height=image.height,
+            seed=seed,
+            model=model,
+            **kwargs,
+        )
+
+    def validate_key(self) -> Tuple[bool, str]:
+        """Check if the API key is valid."""
+        if not self.api_key:
+            return False, "No API key provided."
+        return True, "Key format OK (not verified with server)."
+
+    @staticmethod
+    def _image_to_base64(img: Image.Image, format: str = "PNG") -> str:
+        """Convert PIL Image to base64 string."""
+        buffer = io.BytesIO()
+        img.save(buffer, format=format)
+        return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+    @staticmethod
+    def _base64_to_image(b64: str) -> Image.Image:
+        """Convert base64 string to PIL Image."""
+        data = base64.b64decode(b64)
+        return Image.open(io.BytesIO(data)).convert("RGB")
+
+    @staticmethod
+    def _url_to_image(url: str) -> Image.Image:
+        """Download image from URL and return as PIL Image."""
+        resp = requests.get(url, timeout=120)
+        resp.raise_for_status()
+        return Image.open(io.BytesIO(resp.content)).convert("RGB")
+
+    @staticmethod
+    def _bytes_to_image(data: bytes) -> Image.Image:
+        """Convert raw bytes to PIL Image."""
+        return Image.open(io.BytesIO(data)).convert("RGB")
+
+
+# ═══════════════════════════════════════════
+# 1. OPENAI (DALL-E 3 / DALL-E 2 / gpt-image-1)
+# ═══════════════════════════════════════════
+
+class OpenAIProvider(BaseProvider):
+    name = "openai"
+    display_name = "OpenAI (DALL·E 3 / gpt-image-1)"
+    website = "https://platform.openai.com/api-keys"
+    supports_img2img = False
+    supports_negative_prompt = False
+    default_model = "dall-e-3"
+    available_models = ["dall-e-3", "dall-e-2", "gpt-image-1"]
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        from openai import OpenAI
+        client = OpenAI(api_key=self.api_key)
+        model = model or self.default_model
+
+        size_map = {
+            (1024, 1024): "1024x1024",
+            (1792, 1024): "1792x1024",
+            (1024, 1792): "1024x1792",
+            (512, 512): "512x512",
+            (256, 256): "256x256",
+        }
+        size = size_map.get((width, height), "1024x1024")
+
+        if model == "gpt-image-1":
+            response = client.images.generate(
+                model="gpt-image-1",
+                prompt=prompt,
+                n=1,
+                size=size,
+            )
+            # gpt-image-1 returns b64_json by default
+            if hasattr(response.data[0], 'b64_json') and response.data[0].b64_json:
+                return self._base64_to_image(response.data[0].b64_json)
+            else:
+                return self._url_to_image(response.data[0].url)
+        else:
+            kwargs_api = dict(
+                model=model,
+                prompt=prompt,
+                n=1,
+                size=size,
+                response_format="b64_json",
+            )
+            if model == "dall-e-3":
+                kwargs_api["quality"] = kwargs.get("quality", "hd")
+                kwargs_api["style"] = kwargs.get("style", "natural")
+
+            response = client.images.generate(**kwargs_api)
+            return self._base64_to_image(response.data[0].b64_json)
+
+
+# ═══════════════════════════════════════════
+# 2. STABILITY AI (Stable Diffusion 3 / SDXL)
+# ═══════════════════════════════════════════
+
+class StabilityProvider(BaseProvider):
+    name = "stability"
+    display_name = "Stability AI (SD3 / SDXL)"
+    website = "https://platform.stability.ai/account/keys"
+    supports_img2img = True
+    supports_negative_prompt = True
+    default_model = "sd3.5-large"
+    available_models = [
+        "sd3.5-large", "sd3.5-large-turbo", "sd3.5-medium",
+        "sd3-large", "sd3-large-turbo", "sd3-medium",
+        "stable-image-core", "stable-image-ultra",
+    ]
+
+    API_BASE = "https://api.stability.ai/v2beta"
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        model = model or self.default_model
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "image/*",
+        }
+
+        data = {
+            "prompt": prompt,
+            "output_format": "png",
+            "width": width,
+            "height": height,
+        }
+        if negative_prompt:
+            data["negative_prompt"] = negative_prompt
+        if seed is not None:
+            data["seed"] = seed
+
+        if "stable-image" in model:
+            url = f"{self.API_BASE}/stable-image/generate/{model.replace('stable-image-', '')}"
+        else:
+            url = f"{self.API_BASE}/stable-image/generate/sd3"
+            data["model"] = model
+
+        resp = requests.post(url, headers=headers, files={"none": ""},
+                             data=data, timeout=120)
+        resp.raise_for_status()
+        return self._bytes_to_image(resp.content)
+
+    def img2img(self, prompt, image, strength=0.4, negative_prompt="",
+                seed=None, model=None, **kwargs):
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "image/*",
+        }
+
+        buf = io.BytesIO()
+        image.save(buf, format="PNG")
+        buf.seek(0)
+
+        data = {
+            "prompt": prompt,
+            "strength": strength,
+            "output_format": "png",
+            "mode": "image-to-image",
+        }
+        if negative_prompt:
+            data["negative_prompt"] = negative_prompt
+        if seed is not None:
+            data["seed"] = seed
+
+        files = {"image": ("input.png", buf, "image/png")}
+        url = f"{self.API_BASE}/stable-image/generate/sd3"
+
+        resp = requests.post(url, headers=headers, files=files,
+                             data=data, timeout=120)
+        resp.raise_for_status()
+        return self._bytes_to_image(resp.content)
+
+
+# ═══════════════════════════════════════════
+# 3. REPLICATE (Flux, SDXL, any model)
+# ═══════════════════════════════════════════
+
+class ReplicateProvider(BaseProvider):
+    name = "replicate"
+    display_name = "Replicate (Flux / SDXL / Any)"
+    website = "https://replicate.com/account/api-tokens"
+    supports_img2img = True
+    supports_negative_prompt = True
+    default_model = "black-forest-labs/flux-1.1-pro"
+    available_models = [
+        "black-forest-labs/flux-1.1-pro",
+        "black-forest-labs/flux-schnell",
+        "black-forest-labs/flux-dev",
+        "stability-ai/sdxl:latest",
+        "stability-ai/stable-diffusion-3.5-large",
+        "bytedance/sdxl-lightning-4step:latest",
+        "lucataco/realvisxl-v4.0:latest",
+        "adirik/realvisxl-v4.0-lightning:latest",
+    ]
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        import replicate
+        client = replicate.Client(api_token=self.api_key)
+        model_id = model or self.default_model
+
+        input_params = {
+            "prompt": prompt,
+            "width": width,
+            "height": height,
+        }
+        if negative_prompt:
+            input_params["negative_prompt"] = negative_prompt
+        if seed is not None:
+            input_params["seed"] = seed
+
+        # Flux models use different param names
+        if "flux" in model_id.lower():
+            input_params.pop("negative_prompt", None)
+
+        output = client.run(model_id, input=input_params)
+
+        # Handle different output formats
+        if isinstance(output, list):
+            url = str(output[0])
+        elif hasattr(output, 'url'):
+            url = output.url
+        else:
+            url = str(output)
+
+        return self._url_to_image(url)
+
+    def img2img(self, prompt, image, strength=0.4, negative_prompt="",
+                seed=None, model=None, **kwargs):
+        import replicate
+        client = replicate.Client(api_token=self.api_key)
+        model_id = model or "stability-ai/sdxl:latest"
+
+        buf = io.BytesIO()
+        image.save(buf, format="PNG")
+        buf.seek(0)
+
+        input_params = {
+            "prompt": prompt,
+            "image": buf,
+            "prompt_strength": strength,
+        }
+        if negative_prompt:
+            input_params["negative_prompt"] = negative_prompt
+        if seed is not None:
+            input_params["seed"] = seed
+
+        output = client.run(model_id, input=input_params)
+        if isinstance(output, list):
+            url = str(output[0])
+        else:
+            url = str(output)
+
+        return self._url_to_image(url)
+
+
+# ═══════════════════════════════════════════
+# 4. TOGETHER AI (Flux, SDXL, Fast)
+# ═══════════════════════════════════════════
+
+class TogetherProvider(BaseProvider):
+    name = "together"
+    display_name = "Together AI (Flux / SDXL / Fast)"
+    website = "https://api.together.xyz/settings/api-keys"
+    supports_img2img = False
+    supports_negative_prompt = True
+    default_model = "black-forest-labs/FLUX.1.1-pro"
+    available_models = [
+        "black-forest-labs/FLUX.1.1-pro",
+        "black-forest-labs/FLUX.1-schnell-Free",
+        "black-forest-labs/FLUX.1-dev",
+        "stabilityai/stable-diffusion-xl-base-1.0",
+    ]
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        from together import Together
+        client = Together(api_key=self.api_key)
+        model_id = model or self.default_model
+
+        params = dict(
+            model=model_id,
+            prompt=prompt,
+            width=width,
+            height=height,
+            steps=kwargs.get("steps", 28),
+            n=1,
+            response_format="b64_json",
+        )
+        if negative_prompt:
+            params["negative_prompt"] = negative_prompt
+        if seed is not None:
+            params["seed"] = seed
+
+        response = client.images.generate(**params)
+        return self._base64_to_image(response.data[0].b64_json)
+
+
+# ═══════════════════════════════════════════
+# 5. FAL.AI (Flux Pro, Fast SDXL, etc.)
+# ═══════════════════════════════════════════
+
+class FalProvider(BaseProvider):
+    name = "fal"
+    display_name = "Fal.ai (Flux Pro / Fast SDXL)"
+    website = "https://fal.ai/dashboard/keys"
+    supports_img2img = True
+    supports_negative_prompt = True
+    default_model = "fal-ai/flux-pro/v1.1"
+    available_models = [
+        "fal-ai/flux-pro/v1.1",
+        "fal-ai/flux/dev",
+        "fal-ai/flux/schnell",
+        "fal-ai/flux-realism",
+        "fal-ai/fast-sdxl",
+        "fal-ai/stable-diffusion-v35-large",
+        "fal-ai/recraft-v3",
+        "fal-ai/ideogram/v2",
+        "fal-ai/aura-flow",
+    ]
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        import fal_client
+        os.environ["FAL_KEY"] = self.api_key
+        model_id = model or self.default_model
+
+        arguments = {
+            "prompt": prompt,
+            "image_size": {"width": width, "height": height},
+            "num_images": 1,
+        }
+        if negative_prompt:
+            arguments["negative_prompt"] = negative_prompt
+        if seed is not None:
+            arguments["seed"] = seed
+
+        result = fal_client.subscribe(model_id, arguments=arguments)
+        images = result.get("images", [])
+        if images:
+            return self._url_to_image(images[0]["url"])
+        raise ValueError("No image returned from Fal.ai")
+
+    def img2img(self, prompt, image, strength=0.4, negative_prompt="",
+                seed=None, model=None, **kwargs):
+        import fal_client
+        os.environ["FAL_KEY"] = self.api_key
+
+        b64 = self._image_to_base64(image)
+        data_uri = f"data:image/png;base64,{b64}"
+
+        arguments = {
+            "prompt": prompt,
+            "image_url": data_uri,
+            "strength": strength,
+            "num_images": 1,
+        }
+        if negative_prompt:
+            arguments["negative_prompt"] = negative_prompt
+        if seed is not None:
+            arguments["seed"] = seed
+
+        model_id = model or "fal-ai/flux/dev/image-to-image"
+        result = fal_client.subscribe(model_id, arguments=arguments)
+        images = result.get("images", [])
+        if images:
+            return self._url_to_image(images[0]["url"])
+        raise ValueError("No image returned from Fal.ai img2img")
+
+
+# ═══════════════════════════════════════════
+# 6. GOOGLE GEMINI (Imagen 3)
+# ═══════════════════════════════════════════
+
+class GoogleGeminiProvider(BaseProvider):
+    name = "google"
+    display_name = "Google Gemini (Imagen 3)"
+    website = "https://aistudio.google.com/apikey"
+    supports_img2img = False
+    supports_negative_prompt = True
+    default_model = "imagen-3.0-generate-002"
+    available_models = [
+        "imagen-3.0-generate-002",
+        "imagen-3.0-fast-generate-001",
+        "gemini-2.0-flash-exp",
+    ]
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        import google.generativeai as genai
+        genai.configure(api_key=self.api_key)
+        model_id = model or self.default_model
+
+        if "gemini" in model_id:
+            # Use Gemini native image gen
+            gen_model = genai.GenerativeModel(model_id)
+            response = gen_model.generate_content(
+                f"Generate an image: {prompt}",
+                generation_config=genai.GenerationConfig(
+                    response_modalities=["image", "text"]
+                ),
+            )
+            for part in response.candidates[0].content.parts:
+                if hasattr(part, 'inline_data') and part.inline_data:
+                    return self._bytes_to_image(part.inline_data.data)
+            raise ValueError("No image in Gemini response")
+        else:
+            # Use Imagen
+            imagen = genai.ImageGenerationModel(model_id)
+            params = dict(
+                prompt=prompt,
+                number_of_images=1,
+            )
+            if negative_prompt:
+                params["negative_prompt"] = negative_prompt
+
+            response = imagen.generate_images(**params)
+            if response.images:
+                return response.images[0]._pil_image.convert("RGB")
+            raise ValueError("No image returned from Imagen")
+
+
+# ═══════════════════════════════════════════
+# 7. HUGGING FACE INFERENCE API
+# ═══════════════════════════════════════════
+
+class HuggingFaceProvider(BaseProvider):
+    name = "huggingface"
+    display_name = "HuggingFace Inference API"
+    website = "https://huggingface.co/settings/tokens"
+    supports_img2img = False
+    supports_negative_prompt = True
+    default_model = "black-forest-labs/FLUX.1-schnell"
+    available_models = [
+        "black-forest-labs/FLUX.1-schnell",
+        "black-forest-labs/FLUX.1-dev",
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        "stabilityai/stable-diffusion-3.5-large",
+        "runwayml/stable-diffusion-v1-5",
+        "prompthero/openjourney-v4",
+        "SG161222/RealVisXL_V4.0",
+    ]
+
+    API_BASE = "https://api-inference.huggingface.co/models"
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        model_id = model or self.default_model
+        url = f"{self.API_BASE}/{model_id}"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "width": width,
+                "height": height,
+            },
+        }
+        if negative_prompt:
+            payload["parameters"]["negative_prompt"] = negative_prompt
+        if seed is not None:
+            payload["parameters"]["seed"] = seed
+
+        resp = requests.post(url, headers=headers, json=payload, timeout=180)
+
+        if resp.status_code == 503:
+            # Model loading
+            time.sleep(20)
+            resp = requests.post(url, headers=headers, json=payload, timeout=180)
+
+        resp.raise_for_status()
+        return self._bytes_to_image(resp.content)
+
+
+# ═══════════════════════════════════════════
+# 8. xAI GROK (Aurora Image Gen)
+# ═══════════════════════════════════════════
+
+class XAIProvider(BaseProvider):
+    name = "xai"
+    display_name = "xAI Grok (Aurora)"
+    website = "https://console.x.ai/team/default/api-keys"
+    supports_img2img = False
+    supports_negative_prompt = False
+    default_model = "grok-2-image"
+    available_models = ["grok-2-image"]
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        from openai import OpenAI
+        client = OpenAI(api_key=self.api_key, base_url="https://api.x.ai/v1")
+
+        response = client.images.generate(
+            model=model or self.default_model,
+            prompt=prompt,
+            n=1,
+            response_format="b64_json",
+            size="1024x1024",
+        )
+        return self._base64_to_image(response.data[0].b64_json)
+
+
+# ═══════════════════════════════════════════
+# 9. FIREWORKS AI
+# ═══════════════════════════════════════════
+
+class FireworksProvider(BaseProvider):
+    name = "fireworks"
+    display_name = "Fireworks AI (Flux / SD)"
+    website = "https://fireworks.ai/account/api-keys"
+    supports_img2img = False
+    supports_negative_prompt = True
+    default_model = "accounts/fireworks/models/flux-1-1-pro"
+    available_models = [
+        "accounts/fireworks/models/flux-1-1-pro",
+        "accounts/fireworks/models/flux-1-schnell-fp8",
+        "accounts/fireworks/models/flux-1-dev-fp8",
+        "accounts/fireworks/models/stable-diffusion-xl-1024-v1-0",
+        "accounts/fireworks/models/playground-v2-5-1024px-aesthetic",
+    ]
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        url = "https://api.fireworks.ai/inference/v1/images/generations"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": model or self.default_model,
+            "prompt": prompt,
+            "n": 1,
+            "size": f"{width}x{height}",
+            "response_format": "b64_json",
+        }
+        if negative_prompt:
+            payload["negative_prompt"] = negative_prompt
+        if seed is not None:
+            payload["seed"] = seed
+
+        resp = requests.post(url, headers=headers, json=payload, timeout=120)
+        resp.raise_for_status()
+        data = resp.json()
+        return self._base64_to_image(data["data"][0]["b64_json"])
+
+
+# ═══════════════════════════════════════════
+# 10. IDEOGRAM
+# ═══════════════════════════════════════════
+
+class IdeogramProvider(BaseProvider):
+    name = "ideogram"
+    display_name = "Ideogram (v2 / v2-turbo)"
+    website = "https://ideogram.ai/manage-api"
+    supports_img2img = False
+    supports_negative_prompt = True
+    default_model = "V_2"
+    available_models = ["V_2", "V_2_TURBO", "V_1", "V_1_TURBO"]
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        url = "https://api.ideogram.ai/generate"
+        headers = {
+            "Api-Key": self.api_key,
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "image_request": {
+                "prompt": prompt,
+                "model": model or self.default_model,
+                "magic_prompt_option": "AUTO",
+                "aspect_ratio": "ASPECT_1_1",
+            }
+        }
+        if negative_prompt:
+            payload["image_request"]["negative_prompt"] = negative_prompt
+        if seed is not None:
+            payload["image_request"]["seed"] = seed
+
+        resp = requests.post(url, headers=headers, json=payload, timeout=120)
+        resp.raise_for_status()
+        data = resp.json()
+        img_url = data["data"][0]["url"]
+        return self._url_to_image(img_url)
+
+
+# ═══════════════════════════════════════════
+# 11. LEONARDO AI
+# ═══════════════════════════════════════════
+
+class LeonardoProvider(BaseProvider):
+    name = "leonardo"
+    display_name = "Leonardo AI"
+    website = "https://app.leonardo.ai/api-access"
+    supports_img2img = False
+    supports_negative_prompt = True
+    default_model = "6b645e3a-d64f-4341-a6d8-7a3690fbf042"  # Leonardo Phoenix
+    available_models = [
+        "6b645e3a-d64f-4341-a6d8-7a3690fbf042",  # Phoenix
+        "aa77f04e-3eec-4034-9c07-d0f619684628",  # Kino XL
+        "1e60896f-3c26-4296-8ecc-53e2afecc132",  # DreamShaper
+    ]
+
+    API_BASE = "https://cloud.leonardo.ai/api/rest/v1"
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "prompt": prompt,
+            "modelId": model or self.default_model,
+            "width": width,
+            "height": height,
+            "num_images": 1,
+        }
+        if negative_prompt:
+            payload["negative_prompt"] = negative_prompt
+        if seed is not None:
+            payload["seed"] = seed
+
+        # Start generation
+        resp = requests.post(
+            f"{self.API_BASE}/generations",
+            headers=headers, json=payload, timeout=60,
+        )
+        resp.raise_for_status()
+        gen_id = resp.json()["sdGenerationJob"]["generationId"]
+
+        # Poll for result
+        for _ in range(30):
+            time.sleep(5)
+            poll = requests.get(
+                f"{self.API_BASE}/generations/{gen_id}",
+                headers=headers, timeout=30,
+            )
+            poll.raise_for_status()
+            data = poll.json()
+            gen = data.get("generations_by_pk", {})
+            if gen.get("status") == "COMPLETE":
+                images = gen.get("generated_images", [])
+                if images:
+                    return self._url_to_image(images[0]["url"])
+
+        raise TimeoutError("Leonardo generation timed out")
+
+
+# ═══════════════════════════════════════════
+# 12. CUSTOM OPENAI-COMPATIBLE API
+# ═══════════════════════════════════════════
+
+class CustomOpenAIProvider(BaseProvider):
+    name = "custom_openai"
+    display_name = "Custom OpenAI-Compatible API"
+    website = ""
+    supports_img2img = False
+    supports_negative_prompt = False
+    default_model = "dall-e-3"
+    available_models = ["dall-e-3", "dall-e-2", "custom"]
+
+    def __init__(self, api_key: str = "", base_url: str = ""):
+        super().__init__(api_key)
+        self.base_url = base_url.strip().rstrip("/") if base_url else ""
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        from openai import OpenAI
+        client_kwargs = {"api_key": self.api_key}
+        if self.base_url:
+            client_kwargs["base_url"] = self.base_url
+        client = OpenAI(**client_kwargs)
+
+        response = client.images.generate(
+            model=model or self.default_model,
+            prompt=prompt,
+            n=1,
+            size=f"{width}x{height}",
+            response_format="b64_json",
+        )
+        return self._base64_to_image(response.data[0].b64_json)
+
+
+# ═══════════════════════════════════════════
+# 13. DIRECT URL API (Generic REST endpoint)
+# ═══════════════════════════════════════════
+
+class DirectURLProvider(BaseProvider):
+    name = "direct_url"
+    display_name = "Direct URL API (Any REST Endpoint)"
+    website = ""
+    supports_img2img = False
+    supports_negative_prompt = True
+    default_model = "custom"
+    available_models = ["custom"]
+
+    def __init__(self, api_key: str = "", endpoint_url: str = ""):
+        super().__init__(api_key)
+        self.endpoint_url = endpoint_url.strip()
+
+    def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
+                       seed=None, model=None, **kwargs):
+        if not self.endpoint_url:
+            raise ValueError("No endpoint URL provided")
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "prompt": prompt,
+            "width": width,
+            "height": height,
+        }
+        if negative_prompt:
+            payload["negative_prompt"] = negative_prompt
+        if seed is not None:
+            payload["seed"] = seed
+        if model:
+            payload["model"] = model
+
+        resp = requests.post(self.endpoint_url, headers=headers, json=payload, timeout=180)
+        resp.raise_for_status()
+
+        content_type = resp.headers.get("Content-Type", "")
+        if "image" in content_type:
+            return self._bytes_to_image(resp.content)
+        else:
+            data = resp.json()
+            # Try common response formats
+            if "images" in data:
+                img_data = data["images"][0]
+                if isinstance(img_data, str) and img_data.startswith("http"):
+                    return self._url_to_image(img_data)
+                return self._base64_to_image(img_data)
+            elif "data" in data:
+                item = data["data"][0]
+                if isinstance(item, dict):
+                    if "b64_json" in item:
+                        return self._base64_to_image(item["b64_json"])
+                    if "url" in item:
+                        return self._url_to_image(item["url"])
+                return self._base64_to_image(str(item))
+            elif "output" in data:
+                return self._url_to_image(data["output"][0])
+
+        raise ValueError("Could not parse image from API response")
+
+
+# ═══════════════════════════════════════════
+# PROVIDER REGISTRY
+# ═══════════════════════════════════════════
+
+PROVIDERS = {
+    "openai": OpenAIProvider,
+    "stability": StabilityProvider,
+    "replicate": ReplicateProvider,
+    "together": TogetherProvider,
+    "fal": FalProvider,
+    "google": GoogleGeminiProvider,
+    "huggingface": HuggingFaceProvider,
+    "xai": XAIProvider,
+    "fireworks": FireworksProvider,
+    "ideogram": IdeogramProvider,
+    "leonardo": LeonardoProvider,
+    "custom_openai": CustomOpenAIProvider,
+    "direct_url": DirectURLProvider,
+}
+
+PROVIDER_DISPLAY_NAMES = {
+    cls.display_name: key for key, cls in PROVIDERS.items()
+}
+
+def get_provider(provider_name: str, api_key: str, **kwargs) -> BaseProvider:
+    """Get a provider instance by name."""
+    cls = PROVIDERS.get(provider_name)
+    if cls is None:
+        raise ValueError(f"Unknown provider: {provider_name}")
+    if provider_name in ("custom_openai", "direct_url"):
+        return cls(api_key=api_key, **kwargs)
+    return cls(api_key=api_key)
+
+def get_provider_info() -> List[Dict[str, Any]]:
+    """Get info about all available providers."""
+    info = []
+    for key, cls in PROVIDERS.items():
+        info.append({
+            "name": key,
+            "display_name": cls.display_name,
+            "website": cls.website,
+            "supports_img2img": cls.supports_img2img,
+            "supports_negative_prompt": cls.supports_negative_prompt,
+            "default_model": cls.default_model,
+            "available_models": cls.available_models,
+        })
+    return info
+
+def get_models_for_provider(provider_name: str) -> List[str]:
+    """Get available models for a provider."""
+    cls = PROVIDERS.get(provider_name)
+    if cls:
+        return cls.available_models
+    return []