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

lollms_client/tti_bindings/diffusers/__init__.py

@@ -1,843 +1,451 @@
-# lollms_client/tti_bindings/diffusers/__init__.py
 import os
-import importlib
-from io import BytesIO
-from typing import Optional, List, Dict, Any, Union, Tuple
-from pathlib import Path
+import sys
 import base64
-import pipmaster as pm
-import threading
-import queue
-from concurrent.futures import Future
-import time
-import hashlib
 import requests
-from tqdm import tqdm
+import subprocess
+import time
 import json
-import shutil
-from lollms_client.lollms_tti_binding import LollmsTTIBinding
-from ascii_colors import trace_exception, ASCIIColors
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union, Callable
 
-pm.ensure_packages(["torch","torchvision"],index_url="https://download.pytorch.org/whl/cu126")
-pm.ensure_packages(["diffusers","pillow","transformers","safetensors","requests","tqdm"])
+# 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:
-    import torch
-    from diffusers import (
-        AutoPipelineForText2Image,
-        AutoPipelineForImage2Image,
-        AutoPipelineForInpainting,
-        DiffusionPipeline,
-        StableDiffusionPipeline,
-        
-    )
-    from diffusers.utils import load_image
-    from PIL import Image
-    DIFFUSERS_AVAILABLE = True
+    from filelock import FileLock, Timeout
 except ImportError:
-    torch = None
-    AutoPipelineForText2Image = None
-    AutoPipelineForImage2Image = None
-    AutoPipelineForInpainting = None
-    DiffusionPipeline = None
-    StableDiffusionPipeline = None
-    Image = None
-    load_image = None
-    DIFFUSERS_AVAILABLE = False
-
-BindingName = "DiffusersTTIBinding_Impl"
-
-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"
-    },
-    "absolute-reality": {
-        "display_name": "Absolute Reality",
-        "url": "https://civitai.com/api/download/models/132760?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "absolutereality_v181.safetensors",
-        "description": "General realistic SD1.5.",
-        "owned_by": "civitai"
-    },
-    "dreamshaper-8": {
-        "display_name": "DreamShaper 8",
-        "url": "https://civitai.com/api/download/models/128713",
-        "filename": "dreamshaper_8.safetensors",
-        "description": "Versatile SD1.5 style model.",
-        "owned_by": "civitai"
-    },
-    "juggernaut-xl": {
-        "display_name": "Juggernaut XL",
-        "url": "https://civitai.com/api/download/models/133005",
-        "filename": "juggernautXL_version6Rundiffusion.safetensors",
-        "description": "Artistic SDXL.",
-        "owned_by": "civitai"
-    },
-    "lyriel-v1.6": {
-        "display_name": "Lyriel v1.6",
-        "url": "https://civitai.com/api/download/models/72396?type=Model&format=SafeTensor&size=full&fp=fp16",
-        "filename": "lyriel_v16.safetensors",
-        "description": "Fantasy/stylized SD1.5.",
-        "owned_by": "civitai"
-    },
-    "ui_icons": {
-        "display_name": "UI Icons",
-        "url": "https://civitai.com/api/download/models/367044?type=Model&format=SafeTensor&size=full&fp=fp16",
-        "filename": "uiIcons_v10.safetensors",
-        "description": "A model for generating UI icons.",
-        "owned_by": "civitai"
-    },
-    "meinamix": {
-        "display_name": "MeinaMix",
-        "url": "https://civitai.com/api/download/models/948574?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "meinamix_meinaV11.safetensors",
-        "description": "Anime/illustration SD1.5.",
-        "owned_by": "civitai"
-    },
-    "rpg-v5": {
-        "display_name": "RPG v5",
-        "url": "https://civitai.com/api/download/models/124626?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "rpg_v5.safetensors",
-        "description": "RPG assets SD1.5.",
-        "owned_by": "civitai"
-    },
-    "pixel-art-xl": {
-        "display_name": "Pixel Art XL",
-        "url": "https://civitai.com/api/download/models/135931?type=Model&format=SafeTensor",
-        "filename": "pixelartxl_v11.safetensors",
-        "description": "Pixel art SDXL.",
-        "owned_by": "civitai"
-    },
-    "lowpoly-world": {
-        "display_name": "Lowpoly World",
-        "url": "https://civitai.com/api/download/models/146502?type=Model&format=SafeTensor",
-        "filename": "LowpolySDXL.safetensors",
-        "description": "Lowpoly style SD1.5.",
-        "owned_by": "civitai"
-    },
-    "toonyou": {
-        "display_name": "ToonYou",
-        "url": "https://civitai.com/api/download/models/125771?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "toonyou_beta6.safetensors",
-        "description": "Cartoon/Disney SD1.5.",
-        "owned_by": "civitai"
-    },
-    "papercut": {
-        "display_name": "Papercut",
-        "url": "https://civitai.com/api/download/models/133503?type=Model&format=SafeTensor",
-        "filename": "papercut.safetensors",
-        "description": "Paper cutout SD1.5.",
-        "owned_by": "civitai"
-    },
-    "fantassifiedIcons": {
-        "display_name": "Fantassified Icons",
-        "url": "https://civitai.com/api/download/models/67584?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "fantassifiedIcons_fantassifiedIconsV20.safetensors",
-        "description": "Flat, modern Icons.",
-        "owned_by": "civitai"
-    },
-    "game_icon_institute": {
-        "display_name": "Game icon institute",
-        "url": "https://civitai.com/api/download/models/158776?type=Model&format=SafeTensor&size=full&fp=fp16",
-        "filename": "gameIconInstituteV10_v10.safetensors",
-        "description": "Flat, modern game Icons.",
-        "owned_by": "civitai"
-    },
-    "M4RV3LS_DUNGEONS": {
-        "display_name": "M4RV3LS & DUNGEONS",
-        "url": "https://civitai.com/api/download/models/139417?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "M4RV3LSDUNGEONSNEWV40COMICS_mD40.safetensors",
-        "description": "comics.",
-        "owned_by": "civitai"
-    },
-}
-
-TORCH_DTYPE_MAP_STR_TO_OBJ = {
-    "float16": getattr(torch, 'float16', 'float16'),
-    "bfloat16": getattr(torch, 'bfloat16', 'bfloat16'),
-    "float32": getattr(torch, 'float32', 'float32'),
-    "auto": "auto"
-}
-TORCH_DTYPE_MAP_OBJ_TO_STR = {v: k for k, v in TORCH_DTYPE_MAP_STR_TO_OBJ.items()}
-if torch:
-    TORCH_DTYPE_MAP_OBJ_TO_STR[None] = "None"
-
-SCHEDULER_MAPPING = {
-    "default": None,
-    "ddim": "DDIMScheduler",
-    "ddpm": "DDPMScheduler",
-    "deis_multistep": "DEISMultistepScheduler",
-    "dpm_multistep": "DPMSolverMultistepScheduler",
-    "dpm_multistep_karras": "DPMSolverMultistepScheduler",
-    "dpm_single": "DPMSolverSinglestepScheduler",
-    "dpm_adaptive": "DPMSolverPlusPlusScheduler",
-    "dpm++_2m": "DPMSolverMultistepScheduler",
-    "dpm++_2m_karras": "DPMSolverMultistepScheduler",
-    "dpm++_2s_ancestral": "DPMSolverAncestralDiscreteScheduler",
-    "dpm++_2s_ancestral_karras": "DPMSolverAncestralDiscreteScheduler",
-    "dpm++_sde": "DPMSolverSDEScheduler",
-    "dpm++_sde_karras": "DPMSolverSDEScheduler",
-    "euler_ancestral_discrete": "EulerAncestralDiscreteScheduler",
-    "euler_discrete": "EulerDiscreteScheduler",
-    "heun_discrete": "HeunDiscreteScheduler",
-    "heun_karras": "HeunDiscreteScheduler",
-    "lms_discrete": "LMSDiscreteScheduler",
-    "lms_karras": "LMSDiscreteScheduler",
-    "pndm": "PNDMScheduler",
-    "unipc_multistep": "UniPCMultistepScheduler",
-    "dpm++_2m_sde": "DPMSolverMultistepScheduler",
-    "dpm++_2m_sde_karras": "DPMSolverMultistepScheduler",
-    "dpm2": "KDPM2DiscreteScheduler",
-    "dpm2_karras": "KDPM2DiscreteScheduler",
-    "dpm2_a": "KDPM2AncestralDiscreteScheduler",
-    "dpm2_a_karras": "KDPM2AncestralDiscreteScheduler",
-    "euler": "EulerDiscreteScheduler",
-    "euler_a": "EulerAncestralDiscreteScheduler",
-    "heun": "HeunDiscreteScheduler",
-    "lms": "LMSDiscreteScheduler"
-}
-SCHEDULER_USES_KARRAS_SIGMAS = [
-    "dpm_multistep_karras","dpm++_2m_karras","dpm++_2s_ancestral_karras",
-    "dpm++_sde_karras","heun_karras","lms_karras",
-    "dpm++_2m_sde_karras","dpm2_karras","dpm2_a_karras"
-]
-
-class ModelManager:
-    def __init__(self, config: Dict[str, Any], models_path: Path):
-        self.config = config
-        self.models_path = models_path
-        self.pipeline: Optional[DiffusionPipeline] = None
-        self.current_task: Optional[str] = None
-        self.ref_count = 0
-        self.lock = threading.Lock()
-        self.queue = queue.Queue()
-        self.is_loaded = False
-        self.last_used_time = time.time()
-        self._stop_event = threading.Event()
-        self.worker_thread = threading.Thread(target=self._generation_worker, daemon=True)
-        self.worker_thread.start()
-        self._stop_monitor_event = threading.Event()
-        self._unload_monitor_thread = None
-        self._start_unload_monitor()
-
-    def acquire(self):
-        with self.lock:
-            self.ref_count += 1
-            return self
-
-    def release(self):
-        with self.lock:
-            self.ref_count -= 1
-            return self.ref_count
-
-    def stop(self):
-        self._stop_event.set()
-        if self._unload_monitor_thread:
-            self._stop_monitor_event.set()
-            self._unload_monitor_thread.join(timeout=2)
-        self.queue.put(None)
-        self.worker_thread.join(timeout=5)
-
-    def _start_unload_monitor(self):
-        unload_after = self.config.get("unload_inactive_model_after", 0)
-        if unload_after > 0 and self._unload_monitor_thread is None:
-            self._stop_monitor_event.clear()
-            self._unload_monitor_thread = threading.Thread(target=self._unload_monitor, daemon=True)
-            self._unload_monitor_thread.start()
-
-    def _unload_monitor(self):
-        unload_after = self.config.get("unload_inactive_model_after", 0)
-        if unload_after <= 0:
-            return
-        ASCIIColors.info(f"Starting inactivity monitor for '{self.config['model_name']}' (timeout: {unload_after}s).")
-        while not self._stop_monitor_event.wait(timeout=5.0):
-            with self.lock:
-                if not self.is_loaded:
-                    continue
-                if time.time() - self.last_used_time > unload_after:
-                    ASCIIColors.info(f"Model '{self.config['model_name']}' has been inactive. Unloading.")
-                    self._unload_pipeline()
-
-    def _resolve_model_path(self, model_name: str) -> Union[str, Path]:
-        path_obj = Path(model_name)
-        if path_obj.is_absolute() and path_obj.exists():
-            return model_name
-        if model_name in CIVITAI_MODELS:
-            filename = CIVITAI_MODELS[model_name]["filename"]
-            local_path = self.models_path / filename
-            if not local_path.exists():
-                self._download_civitai_model(model_name)
-            return local_path
-        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):
-        model_info = CIVITAI_MODELS[model_key]
-        url = model_info["url"]
-        filename = model_info["filename"]
-        dest_path = self.models_path / filename
-        temp_path = dest_path.with_suffix(".temp")
-        ASCIIColors.cyan(f"Downloading '{filename}' from Civitai...")
-        try:
-            with requests.get(url, stream=True) as r:
-                r.raise_for_status()
-                total_size = int(r.headers.get('content-length', 0))
-                with open(temp_path, 'wb') as f, tqdm(total=total_size, unit='iB', unit_scale=True, desc=f"Downloading {filename}") as bar:
-                    for chunk in r.iter_content(chunk_size=8192):
-                        f.write(chunk)
-                        bar.update(len(chunk))
-            shutil.move(temp_path, dest_path)
-            ASCIIColors.green(f"Model '{filename}' downloaded successfully.")
-        except Exception as e:
-            if temp_path.exists():
-                temp_path.unlink()
-            raise Exception(f"Failed to download model {filename}: {e}") from e
+    print("FATAL: The 'filelock' library is required. Please install it by running: pip install filelock")
+    sys.exit(1)
 
-    def _set_scheduler(self):
-        if not self.pipeline:
-            return
-        scheduler_name_key = self.config["scheduler_name"].lower()
-        if scheduler_name_key == "default":
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import ASCIIColors
+
+BindingName = "DiffusersBinding"
+
+class DiffusersBinding(LollmsTTIBinding):
+    """
+    Client binding for a dedicated, managed Diffusers server.
+    This architecture prevents multiple models from being loaded into memory
+    in a multi-worker environment, solving OOM errors.
+    """
+    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.host = kwargs.get("host", "localhost")
+        self.port = kwargs.get("port", 9632)
+        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/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()
+
+    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=4)
+            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 Diffusers server is running. If not, it attempts to start it
+        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)
+        # 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
-        scheduler_class_name = SCHEDULER_MAPPING.get(scheduler_name_key)
-        if scheduler_class_name:
+
+        try:
+            # 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=3):
+                # 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 while we waited. Connected successfully.")
+        except Timeout:
+            # 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=60) # Give it a longer timeout here just in case.
+
+        # 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):
+        """
+        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))
+
+        # --- PyTorch Installation ---
+        ASCIIColors.info(f"Installing server dependencies")
+        pm_v.ensure_packages([
+            "requests", "uvicorn", "fastapi", "python-multipart", "filelock"
+        ])
+        ASCIIColors.info(f"Installing parisneo libraries")
+        pm_v.ensure_packages([
+            "ascii_colors","pipmaster"
+        ])
+        ASCIIColors.info(f"Installing misc libraries (numpy, tqdm...)")
+        pm_v.ensure_packages([
+            "tqdm", "numpy"
+        ])
+        ASCIIColors.info(f"Installing Pillow")
+        pm_v.ensure_packages([
+            "pillow"
+        ])
+        
+        ASCIIColors.info(f"Installing pytorch")
+        torch_index_url = None
+        if sys.platform == "win32":
             try:
-                SchedulerClass = getattr(importlib.import_module("diffusers.schedulers"), scheduler_class_name)
-                scheduler_config = self.pipeline.scheduler.config
-                scheduler_config["use_karras_sigmas"] = scheduler_name_key in SCHEDULER_USES_KARRAS_SIGMAS
-                self.pipeline.scheduler = SchedulerClass.from_config(scheduler_config)
-                ASCIIColors.info(f"Switched scheduler to {scheduler_class_name}")
-            except Exception as e:
-                ASCIIColors.warning(f"Could not switch scheduler to {scheduler_name_key}: {e}. Using current default.")
-
-    def _load_pipeline_for_task(self, task: str):
-        if self.pipeline and self.current_task == task:
-            return
-        if self.pipeline:
-            self._unload_pipeline()
-        model_name = self.config.get("model_name", "")
-        if not model_name:
-            raise ValueError("Model name cannot be empty for loading.")
-        ASCIIColors.info(f"Loading Diffusers model: {model_name} for task: {task}")
-        model_path = self._resolve_model_path(model_name)
-        torch_dtype = TORCH_DTYPE_MAP_STR_TO_OBJ.get(self.config["torch_dtype_str"].lower())
+                # Use nvidia-smi to detect CUDA
+                result = subprocess.run(["nvidia-smi"], capture_output=True, text=True, check=True)
+                ASCIIColors.green("NVIDIA GPU detected. Installing CUDA-enabled PyTorch.")
+                # Using a common and stable CUDA version. Adjust if needed.
+                torch_index_url = "https://download.pytorch.org/whl/cu128"
+            except (FileNotFoundError, subprocess.CalledProcessError):
+                ASCIIColors.yellow("`nvidia-smi` not found or failed. Installing standard PyTorch. If you have an NVIDIA GPU, please ensure drivers are installed and in PATH.")
+
+        # Base packages including torch. pm.ensure_packages handles verbose output.
+        pm_v.ensure_packages(["torch", "torchvision"], index_url=torch_index_url)
+
+        # Standard dependencies
+        ASCIIColors.info(f"Installing transformers dependencies")
+        pm_v.ensure_packages([
+            "transformers", "safetensors", "accelerate"
+        ])
+        ASCIIColors.info(f"[Optional] Installing xformers")
         try:
-            load_args = {}
-            if self.config.get("hf_cache_path"):
-                load_args["cache_dir"] = str(self.config["hf_cache_path"])
-            if str(model_path).endswith(".safetensors"):
-                if task == "text2image":
+            pm_v.ensure_packages([
+                "xformers"
+            ])
+        except:
+            pass
+        # Git-based diffusers to get the latest version
+        ASCIIColors.info(f"Installing diffusers library from github")
+        pm_v.ensure_packages([
+            {
+                "name": "diffusers",
+                "vcs": "git+https://github.com/huggingface/diffusers.git",
+                "condition": ">=0.35.1"
+            }
+        ])
+
+        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():
+            # Fallback for old structure
+            server_script = self.binding_root / "server.py"
+            if not server_script.exists():
+                raise FileNotFoundError(f"Server script not found at {server_script}. Make sure it's in a 'server' subdirectory.")
+        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),
+            "--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
+
+        self.server_process = subprocess.Popen(command, creationflags=creationflags)
+        ASCIIColors.info("Diffusers server process launched in the background.")
+
+    def _wait_for_server(self, timeout=30):
+        """Waits for the server to become responsive."""
+        ASCIIColors.info("Waiting for Diffusers server to become available...")
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            if self.is_server_running():
+                ASCIIColors.green("Diffusers Server is up and running.")
+                # Set initial settings from the binding's config, but only if a model is specified.
+                if self.config.get("model_name"):
                     try:
-                        self.pipeline = AutoPipelineForText2Image.from_single_file(model_path, torch_dtype=torch_dtype, cache_dir=load_args.get("cache_dir"))
-                    except AttributeError:
-                        self.pipeline = StableDiffusionPipeline.from_single_file(model_path, torch_dtype=torch_dtype, cache_dir=load_args.get("cache_dir"))
-                elif task == "image2image":
-                    self.pipeline = AutoPipelineForImage2Image.from_single_file(model_path, torch_dtype=torch_dtype, cache_dir=load_args.get("cache_dir"))
-                elif task == "inpainting":
-                    self.pipeline = AutoPipelineForInpainting.from_single_file(model_path, torch_dtype=torch_dtype, cache_dir=load_args.get("cache_dir"))
-            else:
-                common_args = {
-                    "torch_dtype": torch_dtype,
-                    "use_safetensors": self.config["use_safetensors"],
-                    "token": self.config["hf_token"],
-                    "local_files_only": self.config["local_files_only"]
-                }
-                if self.config["hf_variant"]:
-                    common_args["variant"] = self.config["hf_variant"]
-                if not self.config["safety_checker_on"]:
-                    common_args["safety_checker"] = None
-                if self.config.get("hf_cache_path"):
-                    common_args["cache_dir"] = str(self.config["hf_cache_path"])
-                if task == "text2image":
-                    self.pipeline = AutoPipelineForText2Image.from_pretrained(model_path, **common_args)
-                elif task == "image2image":
-                    self.pipeline = AutoPipelineForImage2Image.from_pretrained(model_path, **common_args)
-                elif task == "inpainting":
-                    self.pipeline = AutoPipelineForInpainting.from_pretrained(model_path, **common_args)
-        except Exception as e:
-            error_str = str(e).lower()
-            if "401" in error_str or "gated" in error_str or "authorization" in error_str:
-                msg = (
-                    f"AUTHENTICATION FAILED for model '{model_name}'. "
-                    "Please ensure you accepted the model license and provided a valid HF token."
-                )
-                raise RuntimeError(msg) from e
-            raise e
-        self._set_scheduler()
-        self.pipeline.to(self.config["device"])
-        if self.config["enable_xformers"]:
-            try:
-                self.pipeline.enable_xformers_memory_efficient_attention()
-            except Exception as e:
-                ASCIIColors.warning(f"Could not enable xFormers: {e}.")
-        if self.config["enable_cpu_offload"] and self.config["device"] != "cpu":
-            self.pipeline.enable_model_cpu_offload()
-        elif self.config["enable_sequential_cpu_offload"] and self.config["device"] != "cpu":
-            self.pipeline.enable_sequential_cpu_offload()
-        self.is_loaded = True
-        self.current_task = task
-        self.last_used_time = time.time()
-        ASCIIColors.green(f"Model '{model_name}' loaded successfully on '{self.config['device']}' for task '{task}'.")
-
-    def _unload_pipeline(self):
-        if self.pipeline:
-            model_name = self.config.get('model_name', 'Unknown')
-            del self.pipeline
-            self.pipeline = None
-            if torch and torch.cuda.is_available():
-                torch.cuda.empty_cache()
-            self.is_loaded = False
-            self.current_task = None
-            ASCIIColors.info(f"Model '{model_name}' unloaded and VRAM cleared.")
-
-    def _generation_worker(self):
-        while not self._stop_event.is_set():
-            try:
-                job = self.queue.get(timeout=1)
-                if job is None:
-                    break
-                future, task, pipeline_args = job
+                        ASCIIColors.info(f"Syncing initial client settings to server (model: {self.config['model_name']})...")
+                        self.set_settings(self.config)
+                    except Exception as e:
+                        ASCIIColors.warning(f"Could not sync initial settings to server: {e}")
+                else:
+                    ASCIIColors.warning("Client has no model_name configured, skipping initial settings sync.")
+                return
+            time.sleep(2)
+        raise RuntimeError("Failed to connect to the Diffusers server within the specified timeout.")
+
+    def _post_json_request(self, endpoint: str, data: Optional[dict] = None) -> requests.Response:
+        """Helper to make POST requests with a JSON body."""
+        try:
+            url = f"{self.base_url}{endpoint}"
+            response = requests.post(url, json=data, timeout=3600) # Long timeout for generation
+            response.raise_for_status()
+            return response
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Failed to communicate with Diffusers server at {url}.")
+            ASCIIColors.error(f"Error details: {e}")
+            if hasattr(e, 'response') and e.response:
                 try:
-                    with self.lock:
-                        self.last_used_time = time.time()
-                        if not self.is_loaded or self.current_task != task:
-                            self._load_pipeline_for_task(task)
-                    with torch.no_grad():
-                        output = self.pipeline(**pipeline_args)
-                    pil = output.images[0]
-                    buf = BytesIO()
-                    pil.save(buf, format="PNG")
-                    future.set_result(buf.getvalue())
-                except Exception as e:
-                    trace_exception(e)
-                    future.set_exception(e)
-                finally:
-                    self.queue.task_done()
-            except queue.Empty:
-                continue
-
-class PipelineRegistry:
-    _instance = None
-    _lock = threading.Lock()
-    def __new__(cls, *args, **kwargs):
-        with cls._lock:
-            if cls._instance is None:
-                cls._instance = super().__new__(cls)
-                cls._instance._managers = {}
-                cls._instance._registry_lock = threading.Lock()
-        return cls._instance
-    @staticmethod
-    def _get_critical_keys():
-        return [
-            "model_name","device","torch_dtype_str","use_safetensors",
-            "safety_checker_on","hf_variant","enable_cpu_offload",
-            "enable_sequential_cpu_offload","enable_xformers",
-            "local_files_only","hf_cache_path","unload_inactive_model_after"
-        ]
-    def _get_config_key(self, config: Dict[str, Any]) -> str:
-        key_data = tuple(sorted((k, config.get(k)) for k in self._get_critical_keys()))
-        return hashlib.sha256(str(key_data).encode('utf-8')).hexdigest()
-    def get_manager(self, config: Dict[str, Any], models_path: Path) -> ModelManager:
-        key = self._get_config_key(config)
-        with self._registry_lock:
-            if key not in self._managers:
-                self._managers[key] = ModelManager(config.copy(), models_path)
-            return self._managers[key].acquire()
-    def release_manager(self, config: Dict[str, Any]):
-        key = self._get_config_key(config)
-        with self._registry_lock:
-            if key in self._managers:
-                manager = self._managers[key]
-                ref_count = manager.release()
-                if ref_count == 0:
-                    ASCIIColors.info(f"Reference count for model '{config.get('model_name')}' is zero. Cleaning up manager.")
-                    manager.stop()
-                    with manager.lock:
-                        manager._unload_pipeline()
-                    del self._managers[key]
-    def get_active_managers(self) -> List[ModelManager]:
-        with self._registry_lock:
-            return [m for m in self._managers.values() if m.is_loaded]
-
-class DiffusersTTIBinding_Impl(LollmsTTIBinding):
-    DEFAULT_CONFIG = {
-        "model_name": "",
-        "device": "auto",
-        "torch_dtype_str": "auto",
-        "use_safetensors": True,
-        "scheduler_name": "default",
-        "safety_checker_on": True,
-        "num_inference_steps": 25,
-        "guidance_scale": 7.0,
-        "width": 512,
-        "height": 512,
-        "seed": -1,
-        "enable_cpu_offload": False,
-        "enable_sequential_cpu_offload": False,
-        "enable_xformers": False,
-        "hf_variant": None,
-        "hf_token": None,
-        "hf_cache_path": None,
-        "local_files_only": False,
-        "unload_inactive_model_after": 0
-    }
-    HF_DEFAULT_MODELS = [
-        {"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 Edit", "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."}
-    ]
-
-    def __init__(self, **kwargs):
-        super().__init__(binding_name=BindingName)
-        self.manager: Optional[ModelManager] = None
-        if not DIFFUSERS_AVAILABLE:
-            raise ImportError("Diffusers not available. Please install required packages.")
-        self.config = self.DEFAULT_CONFIG.copy()
-        self.config.update(kwargs)
-        self.model_name = self.config.get("model_name", "")
-        
-        models_path_str = kwargs.get("models_path", str(Path(__file__).parent / "models"))
-        self.models_path = Path(models_path_str)
-        self.models_path.mkdir(parents=True, exist_ok=True)
-        self.registry = PipelineRegistry()
-        self._resolve_device_and_dtype()
-        if self.model_name:
-            self._acquire_manager()
+                    ASCIIColors.error(f"Server response: {e.response.json().get('detail', e.response.text)}")
+                except json.JSONDecodeError:
+                    ASCIIColors.error(f"Server raw response: {e.response.text}")
+            raise RuntimeError("Communication with the Diffusers server failed.") from e
 
-    def ps(self) -> List[dict]:
-        if not self.registry:
-            return []
+    def _post_multipart_request(self, endpoint: str, data: Optional[dict] = None, files: Optional[list] = None) -> requests.Response:
+        """Helper to make multipart/form-data POST requests for file uploads."""
         try:
-            active = self.registry.get_active_managers()
-            out = []
-            for m in active:
-                with m.lock:
-                    cfg = m.config
-                    pipe = m.pipeline
-                    vram_usage_bytes = 0
-                    if torch.cuda.is_available() and cfg.get("device") == "cuda" and pipe:
-                        for comp in pipe.components.values():
-                            if hasattr(comp, 'parameters'):
-                                mem_params = sum(p.nelement() * p.element_size() for p in comp.parameters())
-                                mem_bufs = sum(b.nelement() * b.element_size() for b in comp.buffers())
-                                vram_usage_bytes += (mem_params + mem_bufs)
-                    out.append({
-                        "model_name": cfg.get("model_name"),
-                        "vram_size": vram_usage_bytes,
-                        "device": cfg.get("device"),
-                        "torch_dtype": str(pipe.dtype) if pipe else cfg.get("torch_dtype_str"),
-                        "pipeline_type": pipe.__class__.__name__ if pipe else "N/A",
-                        "scheduler_class": pipe.scheduler.__class__.__name__ if pipe and hasattr(pipe, 'scheduler') else "N/A",
-                        "status": "Active" if m.is_loaded else "Idle",
-                        "queue_size": m.queue.qsize(),
-                        "task": m.current_task or "N/A"
-                    })
-            return out
-        except Exception as e:
-            ASCIIColors.error(f"Failed to list running models: {e}")
-            return []
-
-    def _acquire_manager(self):
-        if self.manager:
-            self.registry.release_manager(self.manager.config)
-        self.manager = self.registry.get_manager(self.config, self.models_path)
-        ASCIIColors.info(f"Binding instance acquired manager for '{self.config['model_name']}'.")
-
-    def _resolve_device_and_dtype(self):
-        if self.config["device"].lower() == "auto":
-            self.config["device"] = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
-        if self.config["torch_dtype_str"].lower() == "auto":
-            self.config["torch_dtype_str"] = "float16" if self.config["device"] != "cpu" else "float32"
-
-    def _decode_image_input(self, item: str) -> Image.Image:
-        s = item.strip()
-        if s.startswith("data:image/") and ";base64," in s:
-            b64 = s.split(";base64,")[-1]
-            raw = base64.b64decode(b64)
-            return Image.open(BytesIO(raw)).convert("RGB")
-        if re_b64 := (s[:30].replace("\n","")):
-            try:
-                raw = base64.b64decode(s, validate=True)
-                return Image.open(BytesIO(raw)).convert("RGB")
-            except Exception:
-                pass
+            url = f"{self.base_url}{endpoint}"
+            response = requests.post(url, data=data, files=files, timeout=3600)
+            response.raise_for_status()
+            return response
+        except requests.exceptions.RequestException as e:
+            # (Error handling is the same as above)
+            ASCIIColors.error(f"Failed to communicate with Diffusers server at {url}.")
+            ASCIIColors.error(f"Error details: {e}")
+            if hasattr(e, 'response') and e.response:
+                try:
+                    ASCIIColors.error(f"Server response: {e.response.json().get('detail', e.response.text)}")
+                except json.JSONDecodeError:
+                    ASCIIColors.error(f"Server raw response: {e.response.text}")
+            raise RuntimeError("Communication with the Diffusers server failed.") from e
+        
+    def _get_request(self, endpoint: str, params: Optional[dict] = None) -> requests.Response:
+        """Helper to make GET requests to the server."""
         try:
-            return load_image(s).convert("RGB")
-        except Exception:
-            return Image.open(s).convert("RGB")
-
-    def _prepare_seed(self, kwargs: Dict[str, Any]) -> Optional[torch.Generator]:
-        seed = kwargs.pop("seed", self.config["seed"])
-        if seed == -1:
-            return None
-        return torch.Generator(device=self.config["device"]).manual_seed(seed)
-
-    def list_safetensor_models(self) -> List[str]:
-        if not self.models_path.exists():
-            return []
-        return sorted([f.name for f in self.models_path.iterdir() if f.is_file() and f.suffix == ".safetensors"])
-
-    def listModels(self) -> list:
-        civitai_list = [
-            {'model_name': key, 'display_name': info['display_name'], 'description': info['description'], 'owned_by': info['owned_by']}
-            for key, info in CIVITAI_MODELS.items()
-        ]
-        hf_list = [
-            {'model_name': m["model_name"], 'display_name': m["display_name"], 'description': m["desc"], 'owned_by': 'HuggingFace', 'family': m["family"]}
-            for m in self.HF_DEFAULT_MODELS
-        ]
-        custom_local = []
-        civitai_filenames = {info['filename'] for info in CIVITAI_MODELS.values()}
-        for filename in self.list_safetensor_models():
-            if filename not in civitai_filenames:
-                custom_local.append({'model_name': filename, 'display_name': filename, 'description': 'Local safetensors file.', 'owned_by': 'local_user'})
-        return hf_list + civitai_list + custom_local
-
-    def load_model(self):
-        ASCIIColors.info("load_model() called. Loading is automatic on first use.")
-        if self.model_name and not self.manager:
-            self._acquire_manager()
+            url = f"{self.base_url}{endpoint}"
+            response = requests.get(url, params=params, timeout=60)
+            response.raise_for_status()
+            return response
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Failed to communicate with Diffusers server at {url}.")
+            raise RuntimeError("Communication with the Diffusers server failed.") from e
 
     def unload_model(self):
-        if self.manager:
-            ASCIIColors.info(f"Binding instance releasing manager for '{self.manager.config['model_name']}'.")
-            self.registry.release_manager(self.manager.config)
-            self.manager = None
-
-    def generate_image(self, prompt: str, negative_prompt: str = "", width: int|None = None, height: int|None = None, **kwargs) -> bytes:
-        if not self.model_name:
-            raise RuntimeError("No model_name configured. Please select a model in settings.")
-        if not self.manager:
-            self._acquire_manager()
-        generator = self._prepare_seed(kwargs)
-        pipeline_args = {
-            "prompt": prompt,
-            "negative_prompt": negative_prompt or self.config.get("negative_prompt", ""),
-            "width": width if width is not None else self.config.get("width", 512),
-            "height": height if height is not None else self.config.get("height", 512),
-            "num_inference_steps": kwargs.pop("num_inference_steps", self.config.get("num_inference_steps",25)),
-            "guidance_scale": kwargs.pop("guidance_scale", self.config.get("guidance_scale",6.5)),
-            "generator": generator
-        }
-        pipeline_args.update(kwargs)
-        future = Future()
-        self.manager.queue.put((future, "text2image", pipeline_args))
-        ASCIIColors.info(f"Job (t2i) '{prompt[:50]}...' queued.")
-        try:
-            return future.result()
-        except Exception as e:
-            raise Exception(f"Image generation failed: {e}") from e
-
-    def _encode_image_to_latents(self, pil: Image.Image, width: int, height: int) -> Tuple[torch.Tensor, Tuple[int,int]]:
-        pil = pil.convert("RGB").resize((width, height))
-        with self.manager.lock:
-            self.manager._load_pipeline_for_task("text2image")
-            vae = self.manager.pipeline.vae
-        img = torch.from_numpy(torch.ByteTensor(bytearray(pil.tobytes())).numpy()).float()  # not efficient but avoids np dep
-        img = img.view(pil.height, pil.width, 3).permute(2,0,1).unsqueeze(0) / 255.0
-        img = (img * 2.0) - 1.0
-        img = img.to(self.config["device"], dtype=getattr(torch, self.config["torch_dtype_str"]))
-        with torch.no_grad():
-            posterior = vae.encode(img)
-            latents = posterior.latent_dist.sample()
-            sf = getattr(vae.config, "scaling_factor", 0.18215)
-            latents = latents * sf
-        return latents, (pil.width, pil.height)
-
-    def edit_image(self,
-                   images: Union[str, List[str]],
-                   prompt: str,
-                   negative_prompt: Optional[str] = "",
-                   mask: Optional[str] = None,
-                   width: Optional[int] = None,
-                   height: Optional[int] = None,
-                   **kwargs) -> bytes:
-        if not self.model_name:
-            raise RuntimeError("No model_name configured. Please select a model in settings.")
-        if not self.manager:
-            self._acquire_manager()
-        imgs = [images] if isinstance(images, str) else list(images)
-        pil_images = [self._decode_image_input(s) for s in imgs]
-        out_w = width if width is not None else self.config["width"]
-        out_h = height if height is not None else self.config["height"]
-        generator = self._prepare_seed(kwargs)
-        steps = kwargs.pop("num_inference_steps", self.config["num_inference_steps"])
-        guidance = kwargs.pop("guidance_scale", self.config["guidance_scale"])
-        if mask is not None and len(pil_images) == 1:
-            try:
-                mask_img = self._decode_image_input(mask).convert("L")
-            except Exception as e:
-                raise ValueError(f"Failed to decode mask image: {e}") from e
-            pipeline_args = {
-                "image": pil_images[0],
-                "mask_image": mask_img,
-                "prompt": prompt,
-                "negative_prompt": negative_prompt or None,
-                "width": out_w,
-                "height": out_h,
-                "num_inference_steps": steps,
-                "guidance_scale": guidance,
-                "generator": generator
-            }
-            pipeline_args.update(kwargs)
-            future = Future()
-            self.manager.queue.put((future, "inpainting", pipeline_args))
-            ASCIIColors.info("Job (inpaint) queued.")
-            return future.result()
+        ASCIIColors.info("Requesting server to unload the current model...")
         try:
-            pipeline_args = {
-                "image": pil_images if len(pil_images) > 1 else pil_images[0],
-                "prompt": prompt,
-                "negative_prompt": negative_prompt or None,
-                "strength": kwargs.pop("strength", 0.6),
-                "width": out_w,
-                "height": out_h,
-                "num_inference_steps": steps,
-                "guidance_scale": guidance,
-                "generator": generator
-            }
-            pipeline_args.update(kwargs)
-            future = Future()
-            self.manager.queue.put((future, "image2image", pipeline_args))
-            ASCIIColors.info("Job (i2i) queued.")
-            return future.result()
-        except Exception:
-            pass
-        try:
-            base = pil_images[0]
-            latents, _ = self._encode_image_to_latents(base, out_w, out_h)
-            pipeline_args = {
-                "prompt": prompt,
-                "negative_prompt": negative_prompt or None,
-                "latents": latents,
-                "num_inference_steps": steps,
-                "guidance_scale": guidance,
-                "generator": generator,
-                "width": out_w,
-                "height": out_h
-            }
-            pipeline_args.update(kwargs)
-            future = Future()
-            self.manager.queue.put((future, "text2image", pipeline_args))
-            ASCIIColors.info("Job (t2i with init latents) queued.")
-            return future.result()
+            self._post_json_request("/unload_model")
         except Exception as e:
-            raise Exception(f"Image edit failed: {e}") from e
+            ASCIIColors.warning(f"Could not send unload request to server: {e}")
+        pass
+
+    def generate_image(self, prompt: str, negative_prompt: str = "", **kwargs) -> bytes:
+        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": params
+        })
+        return response.content
+
+    def edit_image(self, images: Union[str, List[str], "Image.Image", List["Image.Image"]], prompt: str, **kwargs) -> bytes:
+        images_b64 = []
+        if not isinstance(images, list):
+            images = [images]
+
+
+        for img in images:
+            # Case 1: Input is a PIL Image object
+            if hasattr(img, 'save'):
+                buffer = BytesIO()
+                img.save(buffer, format="PNG")
+                b64_string = base64.b64encode(buffer.getvalue()).decode('utf-8')
+                images_b64.append(b64_string)
+            
+            # Case 2: Input is a string (could be path or already base64)
+            elif isinstance(img, str):
+                try:
+                    b64_string = img.split(";base64,")[1] if ";base64," in img else img
+                    base64.b64decode(b64_string) # Validate
+                    images_b64.append(b64_string)
+                except Exception:
+                    ASCIIColors.warning(f"Warning: A string input was not a valid file path or base64. Skipping.")
+            else:
+                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 params and params["mask"]:
+            params["mask_image"] = params.pop("mask")
+
+        json_payload = {
+            "prompt": prompt,
+            "images_b64": images_b64,
+            "params": params
+        }
+        response = self._post_json_request("/edit_image", data=json_payload)
+        return response.content
+
+    def list_models(self) -> List[Dict[str, Any]]:
+        return self._get_request("/list_models").json()
 
     def list_local_models(self) -> List[str]:
-        if not self.models_path.exists():
-            return []
-        folders = [
-            d.name for d in self.models_path.iterdir()
-            if d.is_dir() and ((d / "model_index.json").exists() or (d / "unet" / "config.json").exists())
-        ]
-        safetensors = self.list_safetensor_models()
-        return sorted(folders + safetensors)
+        return self._get_request("/list_local_models").json()
 
     def list_available_models(self) -> List[str]:
-        discoverable = [m['model_name'] for m in self.listModels()]
-        local_models = self.list_local_models()
-        return sorted(list(set(local_models + discoverable)))
+        return self._get_request("/list_available_models").json()
 
     def list_services(self, **kwargs) -> List[Dict[str, str]]:
-        models = self.list_available_models()
-        local_models = self.list_local_models()
-        if not models:
-            return [{"name": "diffusers_no_models", "caption": "No models found", "help": f"Place models in '{self.models_path.resolve()}'."}]
-        services = []
-        for m in models:
-            help_text = "Hugging Face model ID"
-            if m in local_models:
-                help_text = f"Local model from: {self.models_path.resolve()}"
-            elif m in CIVITAI_MODELS:
-                help_text = f"Civitai model (downloads as {CIVITAI_MODELS[m]['filename']})"
-            services.append({"name": m, "caption": f"Diffusers: {m}", "help": help_text})
-        return services
+        return self._get_request("/list_models").json()
 
     def get_settings(self, **kwargs) -> List[Dict[str, Any]]:
-        available_models = self.list_available_models()
-        return [
-            {"name": "model_name", "type": "str", "value": self.model_name, "description": "Local, Civitai, or Hugging Face model.", "options": available_models},
-            {"name": "unload_inactive_model_after", "type": "int", "value": self.config["unload_inactive_model_after"], "description": "Unload model after X seconds of inactivity (0 to disable)."},
-            {"name": "device", "type": "str", "value": self.config["device"], "description": f"Inference device. Resolved: {self.config['device']}", "options": ["auto","cuda","mps","cpu"]},
-            {"name": "torch_dtype_str", "type": "str", "value": self.config["torch_dtype_str"], "description": f"Torch dtype. Resolved: {self.config['torch_dtype_str']}", "options": ["auto","float16","bfloat16","float32"]},
-            {"name": "hf_variant", "type": "str", "value": self.config["hf_variant"], "description": "HF model variant (e.g., 'fp16')."},
-            {"name": "use_safetensors", "type": "bool", "value": self.config["use_safetensors"], "description": "Prefer .safetensors when loading from Hugging Face."},
-            {"name": "scheduler_name", "type": "str", "value": self.config["scheduler_name"], "description": "Scheduler for diffusion.", "options": list(SCHEDULER_MAPPING.keys())},
-            {"name": "safety_checker_on", "type": "bool", "value": self.config["safety_checker_on"], "description": "Enable the safety checker."},
-            {"name": "enable_cpu_offload", "type": "bool", "value": self.config["enable_cpu_offload"], "description": "Enable model CPU offload (saves VRAM, slower)."},
-            {"name": "enable_sequential_cpu_offload", "type": "bool", "value": self.config["enable_sequential_cpu_offload"], "description": "Enable sequential CPU offload."},
-            {"name": "enable_xformers", "type": "bool", "value": self.config["enable_xformers"], "description": "Enable xFormers memory efficient attention."},
-            {"name": "width", "type": "int", "value": self.config["width"], "description": "Default image width."},
-            {"name": "height", "type": "int", "value": self.config["height"], "description": "Default image height."},
-            {"name": "num_inference_steps", "type": "int", "value": self.config["num_inference_steps"], "description": "Default inference steps."},
-            {"name": "guidance_scale", "type": "float", "value": self.config["guidance_scale"], "description": "Default guidance scale (CFG)."},
-            {"name": "seed", "type": "int", "value": self.config["seed"], "description": "Default seed (-1 for random)."},
-            {"name": "hf_token", "type": "str", "value": self.config["hf_token"], "description": "HF API token (for private/gated models).", "is_secret": True},
-            {"name": "hf_cache_path", "type": "str", "value": self.config["hf_cache_path"], "description": "Path to HF cache."},
-            {"name": "local_files_only", "type": "bool", "value": self.config["local_files_only"], "description": "Do not download from Hugging Face."}
-        ]
+        # The server holds the state, so we fetch it.
+        return self._get_request("/get_settings").json()
 
     def set_settings(self, settings: Union[Dict[str, Any], List[Dict[str, Any]]], **kwargs) -> bool:
-        parsed = settings if isinstance(settings, dict) else {i["name"]: i["value"] for i in settings if "name" in i and "value" in i}
-        critical_keys = self.registry._get_critical_keys()
-        needs_swap = False
-        for key, value in parsed.items():
-            if self.config.get(key) != value:
-                ASCIIColors.info(f"Setting '{key}' changed to: {value}")
-                self.config[key] = value
-                if key == "model_name":
-                    self.model_name = value
-                if key in critical_keys:
-                    needs_swap = True
-        if needs_swap and self.model_name:
-            ASCIIColors.info("Critical settings changed. Swapping model manager...")
-            self._resolve_device_and_dtype()
-            self._acquire_manager()
-        if not needs_swap and self.manager:
-            self.manager.config.update(parsed)
-            if 'scheduler_name' in parsed and self.manager.pipeline:
-                with self.manager.lock:
-                    self.manager._set_scheduler()
-        return True
+        # Normalize settings from list of dicts to a single dict if needed
+        parsed_settings = settings if isinstance(settings, dict) else {s["name"]: s["value"] for s in settings if "name" in s and "value" in s}
+        response = self._post_json_request("/set_settings", data=parsed_settings)
+        return response.json().get("success", False)
+
+    def ps(self) -> List[dict]:
+        try:
+            return self._get_request("/ps").json()
+        except Exception:
+            return [{"error": "Could not connect to server to get process status."}]
+
+    def pull_model(self, model_name: str, local_name: Optional[str] = None, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Pulls a model from Hugging Face or URL via the server.
+        """
+        payload = {}
+        if model_name.startswith("http") and "huggingface.co" not in model_name:
+             # Assume direct file URL if not huggingface repo url (roughly)
+             if model_name.endswith(".safetensors"):
+                payload["safetensors_url"] = model_name
+             else:
+                payload["hf_id"] = model_name 
+        else:
+             # Clean up URL if provided as https://huggingface.co/publisher/model
+             if "huggingface.co/" in model_name:
+                 model_name = model_name.split("huggingface.co/")[-1]
+             payload["hf_id"] = model_name
+        
+        if local_name:
+            payload["local_name"] = local_name
+            
+        try:
+            if progress_callback:
+                progress_callback({"status": "starting", "message": f"Sending pull request for {model_name}..."})
+            
+            ASCIIColors.info(f"Sending pull request for {model_name}...")
+            # Use a very long timeout as downloads can be huge (GBs)
+            response = requests.post(f"{self.base_url}/pull_model", json=payload, timeout=7200) 
+            response.raise_for_status()
+            
+            msg = "Model pulled successfully."
+            ASCIIColors.success(msg)
+            if progress_callback:
+                progress_callback({"status": "success", "message": msg, "completed": 100, "total": 100})
+            return {"status": True, "message": msg}
+        except Exception as e:
+            error_msg = f"Failed to pull model: {e}"
+            if hasattr(e, 'response') and e.response:
+                 error_msg += f" Server response: {e.response.text}"
+            ASCIIColors.error(error_msg)
+            if progress_callback:
+                progress_callback({"status": "error", "message": error_msg})
+            return {"status": False, "message": error_msg}
+
+    def upgrade_diffusers(self, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Upgrades the diffusers library in the virtual environment.
+        """
+        try:
+            if progress_callback:
+                progress_callback({"status": "starting", "message": "Upgrading diffusers..."})
+
+            ASCIIColors.info("Upgrading diffusers from GitHub...")
+            if sys.platform == "win32":
+                python_executable = self.venv_dir / "Scripts" / "python.exe"
+            else:
+                python_executable = self.venv_dir / "bin" / "python"
+
+            subprocess.check_call([
+                str(python_executable), "-m", "pip", "install", "--upgrade", 
+                "git+https://github.com/huggingface/diffusers.git"
+            ])
+            msg = "Diffusers upgraded successfully."
+            ASCIIColors.success(msg)
+            ASCIIColors.info("Please restart the application/server to apply changes.")
+            
+            if progress_callback:
+                progress_callback({"status": "success", "message": msg})
+            return {"status": True, "message": msg}
+        except Exception as e:
+            error_msg = f"Failed to upgrade diffusers: {e}"
+            ASCIIColors.error(error_msg)
+            if progress_callback:
+                progress_callback({"status": "error", "message": error_msg})
+            return {"status": False, "message": error_msg}
 
     def __del__(self):
-        self.unload_model()
-
-if __name__ == '__main__':
-    ASCIIColors.magenta("--- Diffusers TTI Binding Test ---")
-    if not DIFFUSERS_AVAILABLE:
-        ASCIIColors.error("Diffusers not available. Cannot run test.")
-        exit(1)
-    temp_paths_dir = Path(__file__).parent / "tmp"
-    temp_models_path = temp_paths_dir / "models"
-    if temp_paths_dir.exists():
-        shutil.rmtree(temp_paths_dir)
-    temp_models_path.mkdir(parents=True, exist_ok=True)
-    try:
-        ASCIIColors.cyan("\n--- Test: Loading a small HF model ---")
-        cfg = {"models_path": str(temp_models_path), "model_name": "hf-internal-testing/tiny-stable-diffusion-torch"}
-        binding = DiffusersTTIBinding_Impl(**cfg)
-        img_bytes = binding.generate_image("a tiny robot", width=64, height=64, num_inference_steps=2)
-        assert len(img_bytes) > 1000
-        ASCIIColors.green("HF t2i generation OK.")
-        del binding
-        time.sleep(0.1)
-    except Exception as e:
-        trace_exception(e)
-        ASCIIColors.error(f"Diffusers binding test failed: {e}")
-    finally:
-        ASCIIColors.cyan("\nCleaning up temporary directories...")
-        if temp_paths_dir.exists():
-            shutil.rmtree(temp_paths_dir)
-        ASCIIColors.magenta("--- Diffusers TTI Binding Test Finished ---")
+        # The client destructor does not stop the server,
+        # as it is a shared resource for all worker processes.
+        pass