amd-gaia 0.14.2__py3-none-any.whl → 0.14.3__py3-none-any.whl

gaia/database/mixin.py

@@ -0,0 +1,290 @@
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+"""SQLite database mixin for GAIA agents."""
+
+import logging
+import sqlite3
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseMixin:
+    """
+    Mixin providing SQLite database access for GAIA agents.
+
+    A lean, zero-dependency mixin that uses Python's built-in sqlite3 module.
+
+    Example:
+        class MyAgent(Agent, DatabaseMixin):
+            def __init__(self, **kwargs):
+                super().__init__(**kwargs)
+                self.init_db("data/app.db")
+
+                if not self.table_exists("items"):
+                    self.execute('''
+                        CREATE TABLE items (
+                            id INTEGER PRIMARY KEY,
+                            name TEXT NOT NULL
+                        )
+                    ''')
+
+            def _register_tools(self):
+                @tool
+                def add_item(name: str) -> dict:
+                    item_id = self.insert("items", {"name": name})
+                    return {"id": item_id}
+    """
+
+    _db: Optional[sqlite3.Connection] = None
+    _in_tx: bool = False
+
+    def init_db(self, path: str = ":memory:") -> None:
+        """
+        Initialize SQLite database.
+
+        Args:
+            path: Database file path, or ":memory:" for in-memory database.
+                  Parent directories are created automatically.
+
+        Example:
+            self.init_db("data/myagent.db")  # File-based
+            self.init_db()                    # In-memory (for testing)
+        """
+        if self._db:
+            self.close_db()
+
+        if path != ":memory:":
+            Path(path).parent.mkdir(parents=True, exist_ok=True)
+
+        self._db = sqlite3.connect(path, check_same_thread=False)
+        self._db.row_factory = sqlite3.Row
+        self._db.execute("PRAGMA foreign_keys = ON")
+        self._in_tx = False
+        logger.info("Database initialized: %s", path)
+
+    def close_db(self) -> None:
+        """
+        Close database connection.
+
+        Safe to call multiple times.
+        """
+        if self._db:
+            self._db.close()
+            self._db = None
+            self._in_tx = False
+
+    @property
+    def db_ready(self) -> bool:
+        """True if database is initialized."""
+        return self._db is not None
+
+    def _require_db(self) -> None:
+        """Raise RuntimeError if database not initialized."""
+        if not self._db:
+            raise RuntimeError("Database not initialized. Call init_db() first.")
+
+    def query(
+        self,
+        sql: str,
+        params: Optional[Dict[str, Any]] = None,
+        one: bool = False,
+    ) -> Union[List[Dict[str, Any]], Optional[Dict[str, Any]]]:
+        """
+        Execute SELECT query and return results as dicts.
+
+        Args:
+            sql: SQL query with :param_name placeholders
+            params: Dictionary of parameter values
+            one: If True, return single row dict or None
+
+        Returns:
+            List of row dicts, or single dict/None if one=True
+
+        Example:
+            # Get all
+            users = self.query("SELECT * FROM users")
+
+            # Get one
+            user = self.query(
+                "SELECT * FROM users WHERE id = :id",
+                {"id": 42},
+                one=True
+            )
+        """
+        self._require_db()
+        cursor = self._db.execute(sql, params or {})
+        rows = [dict(row) for row in cursor.fetchall()]
+        if one:
+            return rows[0] if rows else None
+        return rows
+
+    def insert(self, table: str, data: Dict[str, Any]) -> int:
+        """
+        Insert a row and return its ID.
+
+        Args:
+            table: Table name
+            data: Column-value dictionary
+
+        Returns:
+            The inserted row's ID (lastrowid)
+
+        Example:
+            user_id = self.insert("users", {
+                "name": "Alice",
+                "email": "alice@example.com"
+            })
+        """
+        self._require_db()
+        cols = ", ".join(data.keys())
+        placeholders = ", ".join(f":{k}" for k in data.keys())
+        sql = f"INSERT INTO {table} ({cols}) VALUES ({placeholders})"
+        cursor = self._db.execute(sql, data)
+        if not self._in_tx:
+            self._db.commit()
+        return cursor.lastrowid
+
+    def update(
+        self,
+        table: str,
+        data: Dict[str, Any],
+        where: str,
+        params: Dict[str, Any],
+    ) -> int:
+        """
+        Update rows matching condition and return affected count.
+
+        Args:
+            table: Table name
+            data: Column-value dictionary to update
+            where: WHERE clause with :param placeholders (without WHERE keyword)
+            params: Parameters for WHERE clause
+
+        Returns:
+            Number of rows affected
+
+        Example:
+            count = self.update(
+                "users",
+                {"email": "new@example.com"},
+                "id = :id",
+                {"id": 42}
+            )
+        """
+        self._require_db()
+        # Prefix data params with __set_ to avoid collision with where params
+        set_clause = ", ".join(f"{k} = :__set_{k}" for k in data.keys())
+        merged_params = {f"__set_{k}": v for k, v in data.items()}
+        merged_params.update(params)
+        sql = f"UPDATE {table} SET {set_clause} WHERE {where}"
+        cursor = self._db.execute(sql, merged_params)
+        if not self._in_tx:
+            self._db.commit()
+        return cursor.rowcount
+
+    def delete(self, table: str, where: str, params: Dict[str, Any]) -> int:
+        """
+        Delete rows matching condition and return deleted count.
+
+        Args:
+            table: Table name
+            where: WHERE clause with :param placeholders (without WHERE keyword)
+            params: Parameters for WHERE clause
+
+        Returns:
+            Number of rows deleted
+
+        Example:
+            count = self.delete("sessions", "expires_at < :now", {"now": now})
+        """
+        self._require_db()
+        sql = f"DELETE FROM {table} WHERE {where}"
+        cursor = self._db.execute(sql, params)
+        if not self._in_tx:
+            self._db.commit()
+        return cursor.rowcount
+
+    @contextmanager
+    def transaction(self):
+        """
+        Execute operations atomically.
+
+        Auto-commits on success, rolls back on exception.
+
+        Example:
+            with self.transaction():
+                user_id = self.insert("users", {"name": "Alice"})
+                self.insert("profiles", {"user_id": user_id, "bio": "Hello"})
+                # If any operation fails, all are rolled back
+        """
+        self._require_db()
+        self._in_tx = True
+        try:
+            yield
+            self._db.commit()
+        except Exception:
+            self._db.rollback()
+            raise
+        finally:
+            self._in_tx = False
+
+    def execute(self, sql: str) -> None:
+        """
+        Execute raw SQL (CREATE TABLE, etc).
+
+        Supports multiple statements separated by semicolons.
+
+        WARNING: Do NOT call inside a transaction() block. This method uses
+        executescript() which auto-commits any pending transaction.
+
+        Args:
+            sql: SQL statement(s) to execute
+
+        Raises:
+            RuntimeError: If called inside a transaction() block
+
+        Example:
+            self.execute('''
+                CREATE TABLE users (
+                    id INTEGER PRIMARY KEY,
+                    name TEXT NOT NULL
+                );
+                CREATE TABLE posts (
+                    id INTEGER PRIMARY KEY,
+                    user_id INTEGER REFERENCES users(id),
+                    content TEXT
+                );
+            ''')
+        """
+        self._require_db()
+        if self._in_tx:
+            raise RuntimeError(
+                "execute() cannot be called inside a transaction() block. "
+                "Use query() for SELECT or individual insert/update/delete calls."
+            )
+        self._db.executescript(sql)
+
+    def table_exists(self, name: str) -> bool:
+        """
+        Check if a table exists in the database.
+
+        Args:
+            name: Table name to check
+
+        Returns:
+            True if table exists, False otherwise
+
+        Example:
+            if not self.table_exists("users"):
+                self.execute("CREATE TABLE users (...)")
+        """
+        result = self.query(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name=:name",
+            {"name": name},
+            one=True,
+        )
+        return result is not None

gaia/database/testing.py

@@ -0,0 +1,64 @@
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+
+"""Database testing utilities for GAIA SDK users."""
+
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Optional
+
+from gaia.database.mixin import DatabaseMixin
+
+
+class _TempDB(DatabaseMixin):
+    """Internal helper for temp_db fixture."""
+
+
+@contextmanager
+def temp_db(schema: Optional[str] = None):
+    """
+    Create a temporary SQLite database for testing.
+
+    Creates a temporary database file that is automatically cleaned up
+    after the context exits. Useful for testing agents that use DatabaseMixin.
+
+    Args:
+        schema: Optional SQL to execute on the database (CREATE TABLE, etc.)
+
+    Yields:
+        str: Path to the temporary database file
+
+    Example:
+        from gaia.database import temp_db
+
+        def test_my_agent():
+            schema = '''
+                CREATE TABLE users (
+                    id INTEGER PRIMARY KEY,
+                    name TEXT NOT NULL
+                )
+            '''
+
+            with temp_db(schema) as db_path:
+                agent = MyAgent(skip_lemonade=True)
+                agent.init_db(db_path)  # Use temp database
+                agent.insert("users", {"name": "Alice"})
+                assert len(agent.query("SELECT * FROM users")) == 1
+
+        def test_empty_db():
+            with temp_db() as db_path:
+                agent = MyAgent(skip_lemonade=True)
+                agent.init_db(db_path)
+                # Agent can create its own schema
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = str(Path(tmpdir) / "test.db")
+
+        if schema:
+            db = _TempDB()
+            db.init_db(db_path)
+            db.execute(schema)
+            db.close_db()
+
+        yield db_path

gaia/eval/batch_experiment.py

@@ -1,4 +1,4 @@
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 # SPDX-License-Identifier: MIT
 
 import json

gaia/eval/claude.py

@@ -1,4 +1,4 @@
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 # SPDX-License-Identifier: MIT
 
 import base64

gaia/eval/config.py

@@ -1,4 +1,4 @@
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 # SPDX-License-Identifier: MIT
 
 """

gaia/eval/email_generator.py

@@ -1,4 +1,4 @@
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 # SPDX-License-Identifier: MIT
 
 import argparse

gaia/eval/eval.py

@@ -1,4 +1,4 @@
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 # SPDX-License-Identifier: MIT
 
 import json

gaia/eval/groundtruth.py

@@ -1,4 +1,4 @@
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 # SPDX-License-Identifier: MIT
 
 import argparse

gaia/eval/transcript_generator.py

@@ -1,4 +1,4 @@
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 # SPDX-License-Identifier: MIT
 
 import argparse

gaia/eval/webapp/public/app.js

@@ -1,4 +1,4 @@
-// Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 // SPDX-License-Identifier: MIT
 
 class EvaluationVisualizer {

gaia/eval/webapp/server.js

@@ -1,4 +1,4 @@
-// Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 // SPDX-License-Identifier: MIT
 
 const express = require('express');

gaia/eval/webapp/test-setup.js

@@ -1,4 +1,4 @@
-// Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+// Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 // SPDX-License-Identifier: MIT
 
 const fs = require('fs');

gaia/llm/__init__.py

@@ -1,2 +1,2 @@
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
 # SPDX-License-Identifier: MIT

gaia/llm/lemonade_client.py

@@ -381,6 +381,80 @@ def _prompt_user_for_download(
             print("Please enter 'y' or 'n'")
 
 
+def _prompt_user_for_repair(model_name: str) -> bool:
+    """
+    Prompt user for confirmation before deleting and re-downloading a corrupt model.
+
+    Args:
+        model_name: Name of the model to repair
+
+    Returns:
+        True if user confirms, False otherwise
+    """
+    # Check if we're in an interactive terminal
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        # Non-interactive environment - auto-approve
+        return True
+
+    # Try to use rich for nice formatting, fall back to plain text
+    try:
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.table import Table
+
+        console = Console()
+        console.print()
+
+        # Create info table
+        table = Table(show_header=False, box=None, padding=(0, 1))
+        table.add_column(style="dim")
+        table.add_column()
+        table.add_row("Model:", model_name)
+        table.add_row(
+            "Status:", "[yellow]Download incomplete or files corrupted[/yellow]"
+        )
+        table.add_row("Action:", "Delete and re-download the model")
+
+        console.print(
+            Panel(
+                table,
+                title="[bold yellow]⚠️  Corrupt Model Download Detected[/bold yellow]",
+                border_style="yellow",
+            )
+        )
+        console.print()
+
+        while True:
+            response = input("Delete and re-download? [Y/n]: ").strip().lower()
+            if response in ("", "y", "yes"):
+                console.print("[green]✓[/green] Proceeding with repair...")
+                return True
+            elif response in ("n", "no"):
+                console.print("[dim]Cancelled.[/dim]")
+                return False
+            else:
+                console.print("[dim]Please enter 'y' or 'n'[/dim]")
+
+    except ImportError:
+        # Fall back to plain text formatting
+        print("\n" + "=" * 60)
+        print(f"{_emoji('⚠️', '[WARNING]')} Corrupt Model Download Detected")
+        print("=" * 60)
+        print(f"Model: {model_name}")
+        print("Status: Download incomplete or files corrupted")
+        print("Action: Delete and re-download the model")
+        print("=" * 60)
+
+        while True:
+            response = input("Delete and re-download? [Y/n]: ").strip().lower()
+            if response in ("", "y", "yes"):
+                return True
+            elif response in ("n", "no"):
+                return False
+            else:
+                print("Please enter 'y' or 'n'")
+
+
 def _check_disk_space(size_gb: float, path: Optional[str] = None) -> bool:
     """
     Check if there's enough disk space for download.
@@ -466,9 +540,9 @@ class LemonadeClient:
         if not verbose:
             self.log.setLevel(logging.WARNING)
 
-        self.log.info(f"Initialized Lemonade client for {host}:{port}")
+        self.log.debug(f"Initialized Lemonade client for {host}:{port}")
         if model:
-            self.log.info(f"Initial model set to: {model}")
+            self.log.debug(f"Initial model set to: {model}")
 
     def launch_server(self, log_level="info", background="none", ctx_size=None):
         """
@@ -685,20 +759,27 @@ class LemonadeClient:
         """
         model_lower = model_name.lower()
 
-        # Look for billion parameter indicators
+        # Check for MoE models first (e.g., "30b-a3b" = 30B total, 3B active)
+        # MoE models are smaller than their total parameter count suggests
+        if "a3b" in model_lower or "a2b" in model_lower:
+            return 18.0  # MoE models like Qwen3-Coder-30B-A3B are ~18GB
+
+        # Look for billion parameter indicators (dense models)
         if "70b" in model_lower or "72b" in model_lower:
             return 40.0  # ~40GB for 70B models
         elif "30b" in model_lower or "34b" in model_lower:
-            return 20.0  # ~20GB for 30B models
+            return 18.0  # ~18GB for 30B models
         elif "13b" in model_lower or "14b" in model_lower:
             return 8.0  # ~8GB for 13B models
-        elif "7b" in model_lower:
-            return 5.0  # ~5GB for 7B models
+        elif "7b" in model_lower or "8b" in model_lower:
+            return 5.0  # ~5GB for 7-8B models
+        elif "4b" in model_lower:
+            return 2.5  # ~2.5GB for 4B models (e.g., Qwen3-VL-4B)
         elif "3b" in model_lower:
             return 2.0  # ~2GB for 3B models
-        elif "1b" in model_lower or "0.5b" in model_lower:
+        elif "1b" in model_lower or "0.5b" in model_lower or "0.6b" in model_lower:
             return 1.0  # ~1GB for small models
-        elif "embed" in model_lower:
+        elif "embed" in model_lower or "nomic" in model_lower:
             return 0.5  # Embedding models are usually small
         else:
             return 10.0  # Conservative default
@@ -880,6 +961,31 @@ class LemonadeClient:
             ]
         )
 
+    def _is_corrupt_download_error(self, error: Union[str, Dict, Exception]) -> bool:
+        """
+        Check if an error indicates a corrupt or incomplete model download.
+
+        Args:
+            error: Error as string, dict, or exception
+
+        Returns:
+            True if this is a corrupt/incomplete download error
+        """
+        error_info = self._extract_error_info(error)
+        error_message = (error_info.get("message") or "").lower()
+
+        return any(
+            phrase in error_message
+            for phrase in [
+                "download validation failed",
+                "files are incomplete",
+                "files are missing",
+                "incomplete or missing",
+                "corrupted download",
+                "llama-server failed to start",  # Often indicates corrupt model files
+            ]
+        )
+
     def _execute_with_auto_download(
         self, api_call: Callable, model: str, auto_download: bool = True
     ):
@@ -2007,7 +2113,7 @@ class LemonadeClient:
             InsufficientDiskSpaceError: If not enough disk space
             LemonadeClientError: If model loading fails
         """
-        self.log.info(f"Loading {model_name}")
+        self.log.debug(f"Loading {model_name}")
 
         request_data = {"model_name": model_name}
         if llamacpp_args:
@@ -2016,14 +2122,46 @@ class LemonadeClient:
 
         try:
             response = self._send_request("post", url, request_data, timeout=timeout)
-            self.log.info(f"Loaded {model_name} successfully: response={response}")
+            self.log.debug(f"Loaded {model_name} successfully: response={response}")
             self.model = model_name
             return response
         except Exception as e:
             original_error = str(e)
 
+            # Check if this is a corrupt/incomplete download error
+            if self._is_corrupt_download_error(e):
+                self.log.warning(
+                    f"{_emoji('⚠️', '[CORRUPT]')} Model '{model_name}' has incomplete "
+                    f"or corrupted files"
+                )
+
+                # Prompt user for confirmation to delete and re-download
+                if not _prompt_user_for_repair(model_name):
+                    raise ModelDownloadCancelledError(
+                        f"User declined to repair corrupt model: {model_name}"
+                    )
+
+                # Delete the corrupt model
+                self.log.info(
+                    f"{_emoji('🗑️', '[DELETE]')} Deleting corrupt model: {model_name}"
+                )
+                try:
+                    self.delete_model(model_name)
+                    self.log.info(
+                        f"{_emoji('✅', '[OK]')} Deleted corrupt model: {model_name}"
+                    )
+                except Exception as delete_error:
+                    self.log.warning(f"Failed to delete corrupt model: {delete_error}")
+                    # Continue anyway - the download may still work
+
+                # Now trigger a fresh download by falling through to auto-download flow
+                # (the model is now "not found" so _is_model_error will match)
+
             # Check if this is a "model not found" error and auto_download is enabled
-            if not (auto_download and self._is_model_error(e)):
+            if not (
+                auto_download
+                and (self._is_model_error(e) or self._is_corrupt_download_error(e))
+            ):
                 # Not a model error or auto_download disabled - re-raise
                 self.log.error(f"Failed to load {model_name}: {original_error}")
                 if isinstance(e, LemonadeClientError):