alita-sdk 0.3.462__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/cli/callbacks.py

@@ -68,6 +68,18 @@ class CLICallbackHandler(BaseCallbackHandler):
         self.pending_tokens: Dict[str, List[str]] = defaultdict(list)
         self.current_model: str = ""
         self.step_counter: int = 0
+        
+        # External status spinner that can be stopped
+        self.status = None
+    
+    def _stop_status(self):
+        """Stop the external status spinner if set."""
+        if self.status is not None:
+            try:
+                self.status.stop()
+                self.status = None
+            except Exception:
+                pass
     
     def _format_json_content(self, data: Any, max_length: int = 1500) -> str:
         """Format data as pretty JSON string."""
@@ -137,6 +149,9 @@ class CLICallbackHandler(BaseCallbackHandler):
         **kwargs: Any,
     ) -> None:
         """Called when a tool starts running."""
+        # Stop the thinking spinner when a tool starts
+        self._stop_status()
+        
         if not self.show_tool_outputs:
             return
         
@@ -390,23 +405,26 @@ class CLICallbackHandler(BaseCallbackHandler):
         llm_run_id = str(run_id)
         llm_info = self.llm_runs.pop(llm_run_id, {})
         
-        # Show any pending tokens (streaming output)
-        if self.show_thinking:
-            tokens = self.pending_tokens.pop(llm_run_id, [])
-            if tokens:
-                thinking_text = "".join(tokens)
-                if thinking_text.strip():
-                    # Show thinking in a subtle panel
-                    max_len = 600
-                    display_text = thinking_text[:max_len] + ('...' if len(thinking_text) > max_len else '')
-                    console.print(Panel(
-                        Text(display_text, style="dim italic"),
-                        title="[dim]💭 Thinking[/dim]",
-                        title_align="left",
-                        border_style="dim",
-                        box=box.SIMPLE,
-                        padding=(0, 1),
-                    ))
+        # Clear pending tokens - we don't show them as "Thinking" anymore
+        # The final response will be displayed by the main chat loop
+        # Only show thinking if there were tool calls (indicated by having active tool runs)
+        tokens = self.pending_tokens.pop(llm_run_id, [])
+        
+        # Only show thinking panel if we have active tool context (intermediate reasoning)
+        if self.show_thinking and tokens and len(self.tool_runs) > 0:
+            thinking_text = "".join(tokens)
+            if thinking_text.strip():
+                # Show thinking in a subtle panel
+                max_len = 600
+                display_text = thinking_text[:max_len] + ('...' if len(thinking_text) > max_len else '')
+                console.print(Panel(
+                    Text(display_text, style="dim italic"),
+                    title="[dim]💭 Thinking[/dim]",
+                    title_align="left",
+                    border_style="dim",
+                    box=box.SIMPLE,
+                    padding=(0, 1),
+                ))
         
         if self.show_llm_calls and llm_info:
             start_time = llm_info.get("start_time")
@@ -425,15 +443,68 @@ class CLICallbackHandler(BaseCallbackHandler):
         **kwargs: Any,
     ) -> None:
         """Called when LLM errors."""
+        error_str = str(error)
+        
+        # Parse common error patterns for user-friendly messages
+        user_message = None
+        hint = None
+        
+        # Invalid model identifier (Bedrock/Claude)
+        if "model identifier is invalid" in error_str.lower() or "BedrockException" in error_str:
+            user_message = "Invalid model identifier"
+            hint = "The model may not be available in your region or the model ID is incorrect.\nUse /model to switch to a different model."
+        
+        # Rate limiting
+        elif "rate limit" in error_str.lower() or "too many requests" in error_str.lower():
+            user_message = "Rate limit exceeded"
+            hint = "Wait a moment and try again, or switch to a different model with /model."
+        
+        # Token/context length exceeded
+        elif "context length" in error_str.lower() or "maximum.*tokens" in error_str.lower() or "too long" in error_str.lower():
+            user_message = "Context length exceeded"
+            hint = "The conversation is too long. Start a new session or use /clear to reset."
+        
+        # Authentication errors
+        elif "authentication" in error_str.lower() or "unauthorized" in error_str.lower() or "api key" in error_str.lower():
+            user_message = "Authentication failed"
+            hint = "Check your API credentials in the configuration."
+        
+        # Model not found/available
+        elif "model not found" in error_str.lower() or "does not exist" in error_str.lower():
+            user_message = "Model not found"
+            hint = "The requested model is not available. Use /model to select a different one."
+        
+        # Build the display message
         console.print()
-        console.print(Panel(
-            Text(str(error), style="red"),
-            title="[bold red]✗ LLM Error[/bold red]",
-            title_align="left",
-            border_style="red",
-            box=ERROR_BOX,
-            padding=(0, 1),
-        ))
+        if user_message:
+            content = Text()
+            content.append(f"❌ {user_message}\n\n", style="bold red")
+            if hint:
+                content.append(f"💡 {hint}\n\n", style="yellow")
+            content.append("Technical details:\n", style="dim")
+            # Truncate long error messages
+            if len(error_str) > 300:
+                content.append(error_str[:300] + "...", style="dim")
+            else:
+                content.append(error_str, style="dim")
+            console.print(Panel(
+                content,
+                title="[bold red]✗ LLM Error[/bold red]",
+                title_align="left",
+                border_style="red",
+                box=ERROR_BOX,
+                padding=(0, 1),
+            ))
+        else:
+            # Fallback to original behavior for unrecognized errors
+            console.print(Panel(
+                Text(str(error), style="red"),
+                title="[bold red]✗ LLM Error[/bold red]",
+                title_align="left",
+                border_style="red",
+                box=ERROR_BOX,
+                padding=(0, 1),
+            ))
     
     #
     # Chain Callbacks

alita_sdk/cli/cli.py

@@ -30,10 +30,11 @@ logger = logging.getLogger(__name__)
 @click.group()
 @click.option('--env-file', default='.env', help='Path to .env file')
 @click.option('--debug', is_flag=True, help='Enable debug logging')
+@click.option('--verbose', '-v', is_flag=True, help='Enable verbose/info logging (shows timing)')
 @click.option('--output', type=click.Choice(['text', 'json']), default='text', 
               help='Output format')
 @click.pass_context
-def cli(ctx, env_file: str, debug: bool, output: str):
+def cli(ctx, env_file: str, debug: bool, verbose: bool, output: str):
     """
     Alita SDK CLI - Test agents and toolkits from the command line.
     
@@ -55,12 +56,18 @@ def cli(ctx, env_file: str, debug: bool, output: str):
         logging.getLogger('alita_sdk').setLevel(logging.DEBUG)
         logger.setLevel(logging.DEBUG)
         logger.debug("Debug logging enabled")
+    elif verbose:
+        # Verbose mode shows INFO level (timing info)
+        logging.getLogger('alita_sdk').setLevel(logging.INFO)
+        logger.setLevel(logging.INFO)
+        logger.info("Verbose logging enabled")
     
     # Load configuration
     config = get_config(env_file=env_file)
     ctx.obj['config'] = config
     ctx.obj['formatter'] = get_formatter(output)
     ctx.obj['debug'] = debug
+    ctx.obj['verbose'] = verbose
     
     # Check if configuration is valid (but don't fail yet - some commands don't need it)
     if not config.is_configured():
@@ -128,10 +135,12 @@ def config(ctx):
 # Import subcommands
 from . import toolkit
 from . import agents
+from . import inventory
 
 # Register subcommands
 cli.add_command(toolkit.toolkit)
 cli.add_command(agents.agent)
+cli.add_command(inventory.inventory)
 
 # Add top-level 'chat' command as alias to 'agent chat'
 cli.add_command(agents.agent_chat, name='chat')

alita_sdk/cli/config.py

@@ -7,6 +7,7 @@ as the SDK tests and Streamlit interface.
 
 import os
 import re
+import json
 from typing import Optional, Dict, Any
 from dotenv import load_dotenv
 import logging
@@ -22,37 +23,140 @@ class CLIConfig:
         Initialize CLI configuration.
         
         Args:
-            env_file: Path to .env file. If None, uses default (.env in current directory)
+            env_file: Path to .env file. If None, checks ALITA_ENV_FILE env var,
+                      then falls back to .alita/.env or .env in current directory
         """
-        self.env_file = env_file or '.env'
+        self._config_json: Dict[str, Any] = {}
+        
+        if env_file:
+            self.env_file = env_file
+        else:
+            # Check ALITA_ENV_FILE environment variable first
+            alita_env_file = os.getenv('ALITA_ENV_FILE')
+            if alita_env_file:
+                # Expand ~ and resolve path
+                expanded_path = os.path.expanduser(alita_env_file)
+                if os.path.exists(expanded_path):
+                    self.env_file = expanded_path
+                else:
+                    logger.warning(f"ALITA_ENV_FILE set to {alita_env_file} but file not found")
+                    self.env_file = expanded_path  # Still use it, will warn later
+            elif os.path.exists(os.path.expanduser('~/.alita/.env')):
+                self.env_file = os.path.expanduser('~/.alita/.env')
+            elif os.path.exists('.alita/.env'):
+                self.env_file = '.alita/.env'
+            else:
+                self.env_file = '.env'
         self._load_env()
+        self._load_config_json()
         
     def _load_env(self):
         """Load environment variables from .env file."""
         if os.path.exists(self.env_file):
-            load_dotenv(self.env_file)
+            # Use override=True to ensure .env values take precedence
+            load_dotenv(self.env_file, override=True)
             logger.debug(f"Loaded environment from {self.env_file}")
         else:
             logger.debug(f"No .env file found at {self.env_file}, using system environment")
     
+    def _load_config_json(self):
+        """Load configuration from $ALITA_DIR/config.json as fallback."""
+        # Try ALITA_DIR from env, then ~/.alita, then .alita
+        alita_dir = os.getenv('ALITA_DIR')
+        if alita_dir:
+            config_path = os.path.join(os.path.expanduser(alita_dir), 'config.json')
+        else:
+            # Try ~/.alita/config.json first, then .alita/config.json
+            home_config = os.path.expanduser('~/.alita/config.json')
+            local_config = '.alita/config.json'
+            if os.path.exists(home_config):
+                config_path = home_config
+            elif os.path.exists(local_config):
+                config_path = local_config
+            else:
+                config_path = home_config  # Default path even if doesn't exist
+        
+        if os.path.exists(config_path):
+            try:
+                with open(config_path, 'r') as f:
+                    self._config_json = json.load(f)
+                logger.debug(f"Loaded config from {config_path}")
+                
+                # Load env section into environment variables
+                self._load_env_section()
+            except (json.JSONDecodeError, IOError) as e:
+                logger.warning(f"Failed to load config.json: {e}")
+    
+    def _load_env_section(self):
+        """Load variables from config.json 'env' section into environment."""
+        env_vars = self._config_json.get('env', {})
+        if isinstance(env_vars, dict):
+            for key, value in env_vars.items():
+                # Only set if not already in environment (env vars take precedence)
+                if key not in os.environ and value is not None:
+                    os.environ[key] = str(value)
+                    logger.debug(f"Set {key} from config.json env section")
+    
+    def _get_config_value(self, env_key: str, json_key: Optional[str] = None) -> Optional[str]:
+        """
+        Get config value from environment first, then config.json fallback.
+        
+        Args:
+            env_key: Environment variable name
+            json_key: Key in config.json (defaults to lowercase of env_key)
+        """
+        # Try environment variable first
+        value = os.getenv(env_key)
+        if value:
+            return value
+        
+        # Fallback to config.json
+        if json_key is None:
+            json_key = env_key.lower()
+        
+        return self._config_json.get(json_key)
+    
     @property
     def deployment_url(self) -> Optional[str]:
-        """Get deployment URL from environment."""
-        return os.getenv('DEPLOYMENT_URL')
+        """Get deployment URL from environment or config.json."""
+        return self._get_config_value('DEPLOYMENT_URL', 'deployment_url')
     
     @property
     def project_id(self) -> Optional[int]:
-        """Get project ID from environment."""
+        """Get project ID from environment or config.json."""
         try:
-            value = os.getenv('PROJECT_ID')
+            value = self._get_config_value('PROJECT_ID', 'project_id')
             return int(value) if value else None
         except (TypeError, ValueError):
             return None
     
     @property
     def api_key(self) -> Optional[str]:
-        """Get API key from environment."""
-        return os.getenv('API_KEY')
+        """Get API key from environment or config.json."""
+        return self._get_config_value('API_KEY', 'api_key')
+    
+    @property
+    def default_model(self) -> Optional[str]:
+        """Get default model from environment or config.json."""
+        return self._get_config_value('ALITA_DEFAULT_MODEL', 'default_model')
+    
+    @property
+    def default_temperature(self) -> Optional[float]:
+        """Get default temperature from environment or config.json."""
+        try:
+            value = self._get_config_value('ALITA_DEFAULT_TEMPERATURE', 'default_temperature')
+            return float(value) if value is not None else None
+        except (TypeError, ValueError):
+            return None
+    
+    @property
+    def default_max_tokens(self) -> Optional[int]:
+        """Get default max tokens from environment or config.json."""
+        try:
+            value = self._get_config_value('ALITA_DEFAULT_MAX_TOKENS', 'default_max_tokens')
+            return int(value) if value is not None else None
+        except (TypeError, ValueError):
+            return None
     
     @property
     def alita_dir(self) -> str:
@@ -83,6 +187,55 @@ class CLIConfig:
             return 'mcp.json'
         return alita_mcp
     
+    @property
+    def context_management(self) -> Dict[str, Any]:
+        """
+        Get context management configuration from config.json.
+        
+        Returns configuration for chat history context management with defaults:
+        - enabled: True - Enable context management
+        - max_context_tokens: 8000 - Maximum tokens in context
+        - preserve_recent_messages: 5 - Always keep N most recent messages
+        - pruning_method: 'oldest_first' - Strategy for pruning (oldest_first, importance_based)
+        - enable_summarization: True - Generate summaries of pruned messages
+        - summary_trigger_ratio: 0.8 - Trigger summarization at 80% context fill
+        - summaries_limit_count: 5 - Maximum number of summaries to keep
+        - session_max_age_days: 30 - Purge sessions older than N days
+        - max_sessions: 50 - Maximum number of sessions to keep
+        """
+        defaults = {
+            'enabled': True,
+            'max_context_tokens': 8000,
+            'preserve_recent_messages': 5,
+            'pruning_method': 'oldest_first',
+            'enable_summarization': True,
+            'summary_trigger_ratio': 0.8,
+            'summaries_limit_count': 5,
+            'session_max_age_days': 30,
+            'max_sessions': 50,
+            'weights': {
+                'recency': 1.0,
+                'importance': 1.0,
+                'user_messages': 1.2,
+                'thread_continuity': 1.0,
+            },
+        }
+        
+        # Get from config.json
+        config = self._config_json.get('context_management', {})
+        
+        # Merge with defaults
+        result = defaults.copy()
+        if isinstance(config, dict):
+            result.update(config)
+        
+        return result
+    
+    @property
+    def sessions_dir(self) -> str:
+        """Get sessions directory (derived from ALITA_DIR)."""
+        return os.path.join(self.alita_dir, 'sessions')
+    
     def is_configured(self) -> bool:
         """Check if all required configuration is present."""
         return all([

alita_sdk/cli/context/__init__.py

@@ -0,0 +1,30 @@
+"""
+Context management for CLI chat history.
+
+Provides token-aware context pruning, summarization, and session management
+to optimize LLM context usage during CLI conversations.
+"""
+
+from .manager import CLIContextManager, sanitize_message_history
+from .message import CLIMessage
+from .token_estimation import estimate_tokens, calculate_total_tokens
+from .strategies import (
+    PruningStrategy,
+    OldestFirstStrategy,
+    ImportanceBasedStrategy,
+    PruningStrategyFactory,
+)
+from .cleanup import purge_old_sessions
+
+__all__ = [
+    'CLIContextManager',
+    'CLIMessage',
+    'estimate_tokens',
+    'calculate_total_tokens',
+    'PruningStrategy',
+    'OldestFirstStrategy',
+    'ImportanceBasedStrategy',
+    'PruningStrategyFactory',
+    'purge_old_sessions',
+    'sanitize_message_history',
+]

alita_sdk/cli/context/cleanup.py

@@ -0,0 +1,198 @@
+"""
+Session cleanup utilities for CLI context management.
+
+Handles purging old sessions to prevent disk space issues.
+"""
+
+import os
+import shutil
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+def get_sessions_dir(alita_dir: str = '.alita') -> Path:
+    """
+    Get the sessions directory path.
+    
+    Args:
+        alita_dir: Base Alita directory
+        
+    Returns:
+        Path to sessions directory
+    """
+    # Expand ~ for home directory
+    if alita_dir.startswith('~'):
+        alita_dir = os.path.expanduser(alita_dir)
+    return Path(alita_dir) / 'sessions'
+
+
+def list_sessions_with_age(alita_dir: str = '.alita') -> List[Tuple[str, float, datetime]]:
+    """
+    List all sessions with their age in days.
+    
+    Args:
+        alita_dir: Base Alita directory
+        
+    Returns:
+        List of tuples: (session_id, age_days, modified_time)
+    """
+    sessions_dir = get_sessions_dir(alita_dir)
+    
+    if not sessions_dir.exists():
+        return []
+    
+    sessions = []
+    now = datetime.now(timezone.utc)
+    
+    for session_path in sessions_dir.iterdir():
+        if not session_path.is_dir():
+            continue
+        
+        session_id = session_path.name
+        
+        # Get modification time (most recent file in session)
+        try:
+            mtime = max(
+                f.stat().st_mtime
+                for f in session_path.rglob('*')
+                if f.is_file()
+            )
+            modified = datetime.fromtimestamp(mtime, tz=timezone.utc)
+            age_days = (now - modified).total_seconds() / 86400
+            sessions.append((session_id, age_days, modified))
+        except (ValueError, OSError):
+            # No files or error accessing - use directory mtime
+            try:
+                mtime = session_path.stat().st_mtime
+                modified = datetime.fromtimestamp(mtime, tz=timezone.utc)
+                age_days = (now - modified).total_seconds() / 86400
+                sessions.append((session_id, age_days, modified))
+            except OSError:
+                continue
+    
+    # Sort by modification time (oldest first)
+    sessions.sort(key=lambda x: x[2])
+    
+    return sessions
+
+
+def purge_old_sessions(
+    max_age_days: int = 30,
+    max_sessions: int = 50,
+    alita_dir: str = '.alita',
+    dry_run: bool = False
+) -> Tuple[int, int]:
+    """
+    Purge old sessions based on age and count limits.
+    
+    Args:
+        max_age_days: Maximum age in days before a session is purged
+        max_sessions: Maximum number of sessions to keep
+        alita_dir: Base Alita directory
+        dry_run: If True, only report what would be deleted
+        
+    Returns:
+        Tuple of (sessions_deleted, bytes_freed)
+    """
+    sessions_dir = get_sessions_dir(alita_dir)
+    
+    if not sessions_dir.exists():
+        return 0, 0
+    
+    sessions = list_sessions_with_age(alita_dir)
+    
+    if not sessions:
+        return 0, 0
+    
+    to_delete = []
+    
+    # Mark sessions older than max_age_days for deletion
+    for session_id, age_days, modified in sessions:
+        if age_days > max_age_days:
+            to_delete.append(session_id)
+    
+    # If we still have too many sessions, delete oldest ones
+    remaining = [s for s in sessions if s[0] not in to_delete]
+    if len(remaining) > max_sessions:
+        # Sort remaining by age (oldest first) and mark excess for deletion
+        excess_count = len(remaining) - max_sessions
+        for session_id, age_days, modified in remaining[:excess_count]:
+            if session_id not in to_delete:
+                to_delete.append(session_id)
+    
+    # Delete marked sessions
+    deleted_count = 0
+    bytes_freed = 0
+    
+    for session_id in to_delete:
+        session_path = sessions_dir / session_id
+        
+        if not session_path.exists():
+            continue
+        
+        # Calculate size before deletion
+        try:
+            session_size = sum(
+                f.stat().st_size
+                for f in session_path.rglob('*')
+                if f.is_file()
+            )
+        except OSError:
+            session_size = 0
+        
+        if dry_run:
+            logger.info(f"Would delete session: {session_id} ({session_size} bytes)")
+        else:
+            try:
+                shutil.rmtree(session_path)
+                deleted_count += 1
+                bytes_freed += session_size
+                logger.debug(f"Deleted session: {session_id}")
+            except OSError as e:
+                logger.warning(f"Failed to delete session {session_id}: {e}")
+    
+    if deleted_count > 0:
+        logger.info(f"Purged {deleted_count} old sessions, freed {bytes_freed} bytes")
+    
+    return deleted_count, bytes_freed
+
+
+def get_session_disk_usage(alita_dir: str = '.alita') -> Tuple[int, int]:
+    """
+    Get disk usage statistics for sessions.
+    
+    Args:
+        alita_dir: Base Alita directory
+        
+    Returns:
+        Tuple of (session_count, total_bytes)
+    """
+    sessions_dir = get_sessions_dir(alita_dir)
+    
+    if not sessions_dir.exists():
+        return 0, 0
+    
+    session_count = 0
+    total_bytes = 0
+    
+    for session_path in sessions_dir.iterdir():
+        if not session_path.is_dir():
+            continue
+        
+        session_count += 1
+        
+        try:
+            session_size = sum(
+                f.stat().st_size
+                for f in session_path.rglob('*')
+                if f.is_file()
+            )
+            total_bytes += session_size
+        except OSError:
+            continue
+    
+    return session_count, total_bytes