lollms-client 1.10.0__tar.gz → 1.10.1__tar.gz

{lollms_client-1.10.0/src/lollms_client.egg-info → lollms_client-1.10.1}/PKG-INFO

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

{lollms_client-1.10.0 → lollms_client-1.10.1}/src/lollms_client/__init__.py

@@ -9,7 +9,7 @@ from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 # Import new bindings utils
 from lollms_client.lollms_bindings_utils import list_bindings, get_binding_desc
 
-__version__ = "1.10.0" # Updated version
+__version__ = "1.10.1" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

{lollms_client-1.10.0 → lollms_client-1.10.1}/src/lollms_client/tti_bindings/diffusers/__init__.py

@@ -7,6 +7,7 @@ import time
 import json
 from io import BytesIO
 from pathlib import Path
+from ascii_colors import trace_exception
 from typing import Optional, List, Dict, Any, Union, Callable
 
 # Ensure pipmaster is available.
@@ -126,6 +127,14 @@ class DiffusersTTIBinding(LollmsTTIBinding):
         pm_v.ensure_packages([
             "transformers", "safetensors", "accelerate"
         ])
+        ASCIIColors.info(f"Installing hugging face dependencies")
+        pm_v.ensure_packages([
+            "hf_xet"
+        ])
+        ASCIIColors.info(f"Installing bits and bytes for quantized models")
+        pm_v.ensure_packages([
+            "bitsandbytes"
+        ])
         ASCIIColors.info(f"[Optional] Installing xformers")
         try:
             pm_v.ensure_packages([
@@ -498,6 +507,38 @@ class DiffusersTTIBinding(LollmsTTIBinding):
                 progress_callback({"status": "error", "message": error_msg})
             return {"status": False, "message": error_msg}
 
+
+    def reinstall_dependencies(self):
+        """
+        Re‑install the Python packages required by the Diffusers server.
+
+        This method looks for a ``requirements.txt`` file located in the
+        same directory as this ``__init__.py``.  It then runs:
+
+            ``python -m pip install -r requirements.txt``
+
+        using the **same interpreter** that runs the current process,
+        ensuring that the correct virtual environment is targeted.
+
+        Returns
+        -------
+        dict
+            ``{'status': bool, 'message': str}`` – ``status`` is ``True`` on
+            success, ``False`` otherwise.  ``message`` contains a short
+            description or the error that occurred.
+        """
+        try:
+            self.install_server_dependencies()
+            return {
+                "status": True,
+                "message": "Dependencies reinstalled successfully.",
+            }
+
+        except Exception as e:
+            trace_exception(e)
+            return {"status": False, "message": str(e)}
+
+
     def __del__(self):
         # The client destructor does not stop the server,
         # as it is a shared resource for all worker processes.

{lollms_client-1.10.0 → lollms_client-1.10.1}/src/lollms_client/tti_bindings/diffusers/server/main.py

@@ -287,8 +287,8 @@ class ModelManager:
                 load_params["cache_dir"] = str(self.config["hf_cache_path"])
             load_params["torch_dtype"] = torch_dtype
 
-            is_qwen_model = "Qwen" in model_name_from_config
-            is_flux_model = "FLUX" in model_name_from_config
+            is_qwen_model = "Qwen".lower() in model_name_from_config.lower() 
+            is_flux_model = "FLUX".lower()  in model_name_from_config.lower() 
 
             if is_qwen_model or is_flux_model:
                 ASCIIColors.info(f"Special model '{model_name_from_config}' detected. Using dedicated pipeline loader.")
@@ -310,11 +310,12 @@ class ModelManager:
                 
                 if is_flux_model:
                     self.pipeline = AutoPipelineForText2Image.from_pretrained(model_name_from_config, **load_params)
-                elif "Qwen-Image-Edit-2509" in model_name_from_config:
-                    self.pipeline = QwenImageEditPlusPipeline.from_pretrained(model_name_from_config, **load_params)
                 elif "Qwen-Image-Edit" in model_name_from_config:
-                    self.pipeline = QwenImageEditPipeline.from_pretrained(model_name_from_config, **load_params)
-                elif "Qwen/Qwen-Image" in model_name_from_config:
+                    try:
+                        self.pipeline = QwenImageEditPlusPipeline.from_pretrained(model_name_from_config, **load_params)
+                    except:
+                        self.pipeline = QwenImageEditPipeline.from_pretrained(model_name_from_config, **load_params)
+                else:#if "Qwen/Qwen-Image" in model_name_from_config:
                     self.pipeline = DiffusionPipeline.from_pretrained(model_name_from_config, **load_params)
             
             else:
@@ -362,9 +363,9 @@ class ModelManager:
         # --- FIX START ---
         # Force VAE to float32 to prevent black/chunky artifacts on some GPUs when using float16
         if self.pipeline and hasattr(self.pipeline, 'vae') and hasattr(self.pipeline.vae, 'dtype'):
-             if self.pipeline.vae.dtype == torch.float16:
-                ASCIIColors.info("Upcasting VAE to float32 to prevent artifacts.")
-                self.pipeline.vae = self.pipeline.vae.to(dtype=torch.float32)
+            if self.pipeline.vae.dtype == torch.float16:
+               ASCIIColors.info("Upcasting VAE to float32 to prevent artifacts.")
+               self.pipeline.vae = self.pipeline.vae.to(dtype=torch.float32)
         # --- FIX END ---
 
         self._set_scheduler()
@@ -808,7 +809,7 @@ async def edit_image(request: EditRequestJSON):
         
         if "Qwen-Image-Edit-2509" in model_name:
             task = "image2image"
-            pipeline_args.update({"true_cfg_scale": 4.0, "guidance_scale": 1.0, "num_inference_steps": 40, "negative_prompt": " "})
+            pipeline_args.update({"true_cfg_scale": pipeline_args.get("true_cfg_scale",4.0), "guidance_scale": pipeline_args.get("guidance_scale",1.0), "num_inference_steps": pipeline_args.get("num_inference_steps",40), "negative_prompt": pipeline_args.get("negative_prompt","")})
             edit_mode = pipeline_args.get("edit_mode", "fusion")
             if edit_mode == "fusion": pipeline_args["image"] = pil_images
         else:

lollms_client-1.10.1/src/lollms_client/tts_bindings/FishSpeech/__init__.py

@@ -0,0 +1,281 @@
+import os
+import sys
+import requests
+import subprocess
+import time
+import base64
+from pathlib import Path
+from typing import Optional, List
+
+try:
+    from filelock import FileLock, Timeout
+except ImportError:
+    print("FATAL: The 'filelock' library is required. Please install it: pip install filelock")
+    sys.exit(1)
+
+from lollms_client.lollms_tts_binding import LollmsTTSBinding
+from ascii_colors import ASCIIColors
+
+BindingName = "FishSpeechClientBinding"
+
+class FishSpeechClientBinding(LollmsTTSBinding):
+    """
+    Client binding for Fish Speech (OpenAudio S1) TTS server.
+    Provides state-of-the-art multilingual voice synthesis with zero-shot cloning.
+    """
+    def __init__(self, **kwargs):
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+
+        self.config = kwargs
+        self.host = kwargs.get("host", "localhost")
+        self.port = kwargs.get("port", 8080)
+        self.auto_start_server = kwargs.get("auto_start_server", False)
+        self.compile = kwargs.get("compile", True)
+        self.device = kwargs.get("device", "auto")
+        self.model_name = kwargs.get("model_name", "fishaudio/openaudio-s1-mini")
+        
+        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_fish_speech_venv")
+        
+        # Python version requirement
+        self.target_python_version = "3.12"
+        
+        # Model paths
+        self.checkpoints_dir = self.server_dir / "checkpoints"
+        self.references_dir = self.server_dir / "references"
+
+        if self.auto_start_server:
+            self.ensure_server_is_running()
+
+    def is_server_running(self) -> bool:
+        """Check if the Fish Speech server is running and responsive."""
+        try:
+            response = requests.get(f"{self.base_url}/health", timeout=2)
+            if response.status_code == 200:
+                return True
+        except requests.exceptions.RequestException:
+            return False
+        return False
+
+    def ensure_server_is_running(self):
+        """
+        Ensure the Fish Speech server is running using file lock for process safety.
+        """
+        self.server_dir.mkdir(exist_ok=True)
+        lock_path = self.server_dir / "fish_speech_server.lock"
+        lock = FileLock(lock_path)
+
+        ASCIIColors.info("Attempting to start or connect to Fish Speech server...")
+        
+        if self.is_server_running():
+            ASCIIColors.green("Fish Speech server is already running.")
+            return
+
+        try:
+            with lock.acquire(timeout=10):
+                if not self.is_server_running():
+                    ASCIIColors.yellow("Lock acquired. Starting Fish Speech server...")
+                    self.start_server()
+                    self._wait_for_server(timeout=60)
+                else:
+                    ASCIIColors.green("Server started by another process.")
+        except Timeout:
+            ASCIIColors.yellow("Waiting for another process to start the server...")
+            self._wait_for_server(timeout=90)
+
+        if not self.is_server_running():
+            raise RuntimeError("Failed to start or connect to Fish Speech server.")
+
+    def install_server_dependencies(self):
+        """
+        Install Fish Speech dependencies into a dedicated Python 3.10 virtual environment.
+        """
+        ASCIIColors.info(f"Setting up Python {self.target_python_version} environment in: {self.venv_dir}")
+        
+        try:
+            import pipmaster as pm
+        except ImportError:
+            print("FATAL: pipmaster is required. Install with: pip install pipmaster")
+            raise Exception("pipmaster not found")
+        
+        try:
+            ASCIIColors.info(f"Bootstrapping portable Python {self.target_python_version}...")
+            pm_instance = pm.get_pip_manager_for_version(
+                self.target_python_version,
+                str(self.venv_dir)
+            )
+            
+            ASCIIColors.green(f"Portable Python {self.target_python_version} ready.")
+            ASCIIColors.info(f"Using interpreter: {pm_instance.target_python_executable}")
+            
+        except RuntimeError as e:
+            ASCIIColors.error(f"Failed to bootstrap Python {self.target_python_version}: {e}")
+            raise Exception(f"Fish Speech requires Python {self.target_python_version}")
+        
+        # Install requirements
+        requirements_file = self.server_dir / "requirements.txt"
+        ASCIIColors.info("Installing Fish Speech dependencies...")
+        
+        success = pm_instance.ensure_requirements(str(requirements_file), verbose=True)
+        if not success:
+            ASCIIColors.error("Failed to install dependencies.")
+            raise RuntimeError("Fish Speech dependency installation failed.")
+
+        ASCIIColors.green("Dependencies installed successfully.")
+        self._python_executable = pm_instance.target_python_executable
+        
+        # Download model weights
+        self._download_model_weights(pm_instance)
+
+    def _download_model_weights(self, pm_instance):
+        """Download Fish Speech model weights if not present."""
+        model_path = self.checkpoints_dir / self.model_name.split('/')[-1]
+        
+        if model_path.exists():
+            ASCIIColors.info(f"Model weights found at {model_path}")
+            return
+        
+        ASCIIColors.yellow(f"Downloading model weights for {self.model_name}...")
+        self.checkpoints_dir.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            # Use huggingface-cli to download
+            result = subprocess.run([
+                str(self._python_executable),
+                "-m", "huggingface_hub.commands.huggingface_cli",
+                "download",
+                self.model_name,
+                "--local-dir", str(model_path)
+            ], check=True, capture_output=True, text=True)
+            
+            ASCIIColors.green(f"Model downloaded to {model_path}")
+        except subprocess.CalledProcessError as e:
+            ASCIIColors.error(f"Failed to download model: {e.stderr}")
+            raise RuntimeError("Model download failed.")
+
+    def start_server(self):
+        """Launch the Fish Speech API server as a background process."""
+        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()
+        else:
+            try:
+                import pipmaster as pm
+                pm_instance = pm.get_pip_manager_for_version(
+                    self.target_python_version,
+                    str(self.venv_dir)
+                )
+                self._python_executable = pm_instance.target_python_executable
+            except Exception as e:
+                ASCIIColors.warning(f"Could not verify Python version: {e}")
+                # Fallback
+                if sys.platform == "win32":
+                    self._python_executable = str(self.venv_dir / "Scripts" / "python.exe")
+                else:
+                    self._python_executable = str(self.venv_dir / "bin" / "python")
+
+        # Prepare model path
+        model_short_name = self.model_name.split('/')[-1]
+        model_path = self.checkpoints_dir / model_short_name
+
+        command = [
+            str(self._python_executable),
+            str(server_script),
+            "--host", self.host,
+            "--port", str(self.port),
+            "--model-path", str(model_path),
+            "--device", self.device
+        ]
+        
+        if self.compile:
+            command.append("--compile")
+        
+        creationflags = subprocess.DETACHED_PROCESS if sys.platform == "win32" else 0
+        self.server_process = subprocess.Popen(command, creationflags=creationflags)
+        ASCIIColors.info("Fish Speech server launched.")
+
+    def _wait_for_server(self, timeout=60):
+        """Wait for the server to become responsive."""
+        ASCIIColors.info("Waiting for Fish Speech server...")
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if self.is_server_running():
+                ASCIIColors.green("Fish Speech server is ready.")
+                return
+            time.sleep(3)
+        raise RuntimeError("Fish Speech server failed to start within timeout.")
+
+    def generate_audio(self, text: str, voice: Optional[str] = None, 
+                      reference_text: Optional[str] = None, **kwargs) -> bytes:
+        """
+        Generate audio from text using Fish Speech.
+        
+        Args:
+            text: Text to synthesize (supports emotion markers like (happy), (sad))
+            voice: Path to reference audio file for voice cloning (WAV/MP3, 10-30s)
+            reference_text: Transcript of reference audio (improves accuracy)
+            **kwargs: Additional parameters (format, top_p, temperature, etc.)
+        """
+        self.ensure_server_is_running()
+        
+        payload = {
+            "text": text,
+            "reference_text": reference_text,
+            "format": kwargs.get("format", "wav"),
+            "top_p": kwargs.get("top_p", 0.9),
+            "temperature": kwargs.get("temperature", 0.9),
+            "repetition_penalty": kwargs.get("repetition_penalty", 1.2),
+            "normalize": kwargs.get("normalize", True),
+            "chunk_length": kwargs.get("chunk_length", 200)
+        }
+        
+        # Handle reference audio
+        if voice:
+            voice_path = Path(voice)
+            if not voice_path.exists():
+                # Try references directory
+                voice_path = self.references_dir / voice
+                if not voice_path.exists():
+                    raise FileNotFoundError(f"Reference audio not found: {voice}")
+            
+            # Encode audio as base64
+            with open(voice_path, 'rb') as f:
+                audio_base64 = base64.b64encode(f.read()).decode('utf-8')
+            payload["reference_audio"] = audio_base64
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/v1/tts",
+                json=payload,
+                timeout=300
+            )
+            response.raise_for_status()
+            return response.content
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Failed to communicate with Fish Speech server: {e}")
+            raise RuntimeError("Fish Speech server communication failed.") from e
+
+    def list_voices(self, **kwargs) -> List[str]:
+        """Get available reference voices."""
+        self.ensure_server_is_running()
+        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: {e}")
+            return []
+
+    def list_models(self, **kwargs) -> List[str]:
+        """List available Fish Speech models."""
+        return [
+            "fishaudio/openaudio-s1-mini",
+            "fishaudio/fish-speech-1.5"
+        ]

lollms_client-1.10.1/src/lollms_client/tts_bindings/FishSpeech/server/main.py

@@ -0,0 +1,260 @@
+try:
+    import uvicorn
+    from fastapi import FastAPI, HTTPException
+    from fastapi.responses import Response
+    from pydantic import BaseModel
+    import argparse
+    import sys
+    import os
+    from pathlib import Path
+    import asyncio
+    import traceback
+    import base64
+    import io
+    import wave
+    import numpy as np
+    from typing import Optional, List
+    import warnings
+
+    warnings.filterwarnings("ignore", category=UserWarning)
+    warnings.filterwarnings("ignore", category=FutureWarning)
+    
+    from ascii_colors import ASCIIColors
+
+    # Fish Speech imports
+    try:
+        ASCIIColors.info("Server: Loading Fish Speech dependencies...")
+        import torch
+        from fish_speech.models.text2semantic.inference import InferenceBuilder as Text2SemanticInference
+        from fish_speech.models.dac.inference import AudioCodecInference
+        ASCIIColors.green("Server: Fish Speech dependencies loaded")
+        
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        ASCIIColors.info(f"Server: Using device: {device}")
+        fish_speech_available = True
+        
+    except Exception as e:
+        ASCIIColors.error(f"Server: Failed to load Fish Speech: {e}")
+        ASCIIColors.error(f"Server: Traceback:\n{traceback.format_exc()}")
+        fish_speech_available = False
+
+    # API Models
+    class TTSRequest(BaseModel):
+        text: str
+        reference_audio: Optional[str] = None  # base64 encoded
+        reference_text: Optional[str] = None
+        format: str = "wav"
+        top_p: float = 0.9
+        temperature: float = 0.9
+        repetition_penalty: float = 1.2
+        normalize: bool = True
+        chunk_length: int = 200
+
+    class FishSpeechServer:
+        def __init__(self, model_path: str, device: str = "auto", compile: bool = False):
+            self.model_path = Path(model_path)
+            self.device = device if device != "auto" else ("cuda" if torch.cuda.is_available() else "cpu")
+            self.compile = compile and self.device == "cuda"
+            self.model_loaded = False
+            self.model_loading = False
+            
+            self.text2semantic_model = None
+            self.codec_model = None
+            
+            self.references_dir = Path(__file__).parent / "references"
+            self.references_dir.mkdir(exist_ok=True)
+            
+            ASCIIColors.info(f"Server: Fish Speech server initialized (model will load on first request)")
+            ASCIIColors.info(f"Server: Model path: {self.model_path}")
+            ASCIIColors.info(f"Server: Device: {self.device}, Compile: {self.compile}")
+        
+        async def _ensure_model_loaded(self):
+            """Lazy load Fish Speech models."""
+            if self.model_loaded:
+                return
+            
+            if self.model_loading:
+                while self.model_loading and not self.model_loaded:
+                    await asyncio.sleep(0.1)
+                return
+            
+            if not fish_speech_available:
+                raise RuntimeError("Fish Speech not available. Check dependencies.")
+            
+            try:
+                self.model_loading = True
+                ASCIIColors.yellow("Server: Loading Fish Speech models (first run may take time)...")
+                
+                # Load text2semantic model
+                self.text2semantic_model = Text2SemanticInference(
+                    checkpoint_path=str(self.model_path),
+                    device=self.device,
+                    compile=self.compile
+                )
+                
+                # Load codec model
+                codec_path = self.model_path / "codec.pth"
+                if not codec_path.exists():
+                    # Try alternative names
+                    codec_path = self.model_path / "firefly-gan-vq-fsq-8x1024-21hz-generator.pth"
+                
+                self.codec_model = AudioCodecInference(
+                    checkpoint_path=str(codec_path),
+                    device=self.device
+                )
+                
+                self.model_loaded = True
+                ASCIIColors.green("Server: Fish Speech models loaded successfully")
+                
+            except Exception as e:
+                ASCIIColors.error(f"Server: Error loading models: {e}")
+                ASCIIColors.error(f"Server: Traceback:\n{traceback.format_exc()}")
+                self.model_loaded = False
+                raise
+            finally:
+                self.model_loading = False
+        
+        async def generate_audio(self, request: TTSRequest) -> bytes:
+            """Generate audio from text using Fish Speech."""
+            await self._ensure_model_loaded()
+            
+            if not self.model_loaded:
+                raise RuntimeError("Fish Speech models not loaded")
+            
+            try:
+                ASCIIColors.info(f"Server: Generating audio for: '{request.text[:50]}...'")
+                
+                # Prepare reference audio if provided
+                reference_tokens = None
+                if request.reference_audio:
+                    audio_bytes = base64.b64decode(request.reference_audio)
+                    # Encode reference audio
+                    reference_tokens = self._encode_reference_audio(
+                        audio_bytes,
+                        request.reference_text
+                    )
+                
+                # Generate semantic tokens from text
+                codes = self.text2semantic_model.generate(
+                    text=request.text,
+                    prompt_tokens=reference_tokens,
+                    prompt_text=request.reference_text,
+                    top_p=request.top_p,
+                    temperature=request.temperature,
+                    repetition_penalty=request.repetition_penalty,
+                    max_new_tokens=2048
+                )
+                
+                # Generate audio from semantic tokens
+                audio_data = self.codec_model.decode(codes)
+                
+                # Convert to bytes
+                if request.format == "wav":
+                    audio_bytes = self._to_wav_bytes(audio_data)
+                elif request.format == "mp3":
+                    audio_bytes = self._to_mp3_bytes(audio_data)
+                else:  # pcm
+                    audio_bytes = audio_data.tobytes()
+                
+                ASCIIColors.green(f"Server: Generated {len(audio_bytes)} bytes")
+                return audio_bytes
+                
+            except Exception as e:
+                ASCIIColors.error(f"Server: Error generating audio: {e}")
+                ASCIIColors.error(f"Server: Traceback:\n{traceback.format_exc()}")
+                raise
+        
+        def _encode_reference_audio(self, audio_bytes: bytes, transcript: Optional[str]) -> np.ndarray:
+            """Encode reference audio to semantic tokens."""
+            # Save temporarily
+            temp_path = self.references_dir / "temp_reference.wav"
+            with open(temp_path, 'wb') as f:
+                f.write(audio_bytes)
+            
+            try:
+                tokens = self.codec_model.encode(str(temp_path))
+                return tokens
+            finally:
+                temp_path.unlink(missing_ok=True)
+        
+        def _to_wav_bytes(self, audio_data: np.ndarray, sample_rate: int = 44100) -> bytes:
+            """Convert audio array to WAV bytes."""
+            buffer = io.BytesIO()
+            with wave.open(buffer, 'wb') as wf:
+                wf.setnchannels(1)
+                wf.setsampwidth(2)
+                wf.setframerate(sample_rate)
+                wf.writeframes((audio_data * 32767).astype(np.int16).tobytes())
+            return buffer.getvalue()
+        
+        def _to_mp3_bytes(self, audio_data: np.ndarray) -> bytes:
+            """Convert audio array to MP3 bytes."""
+            # Requires pydub - fallback to WAV
+            return self._to_wav_bytes(audio_data)
+        
+        def list_voices(self) -> List[str]:
+            """List available reference voices."""
+            return [f.stem for f in self.references_dir.glob("*.[wW][aA][vV]")]
+
+    # FastAPI app
+    app = FastAPI(title="Fish Speech Server")
+    fish_server = None
+
+    @app.post("/v1/tts")
+    async def tts_endpoint(request: TTSRequest):
+        try:
+            audio_bytes = await fish_server.generate_audio(request)
+            
+            media_type = {
+                "wav": "audio/wav",
+                "mp3": "audio/mpeg",
+                "pcm": "audio/pcm"
+            }.get(request.format, "audio/wav")
+            
+            return Response(content=audio_bytes, media_type=media_type)
+        except Exception as e:
+            ASCIIColors.error(f"Server: TTS endpoint error: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    @app.get("/list_voices")
+    async def list_voices_endpoint():
+        try:
+            voices = fish_server.list_voices()
+            return {"voices": voices}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    @app.get("/health")
+    async def health_check():
+        return {
+            "status": "running",
+            "fish_speech_available": fish_speech_available,
+            "model_loaded": fish_server.model_loaded if fish_server else False
+        }
+
+    if __name__ == '__main__':
+        parser = argparse.ArgumentParser(description="Fish Speech TTS Server")
+        parser.add_argument("--host", type=str, default="localhost")
+        parser.add_argument("--port", type=int, default=8080)
+        parser.add_argument("--model-path", type=str, required=True)
+        parser.add_argument("--device", type=str, default="auto")
+        parser.add_argument("--compile", action="store_true")
+        
+        args = parser.parse_args()
+
+        fish_server = FishSpeechServer(
+            model_path=args.model_path,
+            device=args.device,
+            compile=args.compile
+        )
+
+        ASCIIColors.cyan("--- Fish Speech TTS Server ---")
+        ASCIIColors.green(f"Starting server on http://{args.host}:{args.port}")
+        
+        uvicorn.run(app, host=args.host, port=args.port)
+
+except Exception as e:
+    from ascii_colors import ASCIIColors
+    ASCIIColors.red(f"Server: CRITICAL ERROR: {e}")
+    import traceback
+    ASCIIColors.red(f"Server: Traceback:\n{traceback.format_exc()}")