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

lollms_client/tti_bindings/novita_ai/__init__.py

@@ -0,0 +1,105 @@
+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):
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        super().__init__(binding_name=BindingName, config=kwargs)
+        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 list_models(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/openai/__init__.py

@@ -6,7 +6,7 @@ from io import BytesIO
 from ascii_colors import trace_exception
 from openai import OpenAI
 from lollms_client.lollms_tti_binding import LollmsTTIBinding
-
+import os
 BindingName = "OpenAITTIBinding"
 
 
@@ -50,19 +50,18 @@ class OpenAITTIBinding(LollmsTTIBinding):
 
     def __init__(
         self,
-        model: str = "gpt-image-1",
-        api_key: Optional[str] = None,
-        size: str = "1024x1024",
-        n: int = 1,
-        quality: str = "standard",
         **kwargs,
     ):
-        self.client = OpenAI(api_key=api_key)
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        super().__init__(binding_name=BindingName, config=kwargs)
+        self.client = OpenAI(api_key=kwargs.get("api_key" or os.environ.get("OPENAI_API_KEY")))
         self.global_params = {
-            "model": model,
-            "size": size,
-            "n": n,
-            "quality": quality,
+            "model": kwargs.get("model_name") or "gpt-image-1",
+            "size": kwargs.get("size", "1024x1024"),
+            "n": kwargs.get("n", 1),
+            "quality": kwargs.get("quality", "standard"),
         }
 
     def _resolve_param(self, name: str, kwargs: Dict[str, Any], default: Any) -> Any:

lollms_client/tti_bindings/stability_ai/__init__.py

@@ -0,0 +1,178 @@
+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):
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        super().__init__(binding_name=BindingName, 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 list_models(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/audiocraft/__init__.py

@@ -75,21 +75,16 @@ DEFAULT_AUDIOCRAFT_MODELS = [
 
 class AudioCraftTTMBinding(LollmsTTMBinding):
     def __init__(self,
-                 model_name: str = "facebook/musicgen-small", # HF ID or local path
-                 device: Optional[str] = None, # "cpu", "cuda", "mps", or None for auto
-                 output_format: str = "wav", # 'wav', 'mp3' (mp3 needs ffmpeg via audiocraft)
-                 # Catch LollmsTTMBinding standard args
-                 host_address: Optional[str] = None, # Not used by local binding
-                 service_key: Optional[str] = None,  # Not used by local binding
-                 verify_ssl_certificate: bool = True,# Not used by local binding
-                 **kwargs): # Catch-all for future compatibility or specific audiocraft params
-
-        super().__init__(binding_name="audiocraft")
+                 **kwargs):
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        super().__init__(binding_name=BindingName, config=kwargs)    
 
         if not _audiocraft_installed_with_correct_torch:
             raise ImportError(f"AudioCraft TTM binding dependencies not met. Please ensure 'audiocraft', 'torch', 'torchaudio', 'scipy', 'numpy' are installed. Error: {_audiocraft_installation_error}")
 
-        self.device = device
+        self.device = kwargs.get("device")  # "cuda", "mps", "cpu", or None for auto-detect
         if self.device is None: # Auto-detect if not specified by user
             if torch.cuda.is_available():
                 self.device = "cuda"
@@ -117,7 +112,7 @@ class AudioCraftTTMBinding(LollmsTTMBinding):
             ASCIIColors.warning(f"Unsupported output_format '{self.output_format}'. Defaulting to 'wav'.")
             self.output_format = "wav"
         
-        self._load_audiocraft_model(model_name)
+        self._load_audiocraft_model(kwargs.get("model_name") or "facebook/musicgen-small")
 
     def _load_audiocraft_model(self, model_name_to_load: str):
         if self.model is not None and self.loaded_model_name == model_name_to_load:

lollms_client/ttm_bindings/beatoven_ai/__init__.py

@@ -0,0 +1,129 @@
+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):
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        super().__init__(binding_name=BindingName, config=kwargs)    
+        self.api_key = self.config.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/lollms/__init__.py

@@ -11,23 +11,10 @@ class LollmsTTMBinding_Impl(LollmsTTMBinding):
     """Concrete implementation of the LollmsTTMBinding for the standard LOLLMS server (Placeholder)."""
 
     def __init__(self,
-                 host_address: Optional[str] = "http://localhost:9600", # Default LOLLMS host
-                 model_name: Optional[str] = None, # Default model (server decides if None)
-                 service_key: Optional[str] = None,
-                 verify_ssl_certificate: bool = True):
-        """
-        Initialize the LOLLMS TTM binding.
-
-        Args:
-            host_address (Optional[str]): Host address for the LOLLMS service.
-            model_name (Optional[str]): Default TTM model identifier.
-            service_key (Optional[str]): Authentication key.
-            verify_ssl_certificate (bool): Whether to verify SSL certificates.
-        """
-        super().__init__(host_address=host_address,
-                         model_name=model_name,
-                         service_key=service_key,
-                         verify_ssl_certificate=verify_ssl_certificate)
+                 **kwargs):
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
         ASCIIColors.warning("LOLLMS TTM binding is not yet fully implemented in the client.")
         ASCIIColors.warning("Please ensure your LOLLMS server has a TTM service running.")
 

lollms_client/ttm_bindings/replicate/__init__.py

@@ -0,0 +1,115 @@
+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):
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+        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-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}")