amd-gaia 0.15.2__py3-none-any.whl → 0.15.3__py3-none-any.whl

gaia/installer/lemonade_installer.py

@@ -386,13 +386,46 @@ class LemonadeInstaller:
             if silent:
                 cmd.extend(["/qn", "/norestart"])
 
+            log_dir = Path.home() / ".cache" / "gaia" / "installer"
+            log_dir.mkdir(parents=True, exist_ok=True)
+            msi_log = log_dir / "msi_install.log"
+            cmd.extend(["/l*v", str(msi_log)])  # Verbose logging to file
+
             log.debug(f"Running: {' '.join(cmd)}")
 
+            # Check for other msiexec processes before starting (helps diagnose hangs)
+            try:
+                check_result = subprocess.run(
+                    ["tasklist", "/FI", "IMAGENAME eq msiexec.exe", "/NH"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                    check=False,
+                )
+                if (
+                    check_result.returncode == 0
+                    and "msiexec.exe" in check_result.stdout
+                ):
+                    msi_count = check_result.stdout.count("msiexec.exe")
+                    log.warning(
+                        f"Found {msi_count} existing msiexec process(es) - installation may be blocked"
+                    )
+            except Exception:
+                pass  # Skip check if tasklist fails
+
+            if silent:
+                self._print_status(
+                    "Running silent MSI installer (should complete in ~10 seconds)..."
+                )
+            else:
+                self._print_status("Running MSI installer...")
+
+            # MSI should install in 10-15 seconds, timeout after 60 seconds (indicates stuck process)
             result = subprocess.run(
                 cmd,
                 capture_output=True,
                 text=True,
-                timeout=300,  # 5 minute timeout
+                timeout=60,  # 60 second timeout (should complete in ~10s)
                 check=False,
             )
 
@@ -418,7 +451,32 @@ class LemonadeInstaller:
                 )
 
         except subprocess.TimeoutExpired:
-            return InstallResult(success=False, error="Installation timed out")
+            # Print MSI log to help diagnose the hang
+            error_msg = "Installation timed out (expected ~10s, hung for 60s)"
+            try:
+                if msi_log.exists():
+                    self._print_status(f"MSI log file: {msi_log}")
+                    log_content = msi_log.read_text(encoding="utf-16", errors="ignore")
+                    # Print last 100 lines of log
+                    log_lines = log_content.split("\n")
+                    relevant_lines = log_lines[-100:]
+                    log.error("=== MSI Install Log (last 100 lines) ===")
+                    for line in relevant_lines:
+                        log.error(line)
+                    log.error("=== End MSI Install Log ===")
+
+                    # Also print to console
+                    if self.console:
+                        self.console.print(
+                            "\n   [red]MSI Install Log (last 50 lines):[/red]"
+                        )
+                        for line in relevant_lines[-50:]:
+                            if line.strip():
+                                self.console.print(f"   [dim]{line}[/dim]")
+            except Exception as e:
+                log.debug(f"Could not read MSI log: {e}")
+
+            return InstallResult(success=False, error=error_msg)
         except FileNotFoundError:
             return InstallResult(success=False, error="msiexec not found")
         except Exception as e:
@@ -533,9 +591,10 @@ class LemonadeInstaller:
             installed_version = info.version.lstrip("v")
 
             # Create installer for the installed version (not target version)
+            # Use minimal=True (lemonade-server-minimal.msi exists for all versions)
             # Pass console to child installer for consistent output
             uninstall_installer = LemonadeInstaller(
-                target_version=installed_version, console=self.console
+                target_version=installed_version, minimal=True, console=self.console
             )
 
             # Download the MSI matching the installed version

gaia/llm/lemonade_client.py

@@ -1601,6 +1601,139 @@ class LemonadeClient:
             self.log.error(f"Error generating embeddings: {str(e)}")
             raise LemonadeClientError(f"Error generating embeddings: {str(e)}")
 
+    # =========================================================================
+    # Image Generation (Stable Diffusion)
+    # =========================================================================
+
+    # Supported SD configurations
+    SD_MODELS = ["SD-1.5", "SD-Turbo", "SDXL-Base-1.0", "SDXL-Turbo"]
+    SD_SIZES = ["512x512", "768x768", "1024x1024"]
+
+    # Model-specific defaults
+    SD_MODEL_DEFAULTS = {
+        "SD-1.5": {"steps": 20, "cfg_scale": 7.5, "size": "512x512"},
+        "SD-Turbo": {"steps": 4, "cfg_scale": 1.0, "size": "512x512"},
+        "SDXL-Base-1.0": {"steps": 20, "cfg_scale": 7.5, "size": "1024x1024"},
+        "SDXL-Turbo": {"steps": 4, "cfg_scale": 1.0, "size": "512x512"},
+    }
+
+    def generate_image(
+        self,
+        prompt: str,
+        model: str = "SDXL-Turbo",
+        size: Optional[str] = None,
+        steps: Optional[int] = None,
+        cfg_scale: Optional[float] = None,
+        seed: Optional[int] = None,
+        timeout: int = 300,
+    ) -> Dict[str, Any]:
+        """
+        Generate an image from a text prompt using Stable Diffusion.
+
+        Args:
+            prompt: Text description of the image to generate
+            model: SD model - SD-1.5, SD-Turbo, SDXL-Base-1.0 (photorealistic), SDXL-Turbo
+            size: Image dimensions (auto-selected if None, or 512x512, 768x768, 1024x1024)
+            steps: Inference steps (auto-selected if None: Turbo=4, Base=20)
+            cfg_scale: CFG scale (auto-selected if None: Turbo=1.0, Base=7.5)
+            seed: Random seed for reproducibility (optional)
+            timeout: Request timeout in seconds (default: 300 for slower Base models)
+
+        Returns:
+            Dict with 'data' containing list of generated images in b64_json format
+
+        Raises:
+            LemonadeClientError: If generation fails or invalid parameters
+
+        Example:
+            # Photorealistic with SDXL-Base-1.0 (auto-settings)
+            result = client.generate_image(
+                prompt="a sunset over mountains, golden hour, photorealistic",
+                model="SDXL-Base-1.0"
+            )
+
+            # Fast stylized with SDXL-Turbo
+            result = client.generate_image(
+                prompt="cyberpunk city",
+                model="SDXL-Turbo"
+            )
+        """
+        # Validate model
+        if model not in self.SD_MODELS:
+            raise LemonadeClientError(
+                f"Invalid model '{model}'. Choose from: {self.SD_MODELS}"
+            )
+
+        # Apply model-specific defaults
+        defaults = self.SD_MODEL_DEFAULTS.get(model, {})
+        size = size or defaults.get("size", "512x512")
+        steps = steps if steps is not None else defaults.get("steps", 20)
+        cfg_scale = (
+            cfg_scale if cfg_scale is not None else defaults.get("cfg_scale", 7.5)
+        )
+
+        # Validate size
+        if size not in self.SD_SIZES:
+            raise LemonadeClientError(
+                f"Invalid size '{size}'. Choose from: {self.SD_SIZES}"
+            )
+
+        try:
+            # Generate random seed if not provided for varied results
+            import random
+
+            if seed is None:
+                seed = random.randint(0, 2**32 - 1)
+
+            payload = {
+                "prompt": prompt,
+                "model": model,
+                "size": size,
+                "n": 1,
+                "response_format": "b64_json",
+                "cfg_scale": cfg_scale,
+                "steps": steps,
+                "seed": seed,
+            }
+
+            self.log.info(
+                f"Generating image: model={model}, size={size}, steps={steps}, cfg={cfg_scale}"
+            )
+            url = f"{self.base_url}/images/generations"
+            response = self._send_request("POST", url, data=payload, timeout=timeout)
+
+            return response
+
+        except LemonadeClientError:
+            raise
+        except Exception as e:
+            self.log.error(f"Error generating image: {str(e)}")
+            raise LemonadeClientError(f"Error generating image: {str(e)}")
+
+    def list_sd_models(self) -> List[Dict[str, Any]]:
+        """
+        List available Stable Diffusion models from the server.
+
+        Returns:
+            List of SD model info dicts with id, labels, and image_defaults
+
+        Example:
+            sd_models = client.list_sd_models()
+            for m in sd_models:
+                print(f"{m['id']}: {m.get('image_defaults', {})}")
+        """
+        try:
+            models = self.list_models()
+            sd_models = [
+                m
+                for m in models.get("data", [])
+                if m.get("id") in self.SD_MODELS or "image" in m.get("labels", [])
+            ]
+            return sd_models
+        except Exception as e:
+            self.log.error(f"Error listing SD models: {str(e)}")
+            raise LemonadeClientError(f"Error listing SD models: {str(e)}")
+
     def list_models(self, show_all: bool = False) -> Dict[str, Any]:
         """
         List available models from the server.
@@ -2184,6 +2317,8 @@ class LemonadeClient:
         auto_download: bool = False,
         _download_timeout: int = 7200,  # Reserved for future use
         llamacpp_args: Optional[str] = None,
+        ctx_size: Optional[int] = None,
+        save_options: bool = False,
         prompt: bool = True,
     ) -> Dict[str, Any]:
         """
@@ -2203,6 +2338,10 @@ class LemonadeClient:
                              Large models can be 100GB+ and take hours to download
             llamacpp_args: Optional llama.cpp arguments (e.g., "--ubatch-size 2048").
                           Used to configure model loading parameters like batch sizes.
+            ctx_size: Context size for the model in tokens (e.g., 8192, 32768).
+                     Overrides the default value for this model.
+            save_options: If True, persists ctx_size and llamacpp_args to config file.
+                         Model will use these settings on future loads.
             prompt: If True, prompt user before downloading (default: True).
                    Set to False to download automatically without user confirmation.
 
@@ -2219,6 +2358,10 @@ class LemonadeClient:
         request_data = {"model_name": model_name}
         if llamacpp_args:
             request_data["llamacpp_args"] = llamacpp_args
+        if ctx_size is not None:
+            request_data["ctx_size"] = ctx_size
+        if save_options:
+            request_data["save_options"] = save_options
         url = f"{self.base_url}/load"
 
         try:

gaia/llm/lemonade_manager.py

@@ -203,16 +203,45 @@ class LemonadeManager:
                     )
                     return True
                 else:
-                    # Context size insufficient - warn and continue
-                    cls._log.warning(
-                        f"Lemonade running with {cls._context_size} tokens, "
-                        f"but {min_context_size} requested. "
-                        f"Restart with: lemonade-server serve --ctx-size {min_context_size}"
-                    )
-                    if not quiet:
-                        cls.print_context_message(
-                            cls._context_size, min_context_size, MessageType.WARNING
+                    # Context size may be cached from before models were loaded
+                    # Re-check current status to see if models are loaded now
+                    try:
+                        client = LemonadeClient(
+                            host=host,
+                            port=port,
+                            keep_alive=True,
+                            verbose=not quiet,
                         )
+                        status = client.get_status()
+                        # Update cached context size
+                        cls._context_size = status.context_size or 0
+
+                        # Only warn if LLM models are loaded AND context is insufficient
+                        # SD models don't have context size, only LLM models do
+                        llm_models_loaded = any(
+                            "image" not in model.get("labels", [])
+                            for model in status.loaded_models
+                        )
+
+                        # Only warn if context_size is non-zero (0 means no model loaded or still loading)
+                        if (
+                            cls._context_size > 0
+                            and cls._context_size < min_context_size
+                            and llm_models_loaded
+                        ):
+                            cls._log.warning(
+                                f"Lemonade running with {cls._context_size} tokens, "
+                                f"but {min_context_size} requested. "
+                                f"Restart with: lemonade-server serve --ctx-size {min_context_size}"
+                            )
+                            if not quiet:
+                                cls.print_context_message(
+                                    cls._context_size,
+                                    min_context_size,
+                                    MessageType.WARNING,
+                                )
+                    except Exception as e:
+                        cls._log.debug(f"Failed to re-check status: {e}")
                     return True
 
             cls._log.debug(f"Initializing Lemonade (min context: {min_context_size})")
@@ -246,8 +275,23 @@ class LemonadeManager:
                     f"(context: {cls._context_size} tokens)"
                 )
 
-                # Verify context size - warn if insufficient
-                if cls._context_size < min_context_size:
+                # Verify context size - only warn if insufficient AND LLM models are loaded
+                # SD models don't have context size, only LLM models do
+                # Check if any loaded models are LLMs (not SD models with "image" label)
+                llm_models_loaded = any(
+                    "image" not in model.get("labels", [])
+                    for model in status.loaded_models
+                )
+
+                # Only warn if:
+                # 1. Context size is non-zero (0 means no model loaded or model still loading)
+                # 2. Context size is less than required
+                # 3. LLM models are loaded (SD models don't have context size)
+                if (
+                    cls._context_size > 0
+                    and cls._context_size < min_context_size
+                    and llm_models_loaded
+                ):
                     cls._log.warning(
                         f"Context size {cls._context_size} is less than "
                         f"requested {min_context_size}. Some features may not work correctly."

gaia/llm/providers/lemonade.py

@@ -79,6 +79,15 @@ class LemonadeProvider(LLMClient):
         )
         if stream:
             return self._handle_stream(response)
+
+        # Handle error responses gracefully
+        if not isinstance(response, dict) or "choices" not in response:
+            error_msg = f"Unexpected response format from Lemonade Server: {response}"
+            raise ValueError(error_msg)
+
+        if not response["choices"] or len(response["choices"]) == 0:
+            raise ValueError("Empty choices in response from Lemonade Server")
+
         return response["choices"][0]["message"]["content"]
 
     def embed(self, texts: list[str], **kwargs) -> list[list[float]]:

gaia/version.py

@@ -6,10 +6,10 @@ import os
 import subprocess
 from importlib.metadata import version as get_package_version_metadata
 
-__version__ = "0.15.2"
+__version__ = "0.15.3"
 
 # Lemonade version used across CI and installer
-LEMONADE_VERSION = "9.1.4"
+LEMONADE_VERSION = "9.2.0"
 
 
 def get_package_version() -> str: