lollms-client 1.4.1__py3-none-any.whl → 1.4.6__py3-none-any.whl

lollms_client/tti_bindings/leonardo_ai/__init__.py

@@ -0,0 +1,124 @@
+import os
+import requests
+import time
+import base64
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+pm.ensure_packages(["requests", "Pillow"])
+from PIL import Image
+
+BindingName = "LeonardoAITTIBinding"
+
+# Sourced from https://docs.leonardo.ai/docs/models
+LEONARDO_AI_MODELS = [
+    {"model_name": "ac4f3991-8a40-42cd-b174-14a8e33738e4", "display_name": "Leonardo Phoenix", "description": "Fast, high-quality photorealism."},
+    {"model_name": "1e65d070-22c9-4aed-a5be-ce58a1b65b38", "display_name": "Leonardo Diffusion XL", "description": "The flagship general-purpose SDXL model."},
+    {"model_name": "b24e16ff-06e3-43eb-a255-db4322b0f345", "display_name": "AlbedoBase XL", "description": "Versatile model for photorealism and artistic styles."},
+    {"model_name": "6bef9f1b-29cb-40c7-b9df-32b51c1f67d3", "display_name": "Absolute Reality v1.6", "description": "Classic photorealistic model."},
+    {"model_name": "f3296a34-a868-4665-8b2f-f4313f8c8533", "display_name": "RPG v5", "description": "Specialized in RPG characters and assets."},
+    {"model_name": "2067ae58-a02e-4318-9742-2b55b2a4c813", "display_name": "DreamShaper v7", "description": "Popular versatile artistic model."},
+]
+
+class LeonardoAITTIBinding(LollmsTTIBinding):
+    """Leonardo.ai TTI binding for LoLLMS"""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName)
+        self.config = kwargs
+        self.api_key = self.config.get("api_key") or os.environ.get("LEONARDO_API_KEY")
+        if not self.api_key:
+            raise ValueError("Leonardo.ai API key is required.")
+        self.model_name = self.config.get("model_name", "ac4f3991-8a40-42cd-b174-14a8e33738e4")
+        self.base_url = "https://cloud.leonardo.ai/api/rest/v1"
+        self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+    def listModels(self) -> list:
+        # You could also fetch this dynamically from /models endpoint
+        return LEONARDO_AI_MODELS
+    
+    def _wait_for_generation(self, generation_id: str) -> List[bytes]:
+        while True:
+            url = f"{self.base_url}/generations/{generation_id}"
+            response = requests.get(url, headers=self.headers)
+            response.raise_for_status()
+            data = response.json().get("generations_by_pk", {})
+            status = data.get("status")
+
+            if status == "COMPLETE":
+                ASCIIColors.green("Generation complete.")
+                images_data = []
+                for img in data.get("generated_images", []):
+                    img_url = img.get("url")
+                    if img_url:
+                        img_response = requests.get(img_url)
+                        img_response.raise_for_status()
+                        images_data.append(img_response.content)
+                return images_data
+            elif status == "FAILED":
+                raise Exception("Leonardo.ai generation failed.")
+            else:
+                ASCIIColors.info(f"Generation status: {status}. Waiting...")
+                time.sleep(3)
+
+    def generate_image(self, prompt: str, negative_prompt: str = "", width: int = 1024, height: int = 1024, **kwargs) -> bytes:
+        url = f"{self.base_url}/generations"
+        payload = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "modelId": self.model_name,
+            "width": width,
+            "height": height,
+            "num_images": 1,
+            "guidance_scale": kwargs.get("guidance_scale", 7),
+            "seed": kwargs.get("seed"),
+            "sd_version": "SDXL" # Most models are SDXL based
+        }
+        
+        try:
+            ASCIIColors.info(f"Submitting generation job to Leonardo.ai ({self.model_name})...")
+            response = requests.post(url, json=payload, headers=self.headers)
+            response.raise_for_status()
+            generation_id = response.json()["sdGenerationJob"]["generationId"]
+            ASCIIColors.info(f"Job submitted with ID: {generation_id}")
+            images = self._wait_for_generation(generation_id)
+            return images[0]
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Leonardo.ai API error: {error_msg}")
+            except:
+                raise Exception(f"Leonardo.ai API request failed: {e}")
+
+    def edit_image(self, **kwargs) -> bytes:
+        ASCIIColors.warning("Leonardo.ai edit_image (inpainting/img2img) is not yet implemented in this binding.")
+        raise NotImplementedError("This binding does not yet support image editing.")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Leonardo.ai TTI Binding Test ---")
+    if "LEONARDO_API_KEY" not in os.environ:
+        ASCIIColors.error("LEONARDO_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = LeonardoAITTIBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Text-to-Image ---")
+        prompt = "A majestic lion wearing a crown, hyperrealistic, 8k"
+        img_bytes = binding.generate_image(prompt, width=1024, height=1024)
+        
+        assert len(img_bytes) > 1000
+        output_path = Path(__file__).parent / "tmp_leonardo_t2i.png"
+        with open(output_path, "wb") as f:
+            f.write(img_bytes)
+        ASCIIColors.green(f"Text-to-Image generation OK. Image saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Leonardo.ai binding test failed: {e}")

lollms_client/tti_bindings/novita_ai/__init__.py

@@ -0,0 +1,102 @@
+import os
+import requests
+import base64
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+pm.ensure_packages(["requests"])
+
+BindingName = "NovitaAITTIBinding"
+
+# Sourced from https://docs.novita.ai/image-generation/models
+NOVITA_AI_MODELS = [
+    {"model_name": "sd_xl_base_1.0.safetensors", "display_name": "Stable Diffusion XL 1.0", "description": "Official SDXL 1.0 Base model."},
+    {"model_name": "dreamshaper_xl_1_0.safetensors", "display_name": "DreamShaper XL 1.0", "description": "Versatile artistic SDXL model."},
+    {"model_name": "juggernaut_xl_v9_rundiffusion.safetensors", "display_name": "Juggernaut XL v9", "description": "High-quality realistic and cinematic model."},
+    {"model_name": "realistic_vision_v5.1.safetensors", "display_name": "Realistic Vision v5.1", "description": "Popular photorealistic SD1.5 model."},
+    {"model_name": "absolutereality_v1.8.1.safetensors", "display_name": "Absolute Reality v1.8.1", "description": "General-purpose realistic SD1.5 model."},
+    {"model_name": "meinamix_meina_v11.safetensors", "display_name": "MeinaMix v11", "description": "High-quality anime illustration model."},
+]
+
+class NovitaAITTIBinding(LollmsTTIBinding):
+    """Novita.ai TTI binding for LoLLMS"""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName)
+        self.config = kwargs
+        self.api_key = self.config.get("api_key") or os.environ.get("NOVITA_API_KEY")
+        if not self.api_key:
+            raise ValueError("Novita.ai API key is required.")
+        self.model_name = self.config.get("model_name", "juggernaut_xl_v9_rundiffusion.safetensors")
+        self.base_url = "https://api.novita.ai/v3"
+        self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+    def listModels(self) -> list:
+        return NOVITA_AI_MODELS
+    
+    def generate_image(self, prompt: str, negative_prompt: str = "", width: int = 1024, height: int = 1024, **kwargs) -> bytes:
+        url = f"{self.base_url}/text2img"
+        payload = {
+            "model_name": self.model_name,
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "width": width,
+            "height": height,
+            "sampler_name": "DPM++ 2M Karras",
+            "cfg_scale": kwargs.get("guidance_scale", 7.0),
+            "steps": kwargs.get("num_inference_steps", 25),
+            "seed": kwargs.get("seed", -1),
+            "n_iter": 1,
+            "batch_size": 1
+        }
+        
+        try:
+            ASCIIColors.info(f"Requesting image from Novita.ai ({self.model_name})...")
+            response = requests.post(url, json=payload, headers=self.headers)
+            response.raise_for_status()
+            data = response.json()
+            if "images" not in data or not data["images"]:
+                raise Exception(f"API returned no images. Response: {data}")
+            
+            b64_image = data["images"][0]["image_base64"]
+            return base64.b64decode(b64_image)
+            
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Novita.ai API error: {error_msg}")
+            except:
+                raise Exception(f"Novita.ai API request failed: {e}")
+
+    def edit_image(self, **kwargs) -> bytes:
+        ASCIIColors.warning("Novita.ai edit_image (inpainting/img2img) is not yet implemented in this binding.")
+        raise NotImplementedError("This binding does not yet support image editing.")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Novita.ai TTI Binding Test ---")
+    if "NOVITA_API_KEY" not in os.environ:
+        ASCIIColors.error("NOVITA_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = NovitaAITTIBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Text-to-Image ---")
+        prompt = "A cute capybara wearing a top hat, sitting in a field of flowers, painterly style"
+        img_bytes = binding.generate_image(prompt, width=1024, height=1024, num_inference_steps=30)
+        
+        assert len(img_bytes) > 1000
+        output_path = Path(__file__).parent / "tmp_novita_t2i.png"
+        with open(output_path, "wb") as f:
+            f.write(img_bytes)
+        ASCIIColors.green(f"Text-to-Image generation OK. Image saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Novita.ai binding test failed: {e}")

lollms_client/tti_bindings/stability_ai/__init__.py

@@ -0,0 +1,176 @@
+import os
+import requests
+import base64
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+pm.ensure_packages(["requests", "Pillow"])
+
+from PIL import Image
+
+BindingName = "StabilityAITTIBinding"
+
+# Sourced from https://platform.stability.ai/docs/getting-started/models
+STABILITY_AI_MODELS = [
+    # SD3
+    {"model_name": "stable-diffusion-3-medium", "display_name": "Stable Diffusion 3 Medium", "description": "Most advanced text-to-image model.", "owned_by": "Stability AI"},
+    {"model_name": "stable-diffusion-3-large", "display_name": "Stable Diffusion 3 Large", "description": "Most advanced model with higher quality.", "owned_by": "Stability AI"},
+    {"model_name": "stable-diffusion-3-large-turbo", "display_name": "Stable Diffusion 3 Large Turbo", "description": "Fast, high-quality generation.", "owned_by": "Stability AI"},
+    # SDXL
+    {"model_name": "stable-diffusion-xl-1024-v1-0", "display_name": "Stable Diffusion XL 1.0", "description": "High-quality 1024x1024 generation.", "owned_by": "Stability AI"},
+    {"model_name": "stable-diffusion-xl-beta-v2-2-2", "display_name": "SDXL Beta", "description": "Legacy anime-focused SDXL model.", "owned_by": "Stability AI"},
+    # SD 1.x & 2.x
+    {"model_name": "stable-diffusion-v1-6", "display_name": "Stable Diffusion 1.6", "description": "Improved version of SD 1.5.", "owned_by": "Stability AI"},
+    {"model_name": "stable-diffusion-2-1", "display_name": "Stable Diffusion 2.1", "description": "768x768 native resolution model.", "owned_by": "Stability AI"},
+]
+
+class StabilityAITTIBinding(LollmsTTIBinding):
+    """Stability AI TTI binding for LoLLMS"""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName)
+        self.config = kwargs
+        self.api_key = self.config.get("api_key") or os.environ.get("STABILITY_API_KEY")
+        if not self.api_key:
+            raise ValueError("Stability AI API key is required. Please set it in the configuration or as STABILITY_API_KEY environment variable.")
+        self.model_name = self.config.get("model_name", "stable-diffusion-3-medium")
+
+    def listModels(self) -> list:
+        return STABILITY_AI_MODELS
+
+    def _get_api_url(self, task: str) -> str:
+        base_url = "https://api.stability.ai/v2beta/stable-image"
+        # SD3 models use a different endpoint structure
+        if "stable-diffusion-3" in self.model_name:
+            return f"{base_url}/generate/sd3"
+        
+        task_map = {
+            "text2image": "generate/core",
+            "image2image": "edit/image-to-image",
+            "inpainting": "edit/in-painting",
+            "upscale": "edit/upscale"
+        }
+        if task not in task_map:
+            raise ValueError(f"Unsupported task for this model family: {task}")
+        return f"{base_url}/{task_map[task]}"
+
+    def _decode_image_input(self, item: Union[str, Path, bytes]) -> Image.Image:
+        if isinstance(item, bytes):
+            return Image.open(BytesIO(item))
+        s = str(item).strip()
+        if s.startswith("data:image/") and ";base64," in s:
+            b64 = s.split(";base64,")[-1]
+            return Image.open(BytesIO(base64.b64decode(b64)))
+        try:
+            p = Path(s)
+            if p.exists():
+                return Image.open(p)
+        except:
+            pass
+        if s.startswith("http"):
+            response = requests.get(s, stream=True)
+            response.raise_for_status()
+            return Image.open(response.raw)
+        # Fallback for raw base64
+        return Image.open(BytesIO(base64.b64decode(s)))
+
+    def generate_image(self, prompt: str, negative_prompt: str = "", width: int = 1024, height: int = 1024, **kwargs) -> bytes:
+        url = self._get_api_url("text2image")
+        
+        data = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "output_format": "png",
+            "seed": kwargs.get("seed", 0)
+        }
+
+        # SD3 uses aspect_ratio, older models use width/height
+        if "stable-diffusion-3" in self.model_name:
+            data["aspect_ratio"] = f"{width}:{height}"
+            data["model"] = self.model_name
+        else:
+            data["width"] = width
+            data["height"] = height
+            data["style_preset"] = kwargs.get("style_preset", "photographic")
+
+        headers = {"authorization": f"Bearer {self.api_key}", "accept": "image/*"}
+        
+        try:
+            ASCIIColors.info(f"Requesting image from Stability AI ({self.model_name})...")
+            response = requests.post(url, headers=headers, files={"none": ''}, data=data)
+            response.raise_for_status()
+            return response.content
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Stability AI API error: {error_msg}")
+            except:
+                raise Exception(f"Stability AI API request failed: {e}")
+
+    def edit_image(self, images: Union[str, List[str]], prompt: str, negative_prompt: Optional[str] = "", mask: Optional[str] = None, **kwargs) -> bytes:
+        init_image_bytes = BytesIO()
+        init_image = self._decode_image_input(images[0] if isinstance(images, list) else images)
+        init_image.save(init_image_bytes, format="PNG")
+        
+        task = "inpainting" if mask else "image2image"
+        url = self._get_api_url(task)
+
+        files = {"image": init_image_bytes.getvalue()}
+        data = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt or "",
+            "output_format": "png",
+            "seed": kwargs.get("seed", 0)
+        }
+
+        if task == "inpainting":
+            mask_image_bytes = BytesIO()
+            mask_image = self._decode_image_input(mask)
+            mask_image.save(mask_image_bytes, format="PNG")
+            files["mask"] = mask_image_bytes.getvalue()
+        else: # image2image
+            data["strength"] = kwargs.get("strength", 0.6) # mode IMAGE_STRENGTH
+        
+        headers = {"authorization": f"Bearer {self.api_key}", "accept": "image/*"}
+
+        try:
+            ASCIIColors.info(f"Requesting image edit from Stability AI ({self.model_name})...")
+            response = requests.post(url, headers=headers, files=files, data=data)
+            response.raise_for_status()
+            return response.content
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Stability AI API error: {error_msg}")
+            except:
+                raise Exception(f"Stability AI API request failed: {e}")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Stability AI TTI Binding Test ---")
+    if "STABILITY_API_KEY" not in os.environ:
+        ASCIIColors.error("STABILITY_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = StabilityAITTIBinding(model_name="stable-diffusion-3-medium")
+        
+        ASCIIColors.cyan("\n--- Test: Text-to-Image ---")
+        prompt = "a cinematic photo of a robot drinking coffee in a Parisian cafe"
+        img_bytes = binding.generate_image(prompt, width=1024, height=1024)
+        
+        assert len(img_bytes) > 1000, "Generated image bytes are too small."
+        output_path = Path(__file__).parent / "tmp_stability_t2i.png"
+        with open(output_path, "wb") as f:
+            f.write(img_bytes)
+        ASCIIColors.green(f"Text-to-Image generation OK. Image saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Stability AI binding test failed: {e}")

lollms_client/ttm_bindings/beatoven_ai/__init__.py

@@ -0,0 +1,125 @@
+import os
+import requests
+import time
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from lollms_client.lollms_ttm_binding import LollmsTTMBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+# Ensure required packages are installed
+pm.ensure_packages(["requests"])
+
+BindingName = "BeatovenAITTMBinding"
+
+class BeatovenAITTMBinding(LollmsTTMBinding):
+    """A Text-to-Music binding for the Beatoven.ai API."""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName, **kwargs)
+        self.api_key = self.settings.get("api_key") or os.environ.get("BEATOVEN_API_KEY")
+        if not self.api_key:
+            raise ValueError("Beatoven.ai API key is required. Please set it in config or as BEATOVEN_API_KEY env var.")
+        self.base_url = "https://api.beatoven.ai/api/v1"
+        self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+    def list_models(self, **kwargs) -> List[str]:
+        # Beatoven.ai does not expose different models via the API.
+        # Customization is done via genre, mood, and tempo.
+        return ["default"]
+
+    def _poll_for_completion(self, task_id: str) -> Dict[str, Any]:
+        """Polls the tasks endpoint until the composition is complete."""
+        poll_url = f"{self.base_url}/tasks/{task_id}"
+        while True:
+            try:
+                response = requests.get(poll_url, headers=self.headers)
+                response.raise_for_status()
+                data = response.json()
+                status = data.get("status")
+
+                if status == "success":
+                    ASCIIColors.green("Composition task successful.")
+                    return data
+                elif status == "failed":
+                    error_info = data.get("error", "Unknown error.")
+                    raise Exception(f"Beatoven.ai task failed: {error_info}")
+                else:
+                    ASCIIColors.info(f"Task status is '{status}'. Waiting...")
+                    time.sleep(5)
+            except requests.exceptions.HTTPError as e:
+                raise Exception(f"Failed to poll task status: {e.response.text}")
+
+    def generate_music(self, prompt: str, **kwargs) -> bytes:
+        """
+        Generates music by creating a track, waiting for composition, and downloading the result.
+        """
+        # Step 1: Create a track
+        create_track_url = f"{self.base_url}/tracks"
+        payload = {
+            "title": prompt[:100], # Use prompt as title, truncated
+            "duration_in_seconds": kwargs.get("duration", 30),
+            "genre": kwargs.get("genre", "Cinematic"),
+            "tempo": kwargs.get("tempo", "medium"),
+            "prompt": prompt
+        }
+
+        try:
+            ASCIIColors.info("Submitting music track request to Beatoven.ai...")
+            create_response = requests.post(create_track_url, json=payload, headers=self.headers)
+            create_response.raise_for_status()
+            task_id = create_response.json().get("task_id")
+            ASCIIColors.info(f"Track creation submitted. Task ID: {task_id}")
+            
+            # Step 2: Poll for task completion
+            task_result = self._poll_for_completion(task_id)
+            track_id = task_result.get("track_id")
+            if not track_id:
+                raise Exception("Task completed but did not return a track_id.")
+
+            # Step 3: Get track details to find the audio URL
+            track_url = f"{self.base_url}/tracks/{track_id}"
+            track_response = requests.get(track_url, headers=self.headers)
+            track_response.raise_for_status()
+            
+            audio_url = track_response.json().get("renders", {}).get("wav")
+            if not audio_url:
+                raise Exception("Could not find WAV render URL in the completed track details.")
+
+            # Step 4: Download the audio file
+            ASCIIColors.info(f"Downloading generated audio from {audio_url}")
+            audio_response = requests.get(audio_url)
+            audio_response.raise_for_status()
+            
+            return audio_response.content
+
+        except requests.exceptions.HTTPError as e:
+            error_details = e.response.json()
+            raise Exception(f"Beatoven.ai API HTTP Error: {error_details}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Beatoven.ai TTM Binding Test ---")
+    if "BEATOVEN_API_KEY" not in os.environ:
+        ASCIIColors.error("BEATOVEN_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = BeatovenAITTMBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Music Generation ---")
+        prompt = "A mysterious and suspenseful cinematic track with soft piano and eerie strings, building tension."
+        music_bytes = binding.generate_music(prompt, duration=45, genre="Cinematic", tempo="slow")
+        
+        assert len(music_bytes) > 1000, "Generated music bytes are too small."
+        output_path = Path(__file__).parent / "tmp_beatoven_music.wav"
+        with open(output_path, "wb") as f:
+            f.write(music_bytes)
+        ASCIIColors.green(f"Music generation OK. Audio saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Beatoven.ai TTM binding test failed: {e}")

lollms_client/ttm_bindings/replicate/__init__.py

@@ -0,0 +1,112 @@
+import os
+import requests
+import base64
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from lollms_client.lollms_ttm_binding import LollmsTTMBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+# Ensure required packages are installed
+pm.ensure_packages(["requests"])
+
+BindingName = "StabilityAITTMBinding"
+
+# Models available via the Stability AI Audio API
+# Sourced from: https://platform.stability.ai/docs/api-reference#tag/Generate/paths/~1v1~1generation~1stable-audio-2.0~1text-to-audio/post
+STABILITY_AI_MODELS = [
+    {"model_name": "stable-audio-2.0", "display_name": "Stable Audio 2.0", "description": "High-quality, full-track music generation up to 3 minutes."},
+    {"model_name": "stable-audio-1.0", "display_name": "Stable Audio 1.0", "description": "Original model, best for short clips and sound effects."},
+]
+
+class StabilityAITTMBinding(LollmsTTMBinding):
+    """A Text-to-Music binding for Stability AI's Stable Audio API."""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName, **kwargs)
+        self.api_key = self.settings.get("api_key") or os.environ.get("STABILITY_API_KEY")
+        if not self.api_key:
+            raise ValueError("Stability AI API key is required. Please set it in the configuration or as STABILITY_API_KEY environment variable.")
+        self.model_name = self.settings.get("model_name", "stable-audio-2.0")
+
+    def list_models(self, **kwargs) -> List[Dict[str, str]]:
+        return STABILITY_AI_MODELS
+
+    def generate_music(self, prompt: str, **kwargs) -> bytes:
+        """
+        Generates music using the Stable Audio API.
+
+        Args:
+            prompt (str): The text prompt describing the desired music.
+            duration (int): The duration of the audio in seconds. Defaults to 29.
+            **kwargs: Additional parameters for the API.
+        
+        Returns:
+            bytes: The generated audio data in WAV format.
+        """
+        url = f"https://api.stability.ai/v1/generation/{self.model_name}/text-to-audio"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "audio/wav",
+        }
+        
+        # Get duration, with a default of 29 seconds as it's a common value
+        duration = kwargs.get("duration", 29)
+        
+        payload = {
+            "text_prompts[0][text]": prompt,
+            "text_prompts[0][weight]": 1.0,
+            "seed": kwargs.get("seed", 0), # 0 for random in API
+            "steps": kwargs.get("steps", 100),
+            "cfg_scale": kwargs.get("cfg_scale", 7.0),
+        }
+
+        # Handle different parameter names for duration
+        if self.model_name == "stable-audio-2.0":
+            payload["duration"] = duration
+        else: # stable-audio-1.0
+            payload["sample_length"] = duration * 44100 # v1 uses sample length
+
+        try:
+            ASCIIColors.info(f"Requesting music from Stability AI ({self.model_name})...")
+            response = requests.post(url, headers=headers, data=payload)
+            response.raise_for_status()
+            
+            ASCIIColors.green("Successfully generated music from Stability AI.")
+            return response.content
+        except requests.exceptions.HTTPError as e:
+            try:
+                error_details = e.response.json()
+                error_message = error_details.get("message", e.response.text)
+            except:
+                error_message = e.response.text
+            ASCIIColors.error(f"HTTP Error from Stability AI: {e.response.status_code} - {error_message}")
+            raise Exception(f"Stability AI API Error: {error_message}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise Exception(f"An unexpected error occurred: {e}")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Stability AI TTM Binding Test ---")
+    if "STABILITY_API_KEY" not in os.environ:
+        ASCIIColors.error("STABILITY_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        # Test with default settings
+        binding = StabilityAITTMBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Music Generation ---")
+        prompt = "80s synthwave, retro futuristic, driving beat, cinematic"
+        music_bytes = binding.generate_music(prompt, duration=10)
+        
+        assert len(music_bytes) > 1000, "Generated music bytes are too small."
+        output_path = Path(__file__).parent / "tmp_stability_music.wav"
+        with open(output_path, "wb") as f:
+            f.write(music_bytes)
+        ASCIIColors.green(f"Music generation OK. Audio saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Stability AI TTM binding test failed: {e}")