Update api_providers.py

api_providers.py

@@ -1,7 +1,7 @@
 """
-TimeLapseForge — Universal API Provider Layer v2.1
-All API client imports are LAZY — packages install only when needed.
-App will always start regardless of which API packages are installed.
+TimeLapseForge - Universal API Provider Layer v2.2
+All API client imports are LAZY.
+Smart prompt truncation per provider.
 """
 
 import os
@@ -15,59 +15,123 @@ from typing import Optional, Dict, List, Any, Tuple
 from abc import ABC, abstractmethod
 
 
-def _safe_import(package_name, pip_name=None):
-    """Try importing a package. Return None if not available."""
+def _safe_import(package_name):
     try:
         import importlib
         return importlib.import_module(package_name)
     except ImportError:
-        display = pip_name or package_name
         return None
 
 
 def _require_import(package_name, pip_name=None):
-    """Import a package or raise a friendly error."""
     mod = _safe_import(package_name)
     if mod is None:
         pip = pip_name or package_name
         raise ImportError(
-            f"📦 Package '{pip}' is not installed. "
-            f"This provider requires it. The Space admin can add '{pip}' to requirements.txt, "
-            f"or you can use a different provider that doesn't need it."
+            "Package '" + pip + "' is not installed. "
+            "Add it to requirements.txt or use a different provider."
         )
     return mod
 
 
-# ═══════════════════════════════════════════
+# ============================================
+# SMART PROMPT TRUNCATOR
+# ============================================
+
+def smart_truncate(text, max_length, preserve_end=True):
+    """
+    Intelligently truncate a prompt to fit within API limits.
+    Preserves the most important parts: subject description and style suffix.
+    """
+    if not text or len(text) <= max_length:
+        return text
+
+    # Strategy: keep first part (subject) and last part (style keywords)
+    if preserve_end:
+        # Find the last comma-separated style section
+        parts = text.rsplit(", ", 1)
+        if len(parts) == 2 and len(parts[1]) < max_length // 3:
+            suffix = ", " + parts[1]
+            available = max_length - len(suffix) - 5  # 5 for " ... "
+            if available > 100:
+                return text[:available] + " ... " + suffix
+
+    # Simple truncation with clean cut at word boundary
+    truncated = text[:max_length - 3]
+    last_space = truncated.rfind(" ")
+    if last_space > max_length // 2:
+        truncated = truncated[:last_space]
+    return truncated + "..."
+
+
+def split_prompt_parts(full_prompt):
+    """
+    Split a long prompt into core subject and style modifiers.
+    Returns (core, style) where style is the reusable suffix.
+    """
+    # Common style keywords that appear at the end
+    style_markers = [
+        "photorealistic", "cinematic", "4K", "8K", "detailed",
+        "shot on", "lens", "lighting", "consistent", "camera",
+        "high quality", "professional", "dramatic",
+    ]
+    
+    # Try to find where style section starts
+    lower = full_prompt.lower()
+    best_split = len(full_prompt)
+    
+    for marker in style_markers:
+        idx = lower.rfind(marker)
+        if idx > len(full_prompt) // 2:
+            # Find the comma before this marker
+            comma_idx = full_prompt.rfind(", ", 0, idx)
+            if comma_idx > len(full_prompt) // 3:
+                best_split = min(best_split, comma_idx)
+    
+    if best_split < len(full_prompt):
+        core = full_prompt[:best_split].strip().rstrip(",")
+        style = full_prompt[best_split:].strip().lstrip(",").strip()
+        return core, style
+    
+    return full_prompt, ""
+
+
+# ============================================
 # BASE PROVIDER CLASS
-# ═══════════════════════════════════════════
+# ============================================
 
 class BaseProvider(ABC):
-    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_package: str = ""  # pip package name needed
-
-    def __init__(self, api_key: str = ""):
+    name = "base"
+    display_name = "Base Provider"
+    website = ""
+    supports_img2img = False
+    supports_negative_prompt = True
+    default_model = ""
+    available_models = []
+    requires_package = ""
+    max_prompt_length = 10000  # Default generous limit
+
+    def __init__(self, api_key=""):
         self.api_key = api_key.strip()
 
+    def _truncate(self, prompt, max_len=None):
+        """Truncate prompt to fit provider's limit."""
+        limit = max_len or self.max_prompt_length
+        return smart_truncate(prompt, limit)
+
     @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:
+        self, prompt, negative_prompt="",
+        width=1024, height=1024,
+        seed=None, model=None, **kwargs,
+    ):
         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:
+        self, prompt, image, strength=0.4,
+        negative_prompt="", seed=None,
+        model=None, **kwargs,
+    ):
         return self.generate_image(
             prompt=prompt, negative_prompt=negative_prompt,
             width=image.width, height=image.height,
@@ -75,40 +139,41 @@ class BaseProvider(ABC):
         )
 
     @staticmethod
-    def _image_to_base64(img: Image.Image, fmt: str = "PNG") -> str:
+    def _image_to_base64(img, fmt="PNG"):
         buf = io.BytesIO()
         img.save(buf, format=fmt)
         return base64.b64encode(buf.getvalue()).decode("utf-8")
 
     @staticmethod
-    def _base64_to_image(b64: str) -> Image.Image:
+    def _base64_to_image(b64):
         data = base64.b64decode(b64)
         return Image.open(io.BytesIO(data)).convert("RGB")
 
     @staticmethod
-    def _url_to_image(url: str) -> Image.Image:
+    def _url_to_image(url):
         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:
+    def _bytes_to_image(data):
         return Image.open(io.BytesIO(data)).convert("RGB")
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # 1. OPENAI (DALL-E 3 / gpt-image-1)
-# ═══════════════════════════════════════════
+# ============================================
 
 class OpenAIProvider(BaseProvider):
     name = "openai"
-    display_name = "OpenAI (DALL·E 3 / gpt-image-1)"
+    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"]
     requires_package = "openai"
+    max_prompt_length = 3900  # DALL-E 3 limit is 4000
 
     def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
                        seed=None, model=None, **kwargs):
@@ -116,6 +181,16 @@ class OpenAIProvider(BaseProvider):
         client = openai_mod.OpenAI(api_key=self.api_key)
         model = model or self.default_model
 
+        # Set correct limit per model
+        if model == "dall-e-2":
+            limit = 900  # DALL-E 2 limit is 1000
+        elif model == "gpt-image-1":
+            limit = 32000  # gpt-image-1 has much higher limit
+        else:
+            limit = 3900  # DALL-E 3
+
+        safe_prompt = self._truncate(prompt, limit)
+
         size_map = {
             (1024, 1024): "1024x1024", (1792, 1024): "1792x1024",
             (1024, 1792): "1024x1792", (512, 512): "512x512",
@@ -125,14 +200,14 @@ class OpenAIProvider(BaseProvider):
 
         if model == "gpt-image-1":
             response = client.images.generate(
-                model="gpt-image-1", prompt=prompt, n=1, size=size,
+                model="gpt-image-1", prompt=safe_prompt, n=1, size=size,
             )
             if hasattr(response.data[0], 'b64_json') and response.data[0].b64_json:
                 return self._base64_to_image(response.data[0].b64_json)
             return self._url_to_image(response.data[0].url)
         else:
             api_kwargs = dict(
-                model=model, prompt=prompt, n=1, size=size,
+                model=model, prompt=safe_prompt, n=1, size=size,
                 response_format="b64_json",
             )
             if model == "dall-e-3":
@@ -142,9 +217,9 @@ class OpenAIProvider(BaseProvider):
             return self._base64_to_image(response.data[0].b64_json)
 
 
-# ═══════════════════════════════════════════
-# 2. STABILITY AI (SD3 / SDXL)
-# ═══════════════════════════════════════════
+# ============================================
+# 2. STABILITY AI
+# ============================================
 
 class StabilityProvider(BaseProvider):
     name = "stability"
@@ -158,24 +233,26 @@ class StabilityProvider(BaseProvider):
         "sd3-large", "sd3-large-turbo", "sd3-medium",
         "stable-image-core", "stable-image-ultra",
     ]
-    requires_package = ""  # uses requests only
+    requires_package = ""
+    max_prompt_length = 10000
 
     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}
+        safe_prompt = self._truncate(prompt)
+        headers = {"Authorization": "Bearer " + self.api_key, "Accept": "image/*"}
+        data = {"prompt": safe_prompt, "output_format": "png", "width": width, "height": height}
         if negative_prompt:
-            data["negative_prompt"] = negative_prompt
+            data["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         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-', '')}"
+            url = self.API_BASE + "/stable-image/generate/" + model.replace("stable-image-", "")
         else:
-            url = f"{self.API_BASE}/stable-image/generate/sd3"
+            url = self.API_BASE + "/stable-image/generate/sd3"
             data["model"] = model
 
         resp = requests.post(url, headers=headers, files={"none": ""}, data=data, timeout=120)
@@ -184,30 +261,31 @@ class StabilityProvider(BaseProvider):
 
     def img2img(self, prompt, image, strength=0.4, negative_prompt="",
                 seed=None, model=None, **kwargs):
-        headers = {"Authorization": f"Bearer {self.api_key}", "Accept": "image/*"}
+        safe_prompt = self._truncate(prompt)
+        headers = {"Authorization": "Bearer " + self.api_key, "Accept": "image/*"}
         buf = io.BytesIO()
         image.save(buf, format="PNG")
         buf.seek(0)
 
         data = {
-            "prompt": prompt, "strength": strength,
+            "prompt": safe_prompt, "strength": strength,
             "output_format": "png", "mode": "image-to-image",
         }
         if negative_prompt:
-            data["negative_prompt"] = negative_prompt
+            data["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             data["seed"] = seed
 
         files = {"image": ("input.png", buf, "image/png")}
-        url = f"{self.API_BASE}/stable-image/generate/sd3"
+        url = 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)
-# ═══════════════════════════════════════════
+# ============================================
+# 3. REPLICATE
+# ============================================
 
 class ReplicateProvider(BaseProvider):
     name = "replicate"
@@ -225,16 +303,18 @@ class ReplicateProvider(BaseProvider):
         "bytedance/sdxl-lightning-4step:latest",
     ]
     requires_package = "replicate"
+    max_prompt_length = 10000
 
     def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
                        seed=None, model=None, **kwargs):
         replicate_mod = _require_import("replicate")
         client = replicate_mod.Client(api_token=self.api_key)
         model_id = model or self.default_model
+        safe_prompt = self._truncate(prompt)
 
-        input_params = {"prompt": prompt, "width": width, "height": height}
+        input_params = {"prompt": safe_prompt, "width": width, "height": height}
         if negative_prompt and "flux" not in model_id.lower():
-            input_params["negative_prompt"] = negative_prompt
+            input_params["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             input_params["seed"] = seed
 
@@ -252,14 +332,15 @@ class ReplicateProvider(BaseProvider):
         replicate_mod = _require_import("replicate")
         client = replicate_mod.Client(api_token=self.api_key)
         model_id = model or "stability-ai/sdxl:latest"
+        safe_prompt = self._truncate(prompt)
 
         buf = io.BytesIO()
         image.save(buf, format="PNG")
         buf.seek(0)
 
-        input_params = {"prompt": prompt, "image": buf, "prompt_strength": strength}
+        input_params = {"prompt": safe_prompt, "image": buf, "prompt_strength": strength}
         if negative_prompt:
-            input_params["negative_prompt"] = negative_prompt
+            input_params["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             input_params["seed"] = seed
 
@@ -268,9 +349,9 @@ class ReplicateProvider(BaseProvider):
         return self._url_to_image(url)
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # 4. TOGETHER AI
-# ═══════════════════════════════════════════
+# ============================================
 
 class TogetherProvider(BaseProvider):
     name = "together"
@@ -286,17 +367,19 @@ class TogetherProvider(BaseProvider):
         "stabilityai/stable-diffusion-xl-base-1.0",
     ]
     requires_package = "together"
+    max_prompt_length = 10000
 
     def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
                        seed=None, model=None, **kwargs):
         together_mod = _require_import("together")
         client = together_mod.Together(api_key=self.api_key)
         model_id = model or self.default_model
+        safe_prompt = self._truncate(prompt)
 
-        params = dict(model=model_id, prompt=prompt, width=width, height=height,
+        params = dict(model=model_id, prompt=safe_prompt, width=width, height=height,
                       steps=kwargs.get("steps", 28), n=1, response_format="b64_json")
         if negative_prompt:
-            params["negative_prompt"] = negative_prompt
+            params["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             params["seed"] = seed
 
@@ -304,9 +387,9 @@ class TogetherProvider(BaseProvider):
         return self._base64_to_image(response.data[0].b64_json)
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # 5. FAL.AI
-# ═══════════════════════════════════════════
+# ============================================
 
 class FalProvider(BaseProvider):
     name = "fal"
@@ -321,16 +404,18 @@ class FalProvider(BaseProvider):
         "fal-ai/stable-diffusion-v35-large", "fal-ai/recraft-v3",
     ]
     requires_package = "fal_client"
+    max_prompt_length = 10000
 
     def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
                        seed=None, model=None, **kwargs):
         fal_client = _require_import("fal_client", "fal-client")
         os.environ["FAL_KEY"] = self.api_key
         model_id = model or self.default_model
+        safe_prompt = self._truncate(prompt)
 
-        arguments = {"prompt": prompt, "image_size": {"width": width, "height": height}, "num_images": 1}
+        arguments = {"prompt": safe_prompt, "image_size": {"width": width, "height": height}, "num_images": 1}
         if negative_prompt:
-            arguments["negative_prompt"] = negative_prompt
+            arguments["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             arguments["seed"] = seed
 
@@ -344,13 +429,14 @@ class FalProvider(BaseProvider):
                 seed=None, model=None, **kwargs):
         fal_client = _require_import("fal_client", "fal-client")
         os.environ["FAL_KEY"] = self.api_key
+        safe_prompt = self._truncate(prompt)
 
         b64 = self._image_to_base64(image)
-        data_uri = f"data:image/png;base64,{b64}"
+        data_uri = "data:image/png;base64," + b64
 
-        arguments = {"prompt": prompt, "image_url": data_uri, "strength": strength, "num_images": 1}
+        arguments = {"prompt": safe_prompt, "image_url": data_uri, "strength": strength, "num_images": 1}
         if negative_prompt:
-            arguments["negative_prompt"] = negative_prompt
+            arguments["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             arguments["seed"] = seed
 
@@ -362,9 +448,9 @@ class FalProvider(BaseProvider):
         raise ValueError("No image from Fal.ai img2img")
 
 
-# ═══════════════════════════════════════════
-# 6. GOOGLE GEMINI (Imagen 3)
-# ═══════════════════════════════════════════
+# ============================================
+# 6. GOOGLE GEMINI
+# ============================================
 
 class GoogleGeminiProvider(BaseProvider):
     name = "google"
@@ -375,17 +461,19 @@ class GoogleGeminiProvider(BaseProvider):
     default_model = "imagen-3.0-generate-002"
     available_models = ["imagen-3.0-generate-002", "imagen-3.0-fast-generate-001"]
     requires_package = "google.generativeai"
+    max_prompt_length = 5000
 
     def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
                        seed=None, model=None, **kwargs):
         genai = _require_import("google.generativeai", "google-generativeai")
         genai.configure(api_key=self.api_key)
         model_id = model or self.default_model
+        safe_prompt = self._truncate(prompt)
 
         imagen = genai.ImageGenerationModel(model_id)
-        params = dict(prompt=prompt, number_of_images=1)
+        params = dict(prompt=safe_prompt, number_of_images=1)
         if negative_prompt:
-            params["negative_prompt"] = negative_prompt
+            params["negative_prompt"] = smart_truncate(negative_prompt, 2000)
 
         response = imagen.generate_images(**params)
         if response.images:
@@ -393,9 +481,9 @@ class GoogleGeminiProvider(BaseProvider):
         raise ValueError("No image returned from Imagen")
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # 7. HUGGING FACE INFERENCE API
-# ═══════════════════════════════════════════
+# ============================================
 
 class HuggingFaceProvider(BaseProvider):
     name = "huggingface"
@@ -410,19 +498,21 @@ class HuggingFaceProvider(BaseProvider):
         "stabilityai/stable-diffusion-3.5-large",
         "runwayml/stable-diffusion-v1-5",
     ]
-    requires_package = ""  # uses requests only
+    requires_package = ""
+    max_prompt_length = 10000
 
     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}"}
+        url = self.API_BASE + "/" + model_id
+        headers = {"Authorization": "Bearer " + self.api_key}
+        safe_prompt = self._truncate(prompt)
 
-        payload = {"inputs": prompt, "parameters": {"width": width, "height": height}}
+        payload = {"inputs": safe_prompt, "parameters": {"width": width, "height": height}}
         if negative_prompt:
-            payload["parameters"]["negative_prompt"] = negative_prompt
+            payload["parameters"]["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             payload["parameters"]["seed"] = seed
 
@@ -434,9 +524,9 @@ class HuggingFaceProvider(BaseProvider):
         return self._bytes_to_image(resp.content)
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # 8. xAI GROK
-# ═══════════════════════════════════════════
+# ============================================
 
 class XAIProvider(BaseProvider):
     name = "xai"
@@ -447,21 +537,23 @@ class XAIProvider(BaseProvider):
     default_model = "grok-2-image"
     available_models = ["grok-2-image"]
     requires_package = "openai"
+    max_prompt_length = 4000
 
     def generate_image(self, prompt, negative_prompt="", width=1024, height=1024,
                        seed=None, model=None, **kwargs):
         openai_mod = _require_import("openai")
         client = openai_mod.OpenAI(api_key=self.api_key, base_url="https://api.x.ai/v1")
+        safe_prompt = self._truncate(prompt)
         response = client.images.generate(
-            model=model or self.default_model, prompt=prompt,
+            model=model or self.default_model, prompt=safe_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"
@@ -476,18 +568,20 @@ class FireworksProvider(BaseProvider):
         "accounts/fireworks/models/flux-1-dev-fp8",
         "accounts/fireworks/models/stable-diffusion-xl-1024-v1-0",
     ]
-    requires_package = ""  # uses requests only
+    requires_package = ""
+    max_prompt_length = 10000
 
     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"}
+        headers = {"Authorization": "Bearer " + self.api_key, "Content-Type": "application/json"}
+        safe_prompt = self._truncate(prompt)
         payload = {
-            "model": model or self.default_model, "prompt": prompt,
-            "n": 1, "size": f"{width}x{height}", "response_format": "b64_json",
+            "model": model or self.default_model, "prompt": safe_prompt,
+            "n": 1, "size": str(width) + "x" + str(height), "response_format": "b64_json",
         }
         if negative_prompt:
-            payload["negative_prompt"] = negative_prompt
+            payload["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             payload["seed"] = seed
 
@@ -497,9 +591,9 @@ class FireworksProvider(BaseProvider):
         return self._base64_to_image(data["data"][0]["b64_json"])
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # 10. IDEOGRAM
-# ═══════════════════════════════════════════
+# ============================================
 
 class IdeogramProvider(BaseProvider):
     name = "ideogram"
@@ -509,20 +603,22 @@ class IdeogramProvider(BaseProvider):
     supports_negative_prompt = True
     default_model = "V_2"
     available_models = ["V_2", "V_2_TURBO", "V_1", "V_1_TURBO"]
-    requires_package = ""  # uses requests only
+    requires_package = ""
+    max_prompt_length = 10000
 
     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"}
+        safe_prompt = self._truncate(prompt)
         payload = {
             "image_request": {
-                "prompt": prompt, "model": model or self.default_model,
+                "prompt": safe_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
+            payload["image_request"]["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             payload["image_request"]["seed"] = seed
 
@@ -532,9 +628,9 @@ class IdeogramProvider(BaseProvider):
         return self._url_to_image(data["data"][0]["url"])
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # 11. LEONARDO AI
-# ═══════════════════════════════════════════
+# ============================================
 
 class LeonardoProvider(BaseProvider):
     name = "leonardo"
@@ -548,29 +644,31 @@ class LeonardoProvider(BaseProvider):
         "aa77f04e-3eec-4034-9c07-d0f619684628",
         "1e60896f-3c26-4296-8ecc-53e2afecc132",
     ]
-    requires_package = ""  # uses requests only
+    requires_package = ""
+    max_prompt_length = 10000
 
     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"}
+        headers = {"Authorization": "Bearer " + self.api_key, "Content-Type": "application/json"}
+        safe_prompt = self._truncate(prompt)
         payload = {
-            "prompt": prompt, "modelId": model or self.default_model,
+            "prompt": safe_prompt, "modelId": model or self.default_model,
             "width": width, "height": height, "num_images": 1,
         }
         if negative_prompt:
-            payload["negative_prompt"] = negative_prompt
+            payload["negative_prompt"] = smart_truncate(negative_prompt, 5000)
         if seed is not None:
             payload["seed"] = seed
 
-        resp = requests.post(f"{self.API_BASE}/generations", headers=headers, json=payload, timeout=60)
+        resp = requests.post(self.API_BASE + "/generations", headers=headers, json=payload, timeout=60)
         resp.raise_for_status()
         gen_id = resp.json()["sdGenerationJob"]["generationId"]
 
         for _ in range(30):
             time.sleep(5)
-            poll = requests.get(f"{self.API_BASE}/generations/{gen_id}", headers=headers, timeout=30)
+            poll = requests.get(self.API_BASE + "/generations/" + gen_id, headers=headers, timeout=30)
             poll.raise_for_status()
             gen = poll.json().get("generations_by_pk", {})
             if gen.get("status") == "COMPLETE":
@@ -581,9 +679,9 @@ class LeonardoProvider(BaseProvider):
         raise TimeoutError("Leonardo generation timed out")
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # 12. CUSTOM OPENAI-COMPATIBLE
-# ═══════════════════════════════════════════
+# ============================================
 
 class CustomOpenAIProvider(BaseProvider):
     name = "custom_openai"
@@ -594,6 +692,7 @@ class CustomOpenAIProvider(BaseProvider):
     default_model = "dall-e-3"
     available_models = ["dall-e-3", "dall-e-2", "custom"]
     requires_package = "openai"
+    max_prompt_length = 3900
 
     def __init__(self, api_key="", base_url=""):
         super().__init__(api_key)
@@ -606,16 +705,17 @@ class CustomOpenAIProvider(BaseProvider):
         if self.base_url:
             ck["base_url"] = self.base_url
         client = openai_mod.OpenAI(**ck)
+        safe_prompt = self._truncate(prompt)
         response = client.images.generate(
-            model=model or self.default_model, prompt=prompt,
-            n=1, size=f"{width}x{height}", response_format="b64_json",
+            model=model or self.default_model, prompt=safe_prompt,
+            n=1, size=str(width) + "x" + str(height), response_format="b64_json",
         )
         return self._base64_to_image(response.data[0].b64_json)
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # 13. DIRECT URL API
-# ═══════════════════════════════════════════
+# ============================================
 
 class DirectURLProvider(BaseProvider):
     name = "direct_url"
@@ -626,6 +726,7 @@ class DirectURLProvider(BaseProvider):
     default_model = "custom"
     available_models = ["custom"]
     requires_package = ""
+    max_prompt_length = 50000
 
     def __init__(self, api_key="", endpoint_url=""):
         super().__init__(api_key)
@@ -636,10 +737,11 @@ class DirectURLProvider(BaseProvider):
         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}
+        headers = {"Authorization": "Bearer " + self.api_key, "Content-Type": "application/json"}
+        safe_prompt = self._truncate(prompt)
+        payload = {"prompt": safe_prompt, "width": width, "height": height}
         if negative_prompt:
-            payload["negative_prompt"] = negative_prompt
+            payload["negative_prompt"] = smart_truncate(negative_prompt, 10000)
         if seed is not None:
             payload["seed"] = seed
         if model and model != "custom":
@@ -662,7 +764,7 @@ class DirectURLProvider(BaseProvider):
                     for subkey in ["b64_json", "url", "image"]:
                         if subkey in item:
                             val = item[subkey]
-                            if val.startswith("http"):
+                            if isinstance(val, str) and val.startswith("http"):
                                 return self._url_to_image(val)
                             return self._base64_to_image(val)
                 if isinstance(item, str):
@@ -673,9 +775,9 @@ class DirectURLProvider(BaseProvider):
         raise ValueError("Could not parse image from API response")
 
 
-# ═══════════════════════════════════════════
+# ============================================
 # PROVIDER REGISTRY
-# ═══════════════════════════════════════════
+# ============================================
 
 PROVIDERS = {
     "openai": OpenAIProvider,
@@ -699,7 +801,7 @@ PROVIDER_DISPLAY_NAMES = {cls.display_name: key for key, cls in PROVIDERS.items(
 def get_provider(provider_name, api_key, **kwargs):
     cls = PROVIDERS.get(provider_name)
     if cls is None:
-        raise ValueError(f"Unknown provider: {provider_name}")
+        raise ValueError("Unknown provider: " + str(provider_name))
     if provider_name == "custom_openai":
         return cls(api_key=api_key, base_url=kwargs.get("base_url", ""))
     if provider_name == "direct_url":
@@ -719,6 +821,7 @@ def get_provider_info():
             "website": cls.website, "supports_img2img": cls.supports_img2img,
             "default_model": cls.default_model, "available_models": cls.available_models,
             "requires_package": pkg, "package_installed": installed,
+            "max_prompt_length": cls.max_prompt_length,
         })
     return info