alita-sdk 0.3.486__py3-none-any.whl → 0.3.515__py3-none-any.whl

alita_sdk/cli/agent_loader.py

@@ -8,6 +8,7 @@ import json
 import yaml
 from pathlib import Path
 from typing import Dict, Any
+from pydantic import SecretStr
 
 from .config import substitute_env_vars
 
@@ -85,6 +86,25 @@ def load_agent_definition(file_path: str) -> Dict[str, Any]:
     raise ValueError(f"Unsupported file format: {path.suffix}")
 
 
+def unwrap_secrets(obj: Any) -> Any:
+    """
+    Recursively unwrap pydantic SecretStr values into plain strings.
+
+    Handles nested dicts, lists, tuples, and sets while preserving structure.
+    """
+    if isinstance(obj, SecretStr):
+        return obj.get_secret_value()
+    if isinstance(obj, dict):
+        return {k: unwrap_secrets(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [unwrap_secrets(v) for v in obj]
+    if isinstance(obj, tuple):
+        return tuple(unwrap_secrets(v) for v in obj)
+    if isinstance(obj, set):
+        return {unwrap_secrets(v) for v in obj}
+    return obj
+
+
 def build_agent_data_structure(agent_def: Dict[str, Any], toolkit_configs: list, 
                                llm_model: str, llm_temperature: float, llm_max_tokens: int) -> Dict[str, Any]:
     """
@@ -128,12 +148,13 @@ def build_agent_data_structure(agent_def: Dict[str, Any], toolkit_configs: list,
                     if hasattr(toolkit_class, 'toolkit_config_schema'):
                         schema = toolkit_class.toolkit_config_schema()
                         validated_config = schema(**toolkit_config)
-                        # validated_dict = validated_config.model_dump()
-                        # validated_dict['type'] = toolkit_config.get('type')
-                        # validated_dict['toolkit_name'] = toolkit_config.get('toolkit_name')
-                        # validated_toolkit_configs.append(validated_dict)
-
-                    validated_toolkit_configs.append(toolkit_config)
+                        # Use python mode so SecretStr remains as objects, then unwrap recursively
+                        validated_dict = unwrap_secrets(validated_config.model_dump(mode="python"))
+                        validated_dict['type'] = toolkit_config.get('type')
+                        validated_dict['toolkit_name'] = toolkit_config.get('toolkit_name')
+                        validated_toolkit_configs.append(validated_dict)
+                    else:
+                        validated_toolkit_configs.append(toolkit_config)
                 else:
                     validated_toolkit_configs.append(toolkit_config)
             except Exception:

alita_sdk/cli/agents.py

@@ -1358,12 +1358,14 @@ def agent_show(ctx, agent_source: str, version: Optional[str]):
               help='Grant agent filesystem access to this directory')
 @click.option('--verbose', '-v', type=click.Choice(['quiet', 'default', 'debug']), default='default',
               help='Output verbosity level: quiet (final output only), default (tool calls + outputs), debug (all including LLM calls)')
+@click.option('--recursion-limit', type=int, default=50,
+              help='Maximum number of tool execution steps per turn')
 @click.pass_context
 def agent_chat(ctx, agent_source: Optional[str], version: Optional[str], 
                toolkit_config: tuple, inventory_path: Optional[str], thread_id: Optional[str],
                model: Optional[str], temperature: Optional[float], 
                max_tokens: Optional[int], work_dir: Optional[str],
-               verbose: str):
+               verbose: str, recursion_limit: Optional[int]):
     """Start interactive chat with an agent.
     
     \b
@@ -2615,6 +2617,11 @@ def agent_chat(ctx, agent_source: Optional[str], version: Optional[str],
                     invoke_config = RunnableConfig(
                         configurable={"thread_id": current_session_id}
                     )
+                    # always proceed with continuation enabled
+                    invoke_config["should_continue"] = True
+                    # Set recursion limit for tool executions
+                    logger.debug(f"Setting tool steps limit to {recursion_limit}")
+                    invoke_config["recursion_limit"] = recursion_limit
                     cli_callback = None
                     if show_verbose:
                         cli_callback = create_cli_callback(verbose=True, debug=debug_mode)
@@ -2718,6 +2725,8 @@ def agent_chat(ctx, agent_source: Optional[str], version: Optional[str],
                                     invoke_config = RunnableConfig(
                                         configurable={"thread_id": continuation_thread_id}
                                     )
+                                    invoke_config["should_continue"] = True
+                                    invoke_config["recursion_limit"] = recursion_limit
                                     if cli_callback:
                                         invoke_config["callbacks"] = [cli_callback]
                                     

alita_sdk/cli/inventory.py

@@ -1048,209 +1048,26 @@ def _get_checkpoint_path(graph: str, source_name: str) -> str:
 
 
 def _load_toolkit_config(toolkit_path: str) -> Dict[str, Any]:
-    """
-    Load and parse a toolkit config JSON file.
-    
-    Supports environment variable substitution for values like ${GITHUB_PAT}.
-    """
-    with open(toolkit_path, 'r') as f:
-        config = json.load(f)
-    
-    # Recursively resolve environment variables
-    def resolve_env_vars(obj):
-        if isinstance(obj, str):
-            # Match ${VAR_NAME} pattern
-            pattern = r'\$\{([^}]+)\}'
-            matches = re.findall(pattern, obj)
-            for var_name in matches:
-                env_value = os.environ.get(var_name, '')
-                obj = obj.replace(f'${{{var_name}}}', env_value)
-            return obj
-        elif isinstance(obj, dict):
-            return {k: resolve_env_vars(v) for k, v in obj.items()}
-        elif isinstance(obj, list):
-            return [resolve_env_vars(item) for item in obj]
-        return obj
-    
-    return resolve_env_vars(config)
+    """Deprecated: Use alita_sdk.community.inventory.toolkit_utils.load_toolkit_config instead."""
+    from alita_sdk.community.inventory.toolkit_utils import load_toolkit_config
+    return load_toolkit_config(toolkit_path)
 
 
 def _get_llm(ctx, model: Optional[str] = None, temperature: float = 0.0):
-    """Get LLM instance from Alita client context."""
+    """Deprecated: Use alita_sdk.community.inventory.toolkit_utils.get_llm_for_config instead."""
     from .cli import get_client
+    from alita_sdk.community.inventory.toolkit_utils import get_llm_for_config
     
-    # Get Alita client - this will raise ClickException if not configured
     client = get_client(ctx)
-    
-    # Get model name from parameter or default
-    model_name = model or 'gpt-4o-mini'
-    
-    # Use client.get_llm() which is the actual method
-    return client.get_llm(
-        model_name=model_name,
-        model_config={
-            'temperature': temperature,
-            'max_tokens': 4096
-        }
-    )
+    return get_llm_for_config(client, model=model, temperature=temperature)
 
 
 def _get_source_toolkit(toolkit_config: Dict[str, Any]):
-    """
-    Get configured source toolkit instance from toolkit config.
-    
-    Uses the SDK's toolkit factory pattern - all toolkits extend BaseCodeToolApiWrapper
-    or BaseVectorStoreToolApiWrapper, which have loader() and chunker() methods.
-    
-    Also supports CLI-specific toolkits like 'filesystem' for local document loading.
+    """Deprecated: Use alita_sdk.community.inventory.toolkit_utils.get_source_toolkit instead."""
+    from alita_sdk.community.inventory.toolkit_utils import get_source_toolkit
     
-    Args:
-        toolkit_config: Toolkit configuration dict with 'type' and settings
-        
-    Returns:
-        API wrapper instance with loader() method
-    """
-    source = toolkit_config.get('type')
-    if not source:
-        raise click.ClickException("Toolkit config missing 'type' field")
-    
-    # Handle filesystem type (CLI-specific, not in AVAILABLE_TOOLS)
-    if source == 'filesystem':
-        from .tools.filesystem import FilesystemApiWrapper
-        
-        base_directory = (
-            toolkit_config.get('base_directory') or
-            toolkit_config.get('path') or
-            toolkit_config.get('git_root_dir')
-        )
-        
-        if not base_directory:
-            raise click.ClickException(
-                "Filesystem toolkit requires 'base_directory' or 'path' field"
-            )
-        
-        return FilesystemApiWrapper(
-            base_directory=base_directory,
-            recursive=toolkit_config.get('recursive', True),
-            follow_symlinks=toolkit_config.get('follow_symlinks', False),
-        )
-    
-    # Handle standard SDK toolkits via AVAILABLE_TOOLS registry
-    from alita_sdk.tools import AVAILABLE_TOOLS
-    
-    # Check if toolkit type is available
-    if source not in AVAILABLE_TOOLS:
-        raise click.ClickException(
-            f"Unknown toolkit type: {source}. "
-            f"Available: {', '.join(list(AVAILABLE_TOOLS.keys()) + ['filesystem'])}"
-        )
-    
-    toolkit_info = AVAILABLE_TOOLS[source]
-    
-    # Get the toolkit class
-    if 'toolkit_class' not in toolkit_info:
-        raise click.ClickException(
-            f"Toolkit '{source}' does not have a toolkit_class registered"
-        )
-    
-    toolkit_class = toolkit_info['toolkit_class']
-    
-    # Build kwargs from toolkit config - we need to map config to API wrapper params
-    kwargs = dict(toolkit_config)
-    
-    # Remove fields that aren't needed for the API wrapper
-    kwargs.pop('type', None)
-    kwargs.pop('toolkit_name', None)
-    kwargs.pop('selected_tools', None)
-    kwargs.pop('excluded_tools', None)
-    
-    # Handle common config patterns - flatten nested configurations
-    config_key = f"{source}_configuration"
-    if config_key in kwargs:
-        nested_config = kwargs.pop(config_key)
-        if isinstance(nested_config, dict):
-            kwargs.update(nested_config)
-    
-    # Handle ADO-specific config pattern
-    if 'ado_configuration' in kwargs:
-        ado_config = kwargs.pop('ado_configuration')
-        if isinstance(ado_config, dict):
-            kwargs.update(ado_config)
-    
-    # Expand environment variables in string values (e.g., ${GITHUB_PAT})
-    def expand_env_vars(value):
-        """Recursively expand environment variables in values."""
-        if isinstance(value, str):
-            import re
-            # Match ${VAR} or $VAR patterns
-            pattern = r'\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)'
-            def replace(match):
-                var_name = match.group(1) or match.group(2)
-                return os.environ.get(var_name, match.group(0))
-            return re.sub(pattern, replace, value)
-        elif isinstance(value, dict):
-            return {k: expand_env_vars(v) for k, v in value.items()}
-        elif isinstance(value, list):
-            return [expand_env_vars(v) for v in value]
-        return value
-    
-    kwargs = expand_env_vars(kwargs)
-    
-    # Map common field names to API wrapper expected names
-    # GitHub: personal_access_token -> github_access_token
-    if 'personal_access_token' in kwargs and source == 'github':
-        kwargs['github_access_token'] = kwargs.pop('personal_access_token')
-    
-    # GitHub: repository -> github_repository
-    if 'repository' in kwargs and source == 'github':
-        kwargs['github_repository'] = kwargs.pop('repository')
-    
-    # Ensure active_branch has a default
-    if 'active_branch' not in kwargs:
-        kwargs['active_branch'] = kwargs.get('base_branch', 'main')
-    
-    # Get the API wrapper class from the toolkit
-    # Introspect toolkit to find the API wrapper class it uses
     try:
-        # Try to get the API wrapper class from the toolkit's module
-        import importlib
-        module_path = f"alita_sdk.tools.{source}.api_wrapper"
-        try:
-            wrapper_module = importlib.import_module(module_path)
-        except ImportError:
-            # Try alternate path for nested modules
-            module_path = f"alita_sdk.tools.{source.replace('_', '.')}.api_wrapper"
-            wrapper_module = importlib.import_module(module_path)
-        
-        # Find the API wrapper class - look for class containing ApiWrapper/APIWrapper
-        api_wrapper_class = None
-        for name in dir(wrapper_module):
-            obj = getattr(wrapper_module, name)
-            if (isinstance(obj, type) and 
-                ('ApiWrapper' in name or 'APIWrapper' in name) and 
-                name not in ('BaseCodeToolApiWrapper', 'BaseVectorStoreToolApiWrapper', 'BaseToolApiWrapper')):
-                api_wrapper_class = obj
-                break
-        
-        if not api_wrapper_class:
-            raise click.ClickException(
-                f"Could not find API wrapper class in {module_path}"
-            )
-        
-        # Instantiate the API wrapper directly
-        api_wrapper = api_wrapper_class(**kwargs)
-        
-        # Verify it has loader method
-        if not hasattr(api_wrapper, 'loader'):
-            raise click.ClickException(
-                f"API wrapper '{api_wrapper_class.__name__}' has no loader() method"
-            )
-        
-        return api_wrapper
-        
-    except ImportError as e:
-        logger.exception(f"Failed to import API wrapper for {source}")
-        raise click.ClickException(f"Failed to import {source} API wrapper: {e}")
-    except Exception as e:
-        logger.exception(f"Failed to instantiate toolkit {source}")
-        raise click.ClickException(f"Failed to create {source} toolkit: {e}")
+        return get_source_toolkit(toolkit_config)
+    except ValueError as e:
+        # Convert ValueError to ClickException for CLI context
+        raise click.ClickException(str(e))

alita_sdk/cli/tools/filesystem.py

@@ -135,6 +135,7 @@ class ListDirectoryInput(BaseModel):
     path: str = Field(default=".", description="Relative path to the directory to list")
     include_sizes: bool = Field(default=False, description="Include file sizes in the output")
     sort_by: str = Field(default="name", description="Sort by 'name' or 'size'")
+    max_results: Optional[int] = Field(default=200, description="Maximum number of entries to return. Default is 200 to prevent context overflow.")
 
 
 class DirectoryTreeInput(BaseModel):
@@ -181,6 +182,8 @@ class FileSystemTool(BaseTool):
     """Base class for filesystem tools with directory restriction."""
     base_directory: str  # Primary directory (for backward compatibility)
     allowed_directories: List[str] = []  # Additional allowed directories
+    _basename_collision_detected: bool = False  # Cache for collision detection
+    _basename_collision_checked: bool = False  # Whether we've checked for collisions
     
     def _get_all_allowed_directories(self) -> List[Path]:
         """Get all allowed directories as resolved Paths."""
@@ -191,6 +194,56 @@ class FileSystemTool(BaseTool):
                 dirs.append(resolved)
         return dirs
     
+    def _check_basename_collision(self) -> bool:
+        """Check if multiple allowed directories have the same basename."""
+        if self._basename_collision_checked:
+            return self._basename_collision_detected
+        
+        allowed_dirs = self._get_all_allowed_directories()
+        basenames = [d.name for d in allowed_dirs]
+        self._basename_collision_detected = len(basenames) != len(set(basenames))
+        self._basename_collision_checked = True
+        return self._basename_collision_detected
+    
+    def _get_relative_path_from_allowed_dirs(self, absolute_path: Path) -> tuple:
+        """Get relative path and directory name for a file in allowed directories.
+        
+        Args:
+            absolute_path: Absolute path to the file
+            
+        Returns:
+            Tuple of (relative_path, directory_name)
+            
+        Raises:
+            ValueError: If path is not within any allowed directory
+        """
+        allowed_dirs = self._get_all_allowed_directories()
+        
+        # Find which allowed directory contains this path
+        for base in allowed_dirs:
+            try:
+                rel_path = absolute_path.relative_to(base)
+                
+                # Determine directory name for prefix
+                if self._check_basename_collision():
+                    # Use parent/basename format to disambiguate
+                    dir_name = f"{base.parent.name}/{base.name}"
+                else:
+                    # Use just basename
+                    dir_name = base.name
+                
+                return (str(rel_path), dir_name)
+            except ValueError:
+                continue
+        
+        # Path not in any allowed directory
+        allowed_paths = [str(d) for d in allowed_dirs]
+        raise ValueError(
+            f"Path '{absolute_path}' is not within any allowed directory.\n"
+            f"Allowed directories: {allowed_paths}\n"
+            f"Attempted path: {absolute_path}"
+        )
+    
     def _resolve_path(self, relative_path: str) -> Path:
         """
         Resolve and validate a path within any of the allowed directories.
@@ -602,7 +655,7 @@ class ListDirectoryTool(FileSystemTool):
         "Consider using filesystem_directory_tree with max_depth=1 for hierarchical overview",
     ]
     
-    def _run(self, path: str = ".", include_sizes: bool = False, sort_by: str = "name") -> str:
+    def _run(self, path: str = ".", include_sizes: bool = False, sort_by: str = "name", max_results: Optional[int] = 200) -> str:
         """List directory contents."""
         try:
             target = self._resolve_path(path)
@@ -618,7 +671,8 @@ class ListDirectoryTool(FileSystemTool):
                 entry_info = {
                     'name': entry.name,
                     'is_dir': entry.is_dir(),
-                    'size': entry.stat().st_size if entry.is_file() else 0
+                    'size': entry.stat().st_size if entry.is_file() else 0,
+                    'path': entry
                 }
                 entries.append(entry_info)
             
@@ -628,6 +682,18 @@ class ListDirectoryTool(FileSystemTool):
             else:
                 entries.sort(key=lambda x: x['name'].lower())
             
+            # Apply limit
+            total_count = len(entries)
+            truncated = False
+            if max_results is not None and total_count > max_results:
+                entries = entries[:max_results]
+                truncated = True
+            
+            # Get directory name for multi-directory configs
+            allowed_dirs = self._get_all_allowed_directories()
+            has_multiple_dirs = len(allowed_dirs) > 1
+            _, dir_name = self._get_relative_path_from_allowed_dirs(target) if has_multiple_dirs else ("", "")
+            
             # Format output
             lines = []
             total_files = 0
@@ -636,7 +702,12 @@ class ListDirectoryTool(FileSystemTool):
             
             for entry in entries:
                 prefix = "[DIR] " if entry['is_dir'] else "[FILE]"
-                name = entry['name']
+                
+                # Add directory prefix for multi-directory configs
+                if has_multiple_dirs:
+                    name = f"{dir_name}/{entry['name']}"
+                else:
+                    name = entry['name']
                 
                 if include_sizes and not entry['is_dir']:
                     size_str = self._format_size(entry['size'])
@@ -665,6 +736,10 @@ class ListDirectoryTool(FileSystemTool):
                     summary += f"\nCombined size: {self._format_size(total_size)}"
                 result += summary
             
+            if truncated:
+                result += f"\n\n⚠️  OUTPUT TRUNCATED: Showing {len(entries)} of {total_count} entries from '{dir_name if has_multiple_dirs else path}' (max_results={max_results})"
+                result += "\n   To see more: increase max_results or list a specific subdirectory"
+            
             # Add note about how to access files
             result += "\n\nNote: Access files using paths shown above (e.g., 'agents/file.md' for items in agents/ directory)"
             
@@ -818,23 +893,34 @@ class SearchFilesTool(FileSystemTool):
             else:
                 matches = sorted(all_matches)
             
-            # Format results
-            base = Path(self.base_directory).resolve()
+            # Format results with directory prefixes for multi-directory configs
+            allowed_dirs = self._get_all_allowed_directories()
+            has_multiple_dirs = len(allowed_dirs) > 1
             results = []
+            search_dir_name = None
             
             for match in matches:
-                rel_path = match.relative_to(base)
+                if has_multiple_dirs:
+                    rel_path_str, dir_name = self._get_relative_path_from_allowed_dirs(match)
+                    display_path = f"{dir_name}/{rel_path_str}"
+                    if search_dir_name is None:
+                        search_dir_name = dir_name
+                else:
+                    rel_path_str = str(match.relative_to(Path(self.base_directory).resolve()))
+                    display_path = rel_path_str
+                
                 if match.is_dir():
-                    results.append(f"📁 {rel_path}/")
+                    results.append(f"📁 {display_path}/")
                 else:
                     size = self._format_size(match.stat().st_size)
-                    results.append(f"📄 {rel_path} ({size})")
+                    results.append(f"📄 {display_path} ({size})")
             
             header = f"Found {total_count} matches for '{pattern}':\n\n"
             output = header + "\n".join(results)
             
             if truncated:
-                output += f"\n\n⚠️  OUTPUT TRUNCATED: Showing {max_results} of {total_count} results (max_results={max_results})"
+                location_str = f"from '{search_dir_name}' " if search_dir_name else ""
+                output += f"\n\n⚠️  OUTPUT TRUNCATED: Showing {max_results} of {total_count} results {location_str}(max_results={max_results})"
                 output += "\n   To see more: increase max_results or use a more specific pattern"
             
             return output

alita_sdk/community/inventory/__init__.py

@@ -85,6 +85,13 @@ from .ingestion import (
 # Retrieval Toolkit - for querying graphs
 from .retrieval import InventoryRetrievalApiWrapper
 
+# Toolkit utilities - for configuration and instantiation
+from .toolkit_utils import (
+    load_toolkit_config,
+    get_llm_for_config,
+    get_source_toolkit,
+)
+
 # Core graph types
 from .knowledge_graph import KnowledgeGraph, Citation
 
@@ -187,6 +194,11 @@ __all__ = [
     'InventoryRetrievalToolkit',
     'InventoryRetrievalApiWrapper',
     
+    # Toolkit utilities
+    'load_toolkit_config',
+    'get_llm_for_config',
+    'get_source_toolkit',
+    
     # Core types
     'KnowledgeGraph',
     'Citation',

alita_sdk/community/inventory/toolkit.py

@@ -15,7 +15,7 @@ from pydantic import BaseModel, Field, ConfigDict, create_model
 
 from .retrieval import InventoryRetrievalApiWrapper
 from ...tools.base.tool import BaseAction
-from ...tools.utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...tools.utils import clean_string, get_max_toolkit_length
 
 
 class InventoryRetrievalToolkit(BaseToolkit):
@@ -144,17 +144,21 @@ class InventoryRetrievalToolkit(BaseToolkit):
         # Build tool mapping
         tool_map = {t['name']: t for t in available_tools}
         
-        # Create tools with toolkit prefix
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
+        # Use clean toolkit name for context (max 1000 chars in description)
+        toolkit_context = f" [Toolkit: {clean_string(toolkit_name, 0)}]" if toolkit_name else ''
         
         tools = []
         for tool_name in selected_tools:
             if tool_name in tool_map:
                 tool_info = tool_map[tool_name]
+                # Add toolkit context to description with character limit
+                description = tool_info['description']
+                if toolkit_context and len(description + toolkit_context) <= 1000:
+                    description = description + toolkit_context
                 tools.append(BaseAction(
                     api_wrapper=api_wrapper,
-                    name=f"{prefix}{tool_name}",
-                    description=tool_info['description'],
+                    name=tool_name,
+                    description=description,
                     args_schema=tool_info['args_schema']
                 ))