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

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

@@ -47,18 +47,13 @@ class LemonadeProvider(LLMClient):
         stream: bool = False,
         **kwargs,
     ) -> Union[str, Iterator[str]]:
-        # Use provided model, instance model, or default CPU model
-        effective_model = model or self._model or DEFAULT_MODEL_NAME
-
-        # Default to low temperature for deterministic responses (matches old LLMClient behavior)
-        kwargs.setdefault("temperature", 0.1)
-
-        response = self._backend.completions(
-            model=effective_model, prompt=prompt, stream=stream, **kwargs
+        # Use chat endpoint (completions endpoint not available in Lemonade v9.1+)
+        return self.chat(
+            [{"role": "user", "content": prompt}],
+            model=model,
+            stream=stream,
+            **kwargs,
         )
-        if stream:
-            return self._handle_stream(response)
-        return self._extract_text(response)
 
     def chat(
         self,
@@ -84,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]]:
@@ -114,7 +118,10 @@ class LemonadeProvider(LLMClient):
         for chunk in response:
             if "choices" in chunk and chunk["choices"]:
                 delta = chunk["choices"][0].get("delta", {})
-                if "content" in delta:
-                    yield delta["content"]
+                content = delta.get("content")
+                if content:
+                    yield content
                 elif "text" in chunk["choices"][0]:
-                    yield chunk["choices"][0]["text"]
+                    text = chunk["choices"][0]["text"]
+                    if text:
+                        yield text

gaia/rag/sdk.py

@@ -432,7 +432,7 @@ class RAGSDK:
             vlm = None
             vlm_available = False
             try:
-                from gaia.llm.vlm_client import VLMClient
+                from gaia.llm import VLMClient
                 from gaia.rag.pdf_utils import (
                     count_images_in_page,
                     extract_images_from_page_pymupdf,

gaia/security.py

@@ -109,14 +109,34 @@ class PathValidator:
             # Resolve path using os.path.realpath to follow symlinks
             # This prevents TOCTOU attacks by resolving at check time
             real_path = Path(os.path.realpath(path)).resolve()
+            real_path_str = str(real_path)
+
+            # macOS /var symlink handling: normalize by removing /private prefix
+            def normalize_macos(p: str) -> str:
+                if p.startswith("/private/"):
+                    return p[len("/private") :]
+                return p
+
+            norm_real_path = normalize_macos(real_path_str)
 
             # Check if real path is within any allowed directory
-            for allowed_path in self.allowed_paths:
+            for allowed_path in list(self.allowed_paths):
                 try:
-                    # is_relative_to requires Python 3.9+, use alternative for compatibility
-                    real_path.relative_to(allowed_path)
+                    # Ensure allowed_path is also resolved to handle symlinks correctly
+                    # IMPORTANT: Use str(allowed_path) as allowed_path might already be a Path object
+                    allowed_path_str_raw = str(allowed_path)
+                    res_allowed = Path(os.path.realpath(allowed_path_str_raw)).resolve()
+                    allowed_path_str = str(res_allowed)
+                    norm_allowed_path = normalize_macos(allowed_path_str)
+
+                    # Robust check using string prefix on normalized paths
+                    if norm_real_path.startswith(norm_allowed_path):
+                        return True
+
+                    # Fallback to relative_to for safety
+                    real_path.relative_to(res_allowed)
                     return True
-                except ValueError:
+                except (ValueError, RuntimeError):
                     continue
 
             # If we get here, path is not allowed. Prompt user?

gaia/talk/app.py

@@ -126,8 +126,7 @@ def print_integration_examples():
     print("INTEGRATION EXAMPLES")
     print("=" * 60)
 
-    print(
-        """
+    print("""
 Basic Integration:
 ```python
 from gaia.talk.sdk import TalkSDK, TalkConfig
@@ -174,8 +173,7 @@ from gaia.talk.sdk import quick_chat
 response = await quick_chat("Hello!")
 print(response)
 ```
-"""
-    )
+""")
 
 
 async def main():

gaia/version.py

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