astraagent 2.25.6

package/astra/core/config.py

@@ -0,0 +1,247 @@
+"""
+Configuration management for AstraAgent.
+Handles all agent settings, API keys, and runtime parameters.
+"""
+
+import os
+import json
+from dataclasses import dataclass, field, asdict
+from typing import Optional, Dict, Any, List
+from pathlib import Path
+from enum import Enum
+
+# Load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    # If python-dotenv not installed, just use os.getenv
+    pass
+
+
+class LogLevel(Enum):
+    """Logging verbosity levels."""
+    DEBUG = "debug"
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+    CRITICAL = "critical"
+
+
+class ExecutionMode(Enum):
+    """Agent execution modes."""
+    AUTONOMOUS = "autonomous"      # Fully autonomous
+    SUPERVISED = "supervised"       # Requires approval for actions
+    INTERACTIVE = "interactive"     # Step-by-step with user
+    DRY_RUN = "dry_run"            # Simulate without execution
+
+
+@dataclass
+class LLMConfig:
+    """Configuration for the LLM backend - Local Server."""
+    provider: str = "local"
+    model: str = "default"
+    api_key: Optional[str] = None
+    api_base: Optional[str] = None
+    temperature: float = 0.7
+    max_tokens: int = 4096
+    top_p: float = 1.0
+    frequency_penalty: float = 0.0
+    presence_penalty: float = 0.0
+    timeout: int = 120
+    max_retries: int = 3
+    
+    def __post_init__(self):
+        # Try to get API key from environment if not provided
+        if not self.api_key:
+            self.api_key = os.getenv("LOCAL_API_KEY")
+        if not self.api_base:
+            self.api_base = os.getenv("LOCAL_API_BASE") or "http://localhost:8000/api/v1"
+    
+    def validate(self) -> None:
+        """Validate configuration is complete."""
+        if not self.api_key or not self.api_key.strip():
+            raise ValueError(
+                "LOCAL_API_KEY is not set. Please:\n"
+                "  1. Copy .env.template to .env\n"
+                "  2. Set LOCAL_API_KEY=your-key in .env\n"
+                "  Or set environment variable:\n"
+                f"     Windows: set LOCAL_API_KEY=your-key\n"
+                f"     Linux/Mac: export LOCAL_API_KEY=your-key"
+            )
+
+
+@dataclass
+class ToolConfig:
+    """Configuration for tool system."""
+    enabled_tools: List[str] = field(default_factory=lambda: ["all"])
+    disabled_tools: List[str] = field(default_factory=list)
+    tool_timeout: int = 300
+    max_tool_retries: int = 2
+    sandbox_enabled: bool = True
+    allow_shell_commands: bool = True
+    allow_network_access: bool = True
+    allow_file_write: bool = True
+    restricted_paths: List[str] = field(default_factory=list)
+    allowed_extensions: List[str] = field(default_factory=lambda: [
+        ".py", ".js", ".ts", ".json", ".yaml", ".yml", ".md", 
+        ".txt", ".html", ".css", ".sh", ".bat", ".ps1"
+    ])
+
+
+@dataclass
+class MemoryConfig:
+    """Configuration for memory system."""
+    enabled: bool = True
+    max_short_term_items: int = 100
+    max_long_term_items: int = 10000
+    persistence_path: Optional[str] = None
+    auto_save: bool = True
+    save_interval: int = 60  # seconds
+    embedding_model: str = "text-embedding-3-small"
+    similarity_threshold: float = 0.75
+
+
+@dataclass
+class SafetyConfig:
+    """Configuration for safety guardrails."""
+    enabled: bool = True
+    max_actions_per_task: int = 100
+    max_execution_time: int = 3600  # 1 hour
+    require_approval_for: List[str] = field(default_factory=lambda: [
+        "shell_dangerous",
+        "file_delete",
+        "network_external",
+        "system_modify"
+    ])
+    blocked_commands: List[str] = field(default_factory=lambda: [
+        "rm -rf /",
+        "format",
+        "mkfs",
+        "dd if=",
+        ":(){:|:&};:",
+    ])
+    allowed_domains: List[str] = field(default_factory=list)  # Empty = all allowed
+    max_file_size_mb: int = 100
+    enable_content_filter: bool = True
+
+
+@dataclass
+class LoggingConfig:
+    """Configuration for logging."""
+    level: LogLevel = LogLevel.INFO
+    log_to_file: bool = True
+    log_to_console: bool = True
+    log_directory: str = "./logs"
+    max_log_files: int = 10
+    log_format: str = "%(asctime)s | %(levelname)s | %(name)s | %(message)s"
+    include_timestamps: bool = True
+    include_tool_outputs: bool = True
+
+
+@dataclass
+class AgentConfig:
+    """Master configuration for AstraAgent."""
+    # Identity
+    name: str = "AstraAgent"
+    version: str = "1.0.0"
+    description: str = "Autonomous AI Agent"
+    
+    # Execution
+    mode: ExecutionMode = ExecutionMode.AUTONOMOUS
+    max_iterations: int = 50
+    reflection_enabled: bool = True
+    planning_enabled: bool = True
+    self_correction_enabled: bool = True
+    
+    # Workspace
+    workspace_path: str = "./"
+    artifacts_path: str = "./artifacts"
+    temp_path: str = "./temp"
+    
+    # Sub-configurations
+    llm: LLMConfig = field(default_factory=LLMConfig)
+    tools: ToolConfig = field(default_factory=ToolConfig)
+    memory: MemoryConfig = field(default_factory=MemoryConfig)
+    safety: SafetyConfig = field(default_factory=SafetyConfig)
+    logging: LoggingConfig = field(default_factory=LoggingConfig)
+    
+    # Advanced
+    parallel_execution: bool = False
+    max_parallel_tasks: int = 4
+    enable_caching: bool = True
+    cache_ttl: int = 3600
+    
+    def __post_init__(self):
+        """Initialize paths and validate configuration."""
+        # Create necessary directories
+        for path_attr in ['workspace_path', 'artifacts_path', 'temp_path']:
+            path = Path(getattr(self, path_attr))
+            path.mkdir(parents=True, exist_ok=True)
+        
+        # Set memory persistence path if not set
+        if self.memory.enabled and not self.memory.persistence_path:
+            self.memory.persistence_path = str(Path(self.workspace_path) / ".astra_memory")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert config to dictionary."""
+        return asdict(self)
+    
+    def save(self, path: str):
+        """Save configuration to JSON file."""
+        with open(path, 'w') as f:
+            json.dump(self.to_dict(), f, indent=2, default=str)
+    
+    @classmethod
+    def load(cls, path: str) -> 'AgentConfig':
+        """Load configuration from JSON file."""
+        with open(path, 'r') as f:
+            data = json.load(f)
+        return cls.from_dict(data)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'AgentConfig':
+        """Create config from dictionary."""
+        # Handle nested configs
+        if 'llm' in data and isinstance(data['llm'], dict):
+            data['llm'] = LLMConfig(**data['llm'])
+        if 'tools' in data and isinstance(data['tools'], dict):
+            data['tools'] = ToolConfig(**data['tools'])
+        if 'memory' in data and isinstance(data['memory'], dict):
+            data['memory'] = MemoryConfig(**data['memory'])
+        if 'safety' in data and isinstance(data['safety'], dict):
+            data['safety'] = SafetyConfig(**data['safety'])
+        if 'logging' in data and isinstance(data['logging'], dict):
+            if 'level' in data['logging']:
+                data['logging']['level'] = LogLevel(data['logging']['level'])
+            data['logging'] = LoggingConfig(**data['logging'])
+        if 'mode' in data:
+            data['mode'] = ExecutionMode(data['mode'])
+        
+        return cls(**data)
+    
+    @classmethod
+    def from_env(cls) -> 'AgentConfig':
+        """Create config from environment variables."""
+        config = cls()
+        
+        # Override from environment
+        if os.getenv("ASTRA_MODE"):
+            config.mode = ExecutionMode(os.getenv("ASTRA_MODE"))
+        if os.getenv("ASTRA_WORKSPACE"):
+            config.workspace_path = os.getenv("ASTRA_WORKSPACE")
+        if os.getenv("ASTRA_MODEL"):
+            config.llm.model = os.getenv("ASTRA_MODEL")
+        if os.getenv("ASTRA_PROVIDER"):
+            config.llm.provider = os.getenv("ASTRA_PROVIDER")
+        
+        # Check for Local Server API key
+        if os.getenv("LOCAL_API_KEY"):
+            config.llm.api_key = os.getenv("LOCAL_API_KEY")
+        if os.getenv("LOCAL_API_BASE"):
+            config.llm.api_base = os.getenv("LOCAL_API_BASE")
+        
+        if os.getenv("ASTRA_MAX_ITERATIONS"):
+            config.max_iterations = int(os.getenv("ASTRA_MAX_ITERATIONS"))
+        
+        return config