alita-sdk 0.3.465__py3-none-any.whl → 0.3.497__py3-none-any.whl

alita_sdk/cli/agent/__init__.py

@@ -0,0 +1,5 @@
+"""Default agent prompts for Alita CLI."""
+
+from .default import DEFAULT_PROMPT
+
+__all__ = ['DEFAULT_PROMPT']

alita_sdk/cli/agent/default.py

@@ -61,6 +61,22 @@ Use `update_plan` when:
 - Ambiguity requires breaking down the approach
 - The user requests step-wise execution
 
+### Resuming existing plans
+
+**Important**: Before creating a new plan, check if there's already an existing plan in progress:
+
+- If the user says "continue" or similar, look at the current plan state shown in tool results
+- If steps are already marked as completed (☑), **do not create a new plan** — continue executing the remaining uncompleted steps
+- Only use `update_plan` to create a **new** plan when starting a fresh task
+- Use `complete_step` to mark steps done as you finish them
+
+When resuming after interruption (e.g., tool limit reached):
+
+1. Review which steps are already completed (☑)
+2. Identify the next uncompleted step (☐)
+3. Continue execution from that step — do NOT recreate the plan
+4. Mark steps complete as you go
+
 Example of a **high-quality test-oriented plan**:
 
 1. Reproduce failure locally  
@@ -69,7 +85,7 @@ Example of a **high-quality test-oriented plan**:
 4. Patch locator + stabilize assertions  
 5. Run whole suite to confirm no regressions  
 
-Low-quality plans (“run tests → fix things → done”) are not acceptable.
+Low-quality plans ("run tests → fix things → done") are not acceptable.
 
 ---
 
@@ -101,6 +117,72 @@ Common use cases include:
 
 ---
 
+## Handling files
+
+### CRITICAL: File creation and modification rules
+
+**NEVER output entire file contents in your response.** Always use tools to write files.
+
+When creating or modifying files:
+
+1. **Use incremental writes for new files**: Create files in logical sections using multiple tool calls:
+   - First call: Create file with initial structure (imports, class definition header)
+   - Subsequent calls: Add methods, functions, or sections one at a time using edit/append
+   - This prevents context overflow and ensures each part is properly written
+
+2. **Use edit tools for modifications**: Use `filesystem_edit_file` for precise text replacement instead of rewriting entire files
+
+3. **Never dump code in chat**: If you find yourself about to write a large code block in your response, STOP and use a file tool instead
+
+Example - creating a test file correctly:
+```
+# Call 1: Create file with structure
+filesystem_write_file("test_api.py", "import pytest\\nimport requests\\n\\n")
+
+# Call 2: Append first test class/method
+filesystem_append_file("test_api.py", "class TestAPI:\\n    def test_health(self):\\n        assert requests.get('/health').status_code == 200\\n")
+
+# Call 3: Append second test method  
+filesystem_append_file("test_api.py", "\\n    def test_auth(self):\\n        assert requests.get('/protected').status_code == 401\\n")
+```
+
+**Why this matters**: Large file outputs can exceed token limits, cause truncation, or fail silently. Incremental writes are reliable and verifiable.
+
+### Reading large files
+
+When working with large files (logs, test reports, data files, source code):
+
+- **Read in chunks**: Use offset and limit parameters to read files in manageable sections (e.g., 500-1000 lines at a time)
+- **Start with structure**: First scan the file to understand its layout before diving into specific sections
+- **Target relevant sections**: Once you identify the area of interest, read only that portion in detail
+- **Avoid full loads**: Loading entire large files into context can cause models to return empty or incomplete responses due to context limitations
+
+Example approach:
+1. Read first 100 lines to understand file structure
+2. Search/grep for relevant patterns to locate target sections
+3. Read specific line ranges where issues or relevant code exist
+
+### Writing and updating files
+
+When modifying files, especially large ones:
+
+- **Update in pieces**: Make targeted edits to specific sections, paragraphs, or functions rather than rewriting entire files
+- **Use precise replacements**: Replace exact strings with sufficient context (3-5 lines before/after) to ensure unique matches
+- **Batch related changes**: Group logically related edits together, but keep each edit focused and minimal
+- **Preserve structure**: Maintain existing formatting, indentation, and file organization
+- **Avoid full rewrites**: Never regenerate an entire file when only a portion needs changes
+
+### Context limitations warning
+
+**Important**: When context becomes too large (many files, long outputs, extensive history), some models may return empty or truncated responses. If you notice this:
+
+- Summarize previous findings before continuing
+- Focus on one file or task at a time
+- Clear irrelevant context from consideration
+- Break complex operations into smaller, sequential steps
+
+---
+
 ## Sandbox and approvals
 
 Sandboxing and approval rules are identical to coding agents, but framed around testing actions:

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,7 +148,8 @@ 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()
+                        # 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)
@@ -168,7 +189,6 @@ def build_agent_data_structure(agent_def: Dict[str, Any], toolkit_configs: list,
                 'settings': toolkit_config,
                 'selected_tools': toolkit_config.get('selected_tools', [])
             })
-    
     return {
         'instructions': agent_def.get('system_prompt', ''),
         'tools': tools,
@@ -181,8 +201,6 @@ def build_agent_data_structure(agent_def: Dict[str, Any], toolkit_configs: list,
             'model_name': llm_model,
             'max_tokens': llm_max_tokens,
             'temperature': llm_temperature,
-            'top_p': 1.0,
-            'top_k': 0,
             'integration_uid': None,
             'indexer_config': {
                 'ai_model': 'langchain_openai.ChatOpenAI',

alita_sdk/cli/agent_ui.py

@@ -79,7 +79,7 @@ def print_help():
         padding=(0, 1),
     )
     
-    table.add_column("Command", style="bold yellow", no_wrap=True, width=14)
+    table.add_column("Command", style="bold yellow", no_wrap=True, width=16)
     table.add_column("Description", style="white")
     
     table.add_row("/clear", "Clear conversation history")
@@ -89,10 +89,13 @@ def print_help():
     table.add_row("/model", "Switch to a different model (preserves history)")
     table.add_row("/reload", "Reload agent from file (hot reload)")
     table.add_row("/mode", "Set approval mode: always, auto, yolo")
-    table.add_row("/dir <path>", "Mount workspace directory for terminal access")
+    table.add_row("/dir [add|rm] <path>", "Add/remove/list allowed directories")
+    table.add_row("/inventory <path>", "Load inventory/knowledge graph from JSON file")
     table.add_row("/session", "List or resume previous sessions with plans")
     table.add_row("/add_mcp", "Add an MCP server (preserves history)")
     table.add_row("/add_toolkit", "Add a toolkit (preserves history)")
+    table.add_row("/rm_mcp", "Remove an MCP server")
+    table.add_row("/rm_toolkit", "Remove a toolkit")
     table.add_row("/help", "Show this help")
     table.add_row("exit", "End conversation")
     
@@ -142,9 +145,11 @@ def print_welcome(agent_name: str, model: str = "gpt-4o", temperature: float = 0
     right_content.append("/mode", style="bold yellow")
     right_content.append("        Set approval mode\n", style="dim")
     right_content.append("/dir", style="bold yellow")
-    right_content.append("         Mount directory\n", style="dim")
+    right_content.append("         Add/list directories\n", style="dim")
     right_content.append("/session", style="bold yellow")
     right_content.append("     List/resume sessions\n", style="dim")
+    right_content.append("/inventory", style="bold yellow")
+    right_content.append("   Load knowledge graph\n", style="dim")
     right_content.append("/add_mcp", style="bold yellow")
     right_content.append("     Add MCP server\n", style="dim")
     right_content.append("/add_toolkit", style="bold yellow")
@@ -193,6 +198,11 @@ def display_output(agent_name: str, message: str, output: str):
     console.print(f"\n[bold cyan]🤖 Agent: {agent_name}[/bold cyan]\n")
     console.print(f"[bold]Message:[/bold] {message}\n")
     console.print("[bold]Response:[/bold]")
+    
+    # Ensure output is a string
+    if not isinstance(output, str):
+        output = str(output)
+    
     if any(marker in output for marker in ['```', '**', '##', '- ', '* ']):
         console.print(Markdown(output))
     else: