lollms-client 1.6.5__tar.gz → 1.6.6__tar.gz

{lollms_client-1.6.5/src/lollms_client.egg-info → lollms_client-1.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.6.5
+Version: 1.6.6
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License:                                  Apache License

{lollms_client-1.6.5 → lollms_client-1.6.6}/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.6.5" # Updated version
+__version__ = "1.6.6" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

{lollms_client-1.6.5 → lollms_client-1.6.6}/src/lollms_client/tti_bindings/diffusers/__init__.py

@@ -53,6 +53,7 @@ class DiffusersBinding(LollmsTTIBinding):
         self.server_dir = self.binding_root / "server"
         self.venv_dir = Path("./venv/tti_diffusers_venv")
         self.models_path = Path(kwargs.get("models_path", "./data/models/diffusers_models")).resolve()
+        self.extra_models_path = kwargs.get("extra_models_path")
         self.models_path.mkdir(exist_ok=True, parents=True)
         if self.auto_start_server:
             self.ensure_server_is_running()
@@ -68,36 +69,47 @@ class DiffusersBinding(LollmsTTIBinding):
         return False
 
 
-    def ensure_server_is_running(self, continue_if_locked: bool = True):
+    def ensure_server_is_running(self):
         """
         Ensures the Diffusers server is running. If not, it attempts to start it
-        in a process-safe manner using a file lock.
-
-        Args:
-            continue_if_locked (bool): If True, return immediately if another process
-                                    already holds the lock.
+        in a process-safe manner using a file lock. This method is designed to
+        prevent race conditions in multi-worker environments.
         """
         self.server_dir.mkdir(exist_ok=True)
-        lock_path = self.models_path / "diffusers_server.lock"
+        # Use a lock file in the binding's server directory for consistency across instances
+        lock_path = self.server_dir / "diffusers_server.lock"
         lock = FileLock(lock_path)
 
         ASCIIColors.info("Attempting to start or connect to the Diffusers server...")
+
+        # First, perform a quick check without the lock to avoid unnecessary waiting.
+        if self.is_server_running():
+            ASCIIColors.green("Diffusers Server is already running and responsive.")
+            return
+
         try:
-            # Try to acquire lock immediately if continue_if_locked=True
-            with lock.acquire(timeout=0 if continue_if_locked else 60):
+            # Try to acquire the lock with a timeout. If another process is starting
+            # the server, this will wait until it's finished.
+            with lock.acquire(timeout=60):
+                # After acquiring the lock, we MUST re-check if the server is running.
+                # Another process might have started it and released the lock while we were waiting.
                 if not self.is_server_running():
                     ASCIIColors.yellow("Lock acquired. Starting dedicated Diffusers server...")
                     self.start_server()
+                    # The process that starts the server is responsible for waiting for it to be ready
+                    # BEFORE releasing the lock. This is the key to preventing race conditions.
+                    self._wait_for_server()
                 else:
-                    ASCIIColors.green("Server was started by another process. Connected successfully.")
+                    ASCIIColors.green("Server was started by another process while we waited. Connected successfully.")
         except Timeout:
-            if continue_if_locked:
-                ASCIIColors.yellow("Lock held by another process. Skipping server startup and continuing execution.")
-                return
-            else:
-                ASCIIColors.yellow("Could not acquire lock within timeout. Waiting for server to become available...")
+            # This happens if the process holding the lock takes more than 60 seconds to start the server.
+            # We don't try to start another one. We just wait for the existing one to be ready.
+            ASCIIColors.yellow("Could not acquire lock, another process is taking a long time to start the server. Waiting...")
+            self._wait_for_server(timeout=300) # Give it a longer timeout here just in case.
 
-        self._wait_for_server()
+        # A final verification to ensure we are connected.
+        if not self.is_server_running():
+            raise RuntimeError("Failed to start or connect to the Diffusers server after all attempts.")
 
     def install_server_dependencies(self):
         """
@@ -191,6 +203,10 @@ class DiffusersBinding(LollmsTTIBinding):
             "--models-path", str(self.models_path.resolve()) # Pass models_path to server
         ]
 
+        if self.extra_models_path:
+            resolved_extra_path = Path(self.extra_models_path).resolve()
+            command.extend(["--extra-models-path", str(resolved_extra_path)])
+
         # Use DETACHED_PROCESS on Windows to allow the server to run independently of the parent process.
         # On Linux/macOS, the process will be daemonized enough to not be killed with the worker.
         creationflags = subprocess.DETACHED_PROCESS if sys.platform == "win32" else 0
@@ -273,11 +289,14 @@ class DiffusersBinding(LollmsTTIBinding):
         pass
 
     def generate_image(self, prompt: str, negative_prompt: str = "", **kwargs) -> bytes:
-        # This is a pure JSON request
+        params = kwargs.copy()
+        if "model_name" not in params and self.config.get("model_name"):
+            params["model_name"] = self.config["model_name"]
+            
         response = self._post_json_request("/generate_image", data={
             "prompt": prompt,
             "negative_prompt": negative_prompt,
-            "params": kwargs
+            "params": params
         })
         return response.content
 
@@ -307,15 +326,19 @@ class DiffusersBinding(LollmsTTIBinding):
                 raise ValueError(f"Unsupported image type in edit_image: {type(img)}")
         if not images_b64:
             raise ValueError("No valid images were provided to the edit_image function.")
+        
+        params = kwargs.copy()
+        if "model_name" not in params and self.config.get("model_name"):
+            params["model_name"] = self.config["model_name"]
 
         # Translate "mask" to "mask_image" for server compatibility
-        if "mask" in kwargs and kwargs["mask"]:
-            kwargs["mask_image"] = kwargs.pop("mask")
+        if "mask" in params and params["mask"]:
+            params["mask_image"] = params.pop("mask")
 
         json_payload = {
             "prompt": prompt,
             "images_b64": images_b64,
-            "params": kwargs
+            "params": params
         }
         response = self._post_json_request("/edit_image", data=json_payload)
         return response.content
@@ -351,4 +374,4 @@ class DiffusersBinding(LollmsTTIBinding):
     def __del__(self):
         # The client destructor does not stop the server,
         # as it is a shared resource for all worker processes.
-        pass
+        pass

{lollms_client-1.6.5 → lollms_client-1.6.6}/src/lollms_client/tti_bindings/diffusers/server/main.py

@@ -62,7 +62,7 @@ MODELS_PATH = Path("./models")
 CIVITAI_MODELS = {
     "realistic-vision-v6": {
         "display_name": "Realistic Vision V6.0", "url": "https://civitai.com/api/download/models/501240?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "realisticVisionV60_v60B1.safetensors", "description": "Photorealistic SD1.5 checkpoint.", "owned_by": "civitai"
+        "filename": "realisticVisionV60_v60B1.safensors", "description": "Photorealistic SD1.5 checkpoint.", "owned_by": "civitai"
     },
     "absolute-reality": {
         "display_name": "Absolute Reality", "url": "https://civitai.com/api/download/models/132760?type=Model&format=SafeTensor&size=pruned&fp=fp16",
@@ -122,19 +122,45 @@ CIVITAI_MODELS = {
     },
 }
 
-HF_DEFAULT_MODELS = [
-    {"family": "FLUX", "model_name": "black-forest-labs/FLUX.1-schnell", "display_name": "FLUX.1 Schnell", "desc": "A fast and powerful next-gen T2I model."},
-    {"family": "FLUX", "model_name": "black-forest-labs/FLUX.1-dev", "display_name": "FLUX.1 Dev", "desc": "The larger, developer version of the FLUX.1 model."},
-    {"family": "SDXL", "model_name": "stabilityai/stable-diffusion-xl-base-1.0", "display_name": "SDXL Base 1.0", "desc": "Text2Image 1024 native."},
-    {"family": "SDXL", "model_name": "stabilityai/stable-diffusion-xl-refiner-1.0", "display_name": "SDXL Refiner 1.0", "desc": "Refiner for SDXL."},
-    {"family": "SD 1.x", "model_name": "runwayml/stable-diffusion-v1-5", "display_name": "Stable Diffusion 1.5", "desc": "Classic SD1.5."},
-    {"family": "SD 2.x", "model_name": "stabilityai/stable-diffusion-2-1", "display_name": "Stable Diffusion 2.1", "desc": "SD2.1 base."},
-    {"family": "SD3", "model_name": "stabilityai/stable-diffusion-3-medium-diffusers", "display_name": "Stable Diffusion 3 Medium", "desc": "SD3 medium."},
-    {"family": "Qwen", "model_name": "Qwen/Qwen-Image", "display_name": "Qwen Image", "desc": "Dedicated image generation."},
-    {"family": "Specialized", "model_name": "playgroundai/playground-v2.5-1024px-aesthetic", "display_name": "Playground v2.5", "desc": "High aesthetic 1024."},
-    {"family": "Editors", "model_name": "Qwen/Qwen-Image-Edit", "display_name": "Qwen Image Edit", "desc": "Dedicated image editing."},
-    {"family": "Editors", "model_name": "Qwen/Qwen-Image-Edit-2509", "display_name": "Qwen Image Edit Plus (Multi-Image)", "desc": "Advanced multi-image editing, fusion, and pose transfer."}
-]
+HF_PUBLIC_MODELS = {
+    "General Purpose & SDXL": [
+        {"model_name": "stabilityai/stable-diffusion-xl-base-1.0", "display_name": "Stable Diffusion XL 1.0", "desc": "Official 1024x1024 text-to-image model from Stability AI."},
+        {"model_name": "stabilityai/sdxl-turbo", "display_name": "SDXL Turbo", "desc": "A fast, real-time text-to-image model based on SDXL."},
+        {"model_name": "kandinsky-community/kandinsky-3", "display_name": "Kandinsky 3", "desc": "A powerful multilingual model with strong prompt understanding and aesthetic quality."},
+        {"model_name": "playgroundai/playground-v2.5-1024px-aesthetic", "display_name": "Playground v2.5", "desc": "A high-quality model focused on aesthetic outputs."},
+    ],
+    "Photorealistic": [
+        {"model_name": "emilianJR/epiCRealism", "display_name": "epiCRealism", "desc": "A popular community model for generating photorealistic images."},
+        {"model_name": "SG161222/Realistic_Vision_V5.1_noVAE", "display_name": "Realistic Vision 5.1", "desc": "One of the most popular realistic models, great for portraits and scenes."},
+        {"model_name": "Photon-v1", "display_name": "Photon", "desc": "A model known for high-quality, realistic images with good lighting and detail."},
+    ],
+    "Anime & Illustration": [
+        {"model_name": "hakurei/waifu-diffusion", "display_name": "Waifu Diffusion 1.4", "desc": "A widely-used model for generating high-quality anime-style images."},
+        {"model_name": "gsdf/Counterfeit-V3.0", "display_name": "Counterfeit V3.0", "desc": "A strong model for illustrative and 2.5D anime styles."},
+        {"model_name": "cagliostrolab/animagine-xl-3.0", "display_name": "Animagine XL 3.0", "desc": "A state-of-the-art anime model on the SDXL architecture."},
+    ],
+    "Artistic & Stylized": [
+        {"model_name": "wavymulder/Analog-Diffusion", "display_name": "Analog Diffusion", "desc": "Creates images with a vintage, analog film aesthetic."},
+        {"model_name": "dreamlike-art/dreamlike-photoreal-2.0", "display_name": "Dreamlike Photoreal 2.0", "desc": "Produces stunning, artistic, and photorealistic images."},
+    ],
+    "Image Editing Tools": [
+        {"model_name": "stabilityai/stable-diffusion-xl-refiner-1.0", "display_name": "SDXL Refiner 1.0", "desc": "A dedicated refiner model to improve details in SDXL generations."},
+        {"model_name": "Qwen/Qwen-Image-Edit", "display_name": "Qwen Image Edit", "desc": "An instruction-based model for various image editing tasks."},
+        {"model_name": "Qwen/Qwen-Image-Edit-2509", "display_name": "Qwen Image Edit Plus", "desc": "Advanced multi-image editing, fusion, and pose transfer."},
+    ],
+    "Legacy & Base Models": [
+        {"model_name": "runwayml/stable-diffusion-v1-5", "display_name": "Stable Diffusion 1.5", "desc": "The classic and versatile SD1.5 base model."},
+        {"model_name": "stabilityai/stable-diffusion-2-1", "display_name": "Stable Diffusion 2.1", "desc": "The 768x768 base model from the SD2.x series."},
+    ]
+}
+
+HF_GATED_MODELS = {
+    "Next-Generation (Gated Access Required)": [
+        {"model_name": "stabilityai/stable-diffusion-3-medium-diffusers", "display_name": "Stable Diffusion 3 Medium", "desc": "State-of-the-art model with advanced prompt understanding. Requires free registration."},
+        {"model_name": "black-forest-labs/FLUX.1-schnell", "display_name": "FLUX.1 Schnell", "desc": "A powerful and extremely fast next-generation model. Requires access request."},
+        {"model_name": "black-forest-labs/FLUX.1-dev", "display_name": "FLUX.1 Dev", "desc": "The larger developer version of the FLUX.1 model. Requires access request."},
+    ]
+}
 
 
 TORCH_DTYPE_MAP_STR_TO_OBJ = {
@@ -228,9 +254,25 @@ class ModelManager:
             if not local_path.exists():
                 self._download_civitai_model(model_name)
             return local_path
+
+        # Search in extra models path
+        if state.extra_models_path and state.extra_models_path.exists():
+            found_paths = list(state.extra_models_path.rglob(model_name))
+            if found_paths:
+                ASCIIColors.info(f"Found model in extra path: {found_paths[0]}")
+                return found_paths[0]
+
+        # Search in primary models path
+        found_paths = list(self.models_path.rglob(model_name))
+        if found_paths:
+            ASCIIColors.info(f"Found model in primary path: {found_paths[0]}")
+            return found_paths[0]
+
+        # Fallback for HF hub models that are folders, not single files.
         local_path = self.models_path / model_name
         if local_path.exists():
             return local_path
+
         return model_name
 
     def _download_civitai_model(self, model_key: str):
@@ -535,9 +577,12 @@ class PipelineRegistry:
             return list(self._managers.values())
 
 class ServerState:
-    def __init__(self, models_path: Path):
+    def __init__(self, models_path: Path, extra_models_path: Optional[Path] = None):
         self.models_path = models_path
+        self.extra_models_path = extra_models_path
         self.models_path.mkdir(parents=True, exist_ok=True)
+        if self.extra_models_path:
+            self.extra_models_path.mkdir(parents=True, exist_ok=True)
         self.config_path = self.models_path.parent / "diffusers_server_config.json"
         self.registry = PipelineRegistry()
         self.manager: Optional[ModelManager] = None
@@ -802,14 +847,49 @@ async def edit_image(request: EditRequestJSON):
 
 @router.get("/list_models")
 def list_models_endpoint():
-    civitai = [{'model_name': key, 'display_name': info['display_name'], 'description': info['description'], 'owned_by': info['owned_by']} for key, info in CIVITAI_MODELS.items()]
-    local = [{'model_name': f.name, 'display_name': f.stem, 'description': 'Local safetensors file.', 'owned_by': 'local_user'} for f in state.models_path.glob("*.safetensors")]
-    huggingface = [{'model_name': m['model_name'], 'display_name': m['display_name'], 'description': m['desc'], 'owned_by': 'huggingface'} for m in HF_DEFAULT_MODELS]
-    return huggingface + civitai + local
+    huggingface_models = []
+    # Add public models, organized by category
+    for category, models in HF_PUBLIC_MODELS.items():
+        for model_info in models:
+            huggingface_models.append({
+                'model_name': model_info['model_name'], 
+                'display_name': model_info['display_name'], 
+                'description': f"({category}) {model_info['desc']}", 
+                'owned_by': 'huggingface'
+            })
+
+    # Conditionally add gated models if an HF token is provided in the server config
+    if state.config.get("hf_token"):
+        ASCIIColors.info("HF token detected, including gated models in the list.")
+        for category, models in HF_GATED_MODELS.items():
+            for model_info in models:
+                huggingface_models.append({
+                    'model_name': model_info['model_name'], 
+                    'display_name': model_info['display_name'], 
+                    'description': f"({category}) {model_info['desc']}", 
+                    'owned_by': 'huggingface'
+                })
+    else:
+        ASCIIColors.info("No HF token found, showing public models only.")
+
+    civitai_models = [{'model_name': key, 'display_name': info['display_name'], 'description': f"(Civitai) {info['description']}", 'owned_by': info['owned_by']} for key, info in CIVITAI_MODELS.items()]
+    
+    local_files = list_local_models_endpoint()
+    local_models = [{'model_name': filename, 'display_name': Path(filename).stem, 'description': '(Local) Local safetensors file.', 'owned_by': 'local_user'} for filename in local_files]
+
+    return huggingface_models + civitai_models + local_models
 
 @router.get("/list_local_models")
 def list_local_models_endpoint():
-    return sorted([f.name for f in state.models_path.glob("*.safetensors")])
+    local_models = set()
+    # Main models path
+    for f in state.models_path.glob("**/*.safetensors"):
+        local_models.add(f.name)
+    # Extra models path
+    if state.extra_models_path and state.extra_models_path.exists():
+        for f in state.extra_models_path.glob("**/*.safetensors"):
+            local_models.add(f.name)
+    return sorted(list(local_models))
 
 @router.get("/list_available_models")
 def list_available_models_endpoint():
@@ -866,14 +946,18 @@ if __name__ == "__main__":
     parser.add_argument("--host", type=str, default="localhost", help="Host to bind to.")
     parser.add_argument("--port", type=int, default=9630, help="Port to bind to.")
     parser.add_argument("--models-path", type=str, required=True, help="Path to the models directory.")
+    parser.add_argument("--extra-models-path", type=str, default=None, help="Path to an extra models directory.")
     args = parser.parse_args()
 
     MODELS_PATH = Path(args.models_path)
-    state = ServerState(MODELS_PATH)
+    EXTRA_MODELS_PATH = Path(args.extra_models_path) if args.extra_models_path else None
+    state = ServerState(MODELS_PATH, EXTRA_MODELS_PATH)
     
     ASCIIColors.cyan(f"--- Diffusers TTI Server ---")
     ASCIIColors.green(f"Starting server on http://{args.host}:{args.port}")
     ASCIIColors.green(f"Serving models from: {MODELS_PATH.resolve()}")
+    if EXTRA_MODELS_PATH:
+        ASCIIColors.green(f"Serving extra models from: {EXTRA_MODELS_PATH.resolve()}")
     if not DIFFUSERS_AVAILABLE:
         ASCIIColors.error("Diffusers or its dependencies are not installed correctly in the server's environment!")
     else:

lollms_client-1.6.6/src/lollms_client/tts_bindings/xtts/__init__.py

@@ -0,0 +1,195 @@
+import os
+import sys
+import requests
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional, List
+
+# Ensure pipmaster is available.
+try:
+    import pipmaster as pm
+except ImportError:
+    print("FATAL: pipmaster is not installed. Please install it using: pip install pipmaster")
+    sys.exit(1)
+
+# Ensure filelock is available for process-safe server startup.
+try:
+    from filelock import FileLock, Timeout
+except ImportError:
+    print("FATAL: The 'filelock' library is required. Please install it by running: pip install filelock")
+    sys.exit(1)
+
+from lollms_client.lollms_tts_binding import LollmsTTSBinding
+from ascii_colors import ASCIIColors
+
+BindingName = "XTTSClientBinding"
+
+class XTTSClientBinding(LollmsTTSBinding):
+    """
+    Client binding for a dedicated, managed XTTS server.
+    This architecture prevents the heavy XTTS model from being loaded into memory
+    by multiple worker processes, solving potential OOM errors and speeding up TTS generation.
+    """
+    def __init__(self, 
+                 **kwargs):
+        
+        binding_name = "xtts"
+        super().__init__(binding_name=binding_name, **kwargs)
+
+        self.config = kwargs
+        self.host = kwargs.get("host", "localhost")
+        self.port = kwargs.get("port", 8081)
+        self.auto_start_server = kwargs.get("auto_start_server", True)
+        self.server_process = None
+        self.base_url = f"http://{self.host}:{self.port}"
+        self.binding_root = Path(__file__).parent
+        self.server_dir = self.binding_root / "server"
+        self.venv_dir = Path("./venv/tts_xtts_venv")
+
+        if self.auto_start_server:
+            self.ensure_server_is_running()
+
+    def is_server_running(self) -> bool:
+        """Checks if the server is already running and responsive."""
+        try:
+            response = requests.get(f"{self.base_url}/status", timeout=2)
+            if response.status_code == 200 and response.json().get("status") == "running":
+                return True
+        except requests.exceptions.RequestException:
+            return False
+        return False
+
+    def ensure_server_is_running(self):
+        """
+        Ensures the XTTS server is running. If not, it attempts to start it
+        in a process-safe manner using a file lock.
+        """
+        self.server_dir.mkdir(exist_ok=True)
+        lock_path = self.server_dir / "xtts_server.lock"
+        lock = FileLock(lock_path)
+
+        ASCIIColors.info("Attempting to start or connect to the XTTS server...")
+        
+        if self.is_server_running():
+            ASCIIColors.green("XTTS Server is already running and responsive.")
+            return
+
+        try:
+            with lock.acquire(timeout=60):
+                if not self.is_server_running():
+                    ASCIIColors.yellow("Lock acquired. Starting dedicated XTTS server...")
+                    self.start_server()
+                    self._wait_for_server()
+                else:
+                    ASCIIColors.green("Server was started by another process while we waited. Connected successfully.")
+        except Timeout:
+            ASCIIColors.yellow("Could not acquire lock, another process is starting the server. Waiting...")
+            self._wait_for_server(timeout=180)
+
+        if not self.is_server_running():
+            raise RuntimeError("Failed to start or connect to the XTTS server after all attempts.")
+
+
+    def install_server_dependencies(self):
+        """
+        Installs the server's dependencies into a dedicated virtual environment
+        using pipmaster, which handles complex packages like PyTorch.
+        """
+        ASCIIColors.info(f"Setting up virtual environment in: {self.venv_dir}")
+        pm_v = pm.PackageManager(venv_path=str(self.venv_dir))
+        
+        requirements_file = self.server_dir / "requirements.txt"
+        
+        ASCIIColors.info("Installing server dependencies from requirements.txt...")
+        success = pm_v.ensure_requirements(str(requirements_file), verbose=True)
+
+        if not success:
+            ASCIIColors.error("Failed to install server dependencies. Please check the console output for errors.")
+            raise RuntimeError("XTTS server dependency installation failed.")
+
+        ASCIIColors.green("Server dependencies are satisfied.")
+
+
+    def start_server(self):
+        """
+        Installs dependencies and launches the FastAPI server as a background subprocess.
+        This method should only be called from within a file lock.
+        """
+        server_script = self.server_dir / "main.py"
+        if not server_script.exists():
+            raise FileNotFoundError(f"Server script not found at {server_script}.")
+
+        if not self.venv_dir.exists():
+            self.install_server_dependencies()
+
+        if sys.platform == "win32":
+            python_executable = self.venv_dir / "Scripts" / "python.exe"
+        else:
+            python_executable = self.venv_dir / "bin" / "python"
+
+        command = [
+            str(python_executable),
+            str(server_script),
+            "--host", self.host,
+            "--port", str(self.port)
+        ]
+        
+        # Use DETACHED_PROCESS on Windows to allow the server to run independently.
+        creationflags = subprocess.DETACHED_PROCESS if sys.platform == "win32" else 0
+        
+        self.server_process = subprocess.Popen(command, creationflags=creationflags)
+        ASCIIColors.info("XTTS server process launched in the background.")
+
+    def _wait_for_server(self, timeout=120):
+        """Waits for the server to become responsive."""
+        ASCIIColors.info("Waiting for XTTS server to become available...")
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if self.is_server_running():
+                ASCIIColors.green("XTTS Server is up and running.")
+                return
+            time.sleep(2)
+        raise RuntimeError("Failed to connect to the XTTS server within the specified timeout.")
+
+    def __del__(self):
+        # The client destructor does not stop the server,
+        # as it is a shared resource for other processes.
+        pass
+
+    def generate_audio(self, text: str, voice: Optional[str] = None, **kwargs) -> bytes:
+        """Generate audio by calling the server's API"""
+        payload = {"text": text, "voice": voice}
+        # Pass other kwargs from the description file (language, split_sentences)
+        payload.update(kwargs)
+        
+        try:
+            response = requests.post(f"{self.base_url}/generate_audio", json=payload, timeout=300)
+            response.raise_for_status()
+            return response.content
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Failed to communicate with XTTS server at {self.base_url}.")
+            ASCIIColors.error(f"Error details: {e}")
+            raise RuntimeError("Communication with the XTTS server failed.") from e
+
+
+    def list_voices(self, **kwargs) -> List[str]:
+        """Get available voices from the server"""
+        try:
+            response = requests.get(f"{self.base_url}/list_voices")
+            response.raise_for_status()
+            return response.json().get("voices", [])
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Failed to get voices from XTTS server: {e}")
+            return []
+
+
+    def list_models(self, **kwargs) -> list:
+        """Lists models supported by the server"""
+        try:
+            response = requests.get(f"{self.base_url}/list_models")
+            response.raise_for_status()
+            return response.json().get("models", [])
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Failed to get models from XTTS server: {e}")
+            return []