lollms-client 1.4.5__tar.gz → 1.4.7__tar.gz

{lollms_client-1.4.5/src/lollms_client.egg-info → lollms_client-1.4.7}/PKG-INFO

@@ -1,9 +1,210 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.4.5
+Version: 1.4.7
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
-License: Apache Software License
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [yyyy] [name of copyright owner]
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+        
 Project-URL: Homepage, https://github.com/ParisNeo/lollms_client
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
@@ -18,6 +219,7 @@ Classifier: Intended Audience :: Science/Research
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: httpx
 Requires-Dist: requests
 Requires-Dist: ascii-colors
 Requires-Dist: pipmaster

{lollms_client-1.4.5 → lollms_client-1.4.7}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=77.0", "wheel"]
+requires = ["setuptools>=80.9", "wheel"]
 build-backend = "setuptools.build_meta"
 # REMOVE THE LINE BELOW:
 # backend-path = ["."]
@@ -13,7 +13,7 @@ authors = [
 description = "A client library for LoLLMs generate endpoint"
 readme = "README.md"
 requires-python = ">=3.7"
-license = {text = "Apache Software License"}
+license = { file = "LICENSE" }
 classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.8",
@@ -27,6 +27,7 @@ classifiers = [
     "Intended Audience :: Science/Research",
 ]
 dependencies = [
+    "httpx",
     "requests",
     "ascii-colors",
     "pipmaster",

{lollms_client-1.4.5 → lollms_client-1.4.7}/src/lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-__version__ = "1.4.5" # Updated version
+__version__ = "1.4.7" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

{lollms_client-1.4.5 → lollms_client-1.4.7}/src/lollms_client/lollms_discussion.py

@@ -1,3 +1,6 @@
+#lollms_client/lollms_discussion.py
+#author : ParisNeo
+
 import base64
 import json
 import re
@@ -1000,6 +1003,13 @@ class LollmsDiscussion:
         self._rebuild_message_index() # Ensure index is fresh
         return [LollmsMessage(self, msg_obj) for msg_obj in self._message_index.values()]
 
+    def setMemory(self, memory:str):
+        """sets memory content
+
+        Args:
+            memory (str): _description_
+        """
+        self.memory = memory
 
     def get_full_data_zone(self):
         """Assembles all data zones into a single, formatted string for the prompt."""
@@ -2585,4 +2595,4 @@ class LollmsDiscussion:
         if db_manager:
             new_discussion.commit()
 
-        return new_discussion
+        return new_discussion

{lollms_client-1.4.5 → lollms_client-1.4.7}/src/lollms_client/lollms_personality.py

@@ -84,7 +84,10 @@ class LollmsPersonality:
         """
         Creates a filesystem-safe, unique ID based on the author and name.
         """
-        safe_author = "".join(c if c.isalnum() else '_' for c in self.author)
+        if self.author:
+            safe_author = "".join(c if c.isalnum() else '_' for c in self.author)
+        else:
+            safe_author = "".join(c if c.isalnum() else '_' for c in "ParisNeo")
         safe_name = "".join(c if c.isalnum() else '_' for c in self.name)
         return f"{safe_author}_{safe_name}"
 
@@ -187,4 +190,4 @@ class LollmsPersonality:
             "has_data_source": self.data_source is not None,
             "data_files": [str(p) for p in self.data_files],
             "has_script": self.script is not None
-        }
+        }

lollms_client-1.4.7/src/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-1.4.7/src/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}")

lollms_client-1.4.7/src/lollms_client/ttm_bindings/stability_ai/__init__.py

@@ -0,0 +1,114 @@
+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 = "ReplicateTTMBinding"
+
+# Popular music models available on Replicate
+# Sourced from: https://replicate.com/collections/text-to-music
+REPLICATE_MODELS = [
+    {"model_name": "meta/musicgen:b05b1dff1d8c6ac63d42422dd565e23b63869bf2d51acda751e04b5dd304535d", "display_name": "Meta - MusicGen", "description": "State-of-the-art controllable text-to-music model from Meta."},
+    {"model_name": "suno-ai/bark:b76242b40d67c76ab6742e987628a2a9ac019e11d56ab96c4e91ce03b79b2787", "display_name": "Suno - Bark", "description": "Text-to-audio model capable of music, voice, and sound effects."},
+    {"model_name": "joehoover/musicgen-melody:7a76a8258b23fae65c5a24debbe88414f9bed22c2422a63465731103f6990803", "display_name": "MusicGen Melody", "description": "MusicGen fine-tuned for generating melodies."},
+]
+
+class ReplicateTTMBinding(LollmsTTMBinding):
+    """A Text-to-Music binding for models hosted on Replicate."""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName, **kwargs)
+        self.api_key = self.settings.get("api_key") or os.environ.get("REPLICATE_API_TOKEN")
+        if not self.api_key:
+            raise ValueError("Replicate API token is required. Please set it in config or as REPLICATE_API_TOKEN env var.")
+        self.model_version = self.settings.get("model_name", "meta/musicgen:b05b1dff1d8c6ac63d42422dd565e23b63869bf2d51acda751e04b5dd304535d")
+        self.base_url = "https://api.replicate.com/v1"
+        self.headers = {"Authorization": f"Token {self.api_key}", "Content-Type": "application/json"}
+
+    def list_models(self, **kwargs) -> List[Dict[str, str]]:
+        return REPLICATE_MODELS
+
+    def generate_music(self, prompt: str, **kwargs) -> bytes:
+        """
+        Generates music via Replicate by starting a prediction and polling for the result.
+        """
+        model_id, version_id = self.model_version.split(":")
+        
+        payload = {
+            "version": version_id,
+            "input": {
+                "prompt": prompt,
+                "duration": kwargs.get("duration", 8),
+                "temperature": kwargs.get("temperature", 1.0),
+                "top_p": kwargs.get("top_p", 0.9),
+                # Add other model-specific parameters here
+            }
+        }
+        
+        try:
+            # 1. Start the prediction
+            ASCIIColors.info(f"Submitting music generation job to Replicate ({model_id})...")
+            start_response = requests.post(f"{self.base_url}/predictions", json=payload, headers=self.headers)
+            start_response.raise_for_status()
+            job_data = start_response.json()
+            get_url = job_data["urls"]["get"]
+            ASCIIColors.info(f"Job submitted. Polling for results at: {get_url}")
+
+            # 2. Poll for the result
+            while True:
+                poll_response = requests.get(get_url, headers=self.headers)
+                poll_response.raise_for_status()
+                poll_data = poll_response.json()
+                status = poll_data["status"]
+
+                if status == "succeeded":
+                    ASCIIColors.green("Generation successful!")
+                    output_url = poll_data["output"]
+                    # Download the resulting audio file
+                    audio_response = requests.get(output_url)
+                    audio_response.raise_for_status()
+                    return audio_response.content
+                elif status in ["starting", "processing"]:
+                    ASCIIColors.info(f"Job status: {status}. Waiting...")
+                    time.sleep(3)
+                else: # failed, canceled
+                    error_log = poll_data.get("logs", "No logs available.")
+                    raise Exception(f"Replicate job failed with status '{status}'. Log: {error_log}")
+                    
+        except requests.exceptions.HTTPError as e:
+            error_details = e.response.json().get("detail", e.response.text)
+            raise Exception(f"Replicate API HTTP Error: {error_details}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Replicate TTM Binding Test ---")
+    if "REPLICATE_API_TOKEN" not in os.environ:
+        ASCIIColors.error("REPLICATE_API_TOKEN environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = ReplicateTTMBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Music Generation with MusicGen ---")
+        prompt = "An epic cinematic orchestral piece, with soaring strings and dramatic percussion, fit for a movie trailer"
+        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_replicate_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"Replicate TTM binding test failed: {e}")