astraagent 2.25.6

package/astra/core/__init__.py

@@ -0,0 +1,8 @@
+"""Core components of AstraAgent."""
+
+from astra.core.agent import AstraAgent
+from astra.core.config import AgentConfig
+from astra.core.state import AgentState
+from astra.core.memory import MemoryManager
+
+__all__ = ["AstraAgent", "AgentConfig", "AgentState", "MemoryManager"]

package/astra/core/agent.py

@@ -0,0 +1,515 @@
+"""
+AstraAgent Core - The Main Autonomous Agent.
+An elite AI agent more powerful than ChatGPT, Claude, or Gemini.
+"""
+
+import asyncio
+import json
+import logging
+import sys
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+from pathlib import Path
+
+from astra.core.config import AgentConfig, ExecutionMode
+from astra.core.state import AgentState, Action, ActionStatus, Task, TaskStatus, Plan
+from astra.core.memory import MemoryManager
+from astra.core.reasoning import ReasoningEngine, ReasoningMode
+from astra.tools.base import ToolRegistry, create_default_registry, ToolResult
+from astra.tools.memory_tool import MemoryTool
+from astra.llm import create_provider, Message, LLMProvider, LLMResponse
+from astra.prompts import SYSTEM_PROMPT, build_system_prompt, get_chain_of_thought_prompt
+
+
+class AstraAgent:
+    """
+    The main autonomous agent.
+    An elite AI agent more powerful than ChatGPT, Claude, or Gemini.
+    """
+    
+    def __init__(self, config: AgentConfig = None):
+        self.config = config or AgentConfig()
+        self.state = AgentState()
+        self.logger = self._setup_logging()
+        
+        # Initialize Unified Memory System
+        self.memory = MemoryManager(
+            persistence_path=self.config.memory.persistence_path or "./.astra_memory",
+            auto_save=self.config.memory.auto_save
+        )
+        MemoryTool.set_memory_manager(self.memory)
+        
+        # Initialize Reasoning Engine
+        self.reasoning = ReasoningEngine()
+        
+        self.tools = create_default_registry()
+        self.llm: Optional[LLMProvider] = None
+        
+        # Message history
+        self.messages: List[Message] = []
+        self._format_retry_count: int = 0
+        
+        # Check for API key upfront
+        self._validate_config()
+    
+    def _validate_config(self):
+        """Validate configuration and warn about issues."""
+        if not self.config.llm.api_key:
+            self.logger.warning("No API key found. Set LOCAL_API_KEY environment variable.")
+    
+    def _setup_logging(self) -> logging.Logger:
+        """Setup logging with UTF-8 support for Windows."""
+        logger = logging.getLogger("AstraAgent")
+        logger.setLevel(getattr(logging, self.config.logging.level.value.upper()))
+        
+        # Clear existing handlers
+        logger.handlers.clear()
+        
+        if self.config.logging.log_to_console:
+            # Use UTF-8 encoding for console on Windows
+            handler = logging.StreamHandler(sys.stdout)
+            handler.setFormatter(logging.Formatter(self.config.logging.log_format))
+            # Set encoding to handle unicode on Windows
+            if hasattr(handler.stream, 'reconfigure'):
+                try:
+                    handler.stream.reconfigure(encoding='utf-8', errors='replace')
+                except Exception:
+                    pass
+            logger.addHandler(handler)
+        
+        if self.config.logging.log_to_file:
+            log_dir = Path(self.config.logging.log_directory)
+            log_dir.mkdir(parents=True, exist_ok=True)
+            log_file = log_dir / f"astra_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+            handler = logging.FileHandler(log_file, encoding='utf-8')
+            handler.setFormatter(logging.Formatter(self.config.logging.log_format))
+            logger.addHandler(handler)
+        
+        return logger
+    
+    def _init_llm(self):
+        """Initialize LLM provider."""
+        if self.llm is None:
+            if not self.config.llm.api_key:
+                raise RuntimeError(
+                    f"No API key configured for local server.\n"
+                    f"Please set the environment variable:\n"
+                    f"  set LOCAL_API_KEY=your-key\n"
+                    f"Or add it to config.json"
+                )
+            
+            self.llm = create_provider(
+                self.config.llm.provider,
+                api_key=self.config.llm.api_key,
+                model=self.config.llm.model,
+                api_base=self.config.llm.api_base
+            )
+    
+    def _build_system_prompt(self, mode: str = "default", goal: Optional[str] = None) -> str:
+        """Build the enhanced system prompt with context."""
+        tool_names = ", ".join(self.tools.list_enabled())
+        
+        # Build base prompt
+        prompt = build_system_prompt(
+            workspace=self.config.workspace_path,
+            tools=tool_names,
+            mode=mode
+        )
+        
+        # Add memory context if available
+        try:
+            user_facts = self.memory.get_user_facts()
+            if user_facts:
+                prompt += "\n\n=== KNOWN ABOUT USER ===\n"
+                for fact in user_facts[:5]:
+                    prompt += f"- {fact.content}\n"
+
+            # Add compact goal-aware memory context
+            if goal:
+                goal_context = self.memory.get_goal_context(goal, max_items=12)
+                if goal_context:
+                    prompt += "\n\n=== MEMORY CONTEXT FOR CURRENT GOAL ===\n"
+                    prompt += goal_context[:3000]
+        except (AttributeError, ValueError, KeyError) as e:
+            self.logger.warning(f"Failed to retrieve user facts: {e}")
+        except Exception as e:
+            self.logger.error(f"Unexpected error retrieving user facts: {e}", exc_info=True)
+        
+        return prompt
+
+    def _is_unstructured_final(self, raw_content: str, parsed: Dict[str, Any]) -> bool:
+        """Detect plain-text final answers that violate required JSON format."""
+        if "final" not in parsed:
+            return False
+        content = (raw_content or "").strip()
+        if not content:
+            return False
+        if "```json" in content:
+            return False
+        if content.startswith("{") and content.endswith("}"):
+            return False
+        return True
+    
+    def _parse_response(self, content: str) -> Optional[Dict[str, Any]]:
+        """Parse response from LLM. Handles both JSON and plain text."""
+        if not content or not content.strip():
+            return None
+        
+        content = content.strip()
+        
+        # Try to extract JSON from markdown code blocks
+        if "```json" in content:
+            start = content.find("```json") + 7
+            end = content.find("```", start)
+            if end > start:
+                json_content = content[start:end].strip()
+                try:
+                    parsed = json.loads(json_content)
+                    if parsed:
+                        return parsed
+                except json.JSONDecodeError:
+                    pass
+        elif "```" in content:
+            start = content.find("```") + 3
+            end = content.find("```", start)
+            if end > start:
+                json_content = content[start:end].strip()
+                if json_content.startswith("{"):
+                    try:
+                        parsed = json.loads(json_content)
+                        if parsed:
+                            return parsed
+                    except json.JSONDecodeError:
+                        pass
+        
+        # Try to find JSON object in content
+        if "{" in content and "}" in content:
+            start = content.find("{")
+            end = content.rfind("}") + 1
+            if end > start:
+                try:
+                    parsed = json.loads(content[start:end])
+                    if parsed:
+                        return parsed
+                except json.JSONDecodeError:
+                    pass
+        
+        # Smart intent detection for common commands in natural language responses
+        content_lower = content.lower()
+        
+        # Check for lock computer intent
+        if any(kw in content_lower for kw in ["lock screen", "lockworkstation", "lock computer", "locking"]):
+            if "rundll32" in content_lower or "win + l" in content_lower or "lock" in content_lower:
+                return {
+                    "thought": "User wants to lock the computer, executing now",
+                    "action": "system_control",
+                    "args": {"action": "lock"}
+                }
+        
+        # Check for volume intent
+        if "volume" in content_lower and any(char.isdigit() for char in content):
+            import re
+            match = re.search(r'(\d+)\s*%?', content)
+            if match:
+                return {
+                    "thought": "Setting volume to specified percentage",
+                    "action": "system_control",
+                    "args": {"action": "set_volume", "value": match.group(1)}
+                }
+        
+        # Check for mute intent
+        if "mute" in content_lower and ("volume" in content_lower or "sound" in content_lower):
+            return {
+                "thought": "Muting the system",
+                "action": "system_control",
+                "args": {"action": "mute"}
+            }
+        
+        # If no valid JSON found, treat the entire response as a final answer
+        # This handles models that don't output structured JSON
+        return {"final": content}
+    
+    async def _execute_tool(self, tool_name: str, args: Dict[str, Any]) -> ToolResult:
+        """Execute a tool."""
+        self.logger.debug(f"Executing tool: {tool_name} with args: {args}")
+        
+        result = await self.tools.execute(tool_name, **args)
+        
+        if result.success:
+            self.logger.debug(f"Tool {tool_name} succeeded")
+            for artifact in result.artifacts:
+                self.state.add_artifact(artifact)
+        else:
+            self.logger.warning(f"Tool {tool_name} failed: {result.error}")
+        
+        return result
+    
+    async def _think(self, goal: str) -> LLMResponse:
+        """Generate next action from LLM."""
+        self._init_llm()
+        
+        # Update messages if needed
+        if not self.messages:
+            self.messages.append(Message(role="system", content=self._build_system_prompt(goal=goal)))
+            self.messages.append(Message(role="user", content=f"Goal: {goal}"))
+
+            # Add memory context as explicit runtime instruction message
+            try:
+                memory_context = self.memory.get_goal_context(goal, max_items=10)
+                if memory_context:
+                    self.messages.append(
+                        Message(
+                            role="user",
+                            content=(
+                                "Memory context (must be considered while planning):\n"
+                                f"{memory_context[:2500]}"
+                            )
+                        )
+                    )
+            except Exception as e:
+                self.logger.warning(f"Failed to attach memory context: {e}")
+        
+        # Add context about recent actions
+        if self.state.action_history:
+            recent = self.state.action_history[-5:]
+            context = "Recent actions:\n"
+            for action in recent:
+                status = "[OK]" if action.status == ActionStatus.SUCCESS else "[FAIL]"
+                result_preview = str(action.result)[:200] if action.result else ""
+                context += f"{status} {action.tool}: {result_preview}\n"
+            
+            # Add as context if not already in messages
+            if len(self.messages) <= 2:
+                self.messages.append(Message(role="assistant", content=context))
+        
+        response = await self.llm.generate(
+            self.messages,
+            tools=self.tools.get_all_schemas(),
+            temperature=self.config.llm.temperature,
+            max_tokens=self.config.llm.max_tokens
+        )
+        
+        self.state.total_tokens_used += response.tokens_used
+        return response
+    
+    async def step(self) -> bool:
+        """Execute one step of the agent loop. Returns True if complete."""
+        self.state.increment_iteration()
+        self.logger.debug(f"=== Iteration {self.state.iteration_count} ===")
+        
+        # Check iteration limit
+        if self.state.iteration_count > self.config.max_iterations:
+            self.logger.warning("Max iterations reached")
+            return True
+        
+        # Get LLM response
+        try:
+            response = await self._think(self.state.current_goal)
+        except RuntimeError as e:
+            # API key or configuration error - stop immediately
+            self.logger.debug(str(e))
+            self.state.last_error = str(e)
+            return True  # Stop the loop
+        except Exception as e:
+            self.logger.debug(f"LLM error: {e}")
+            self.state.last_error = str(e)
+            return False
+        
+        # Handle tool calls from LLM
+        if response.tool_calls:
+            if response.content:
+                self.memory.remember_conversation("assistant", response.content, metadata={"kind": "tool_call"})
+            for tc in response.tool_calls:
+                action = Action(
+                    tool=tc["name"],
+                    args=tc["arguments"],
+                    thought=response.content
+                )
+                action.mark_executing()
+                
+                result = await self._execute_tool(tc["name"], tc["arguments"])
+                
+                if result.success:
+                    action.mark_success(result.output)
+                else:
+                    action.mark_failed(result.error)
+                
+                self.state.record_action(action)
+                
+                # Add result to messages for context
+                self.messages.append(Message(
+                    role="tool",
+                    content=result.output or result.error or "No output",
+                    tool_call_id=tc.get("id"),
+                    name=tc["name"]
+                ))
+            return False
+        
+        # Parse response content
+        parsed = self._parse_response(response.content)
+        
+        if not parsed:
+            self.logger.warning("Could not parse LLM response")
+            self.messages.append(Message(role="assistant", content=response.content))
+            return False
+        
+        # Check for final response
+        if "final" in parsed:
+            if self._is_unstructured_final(response.content, parsed) and self._format_retry_count < 2:
+                self._format_retry_count += 1
+                self.messages.append(Message(
+                    role="user",
+                    content=(
+                        "FORMAT ERROR: Reply ONLY with valid JSON in the required schema. "
+                        "Do not output plain text."
+                    )
+                ))
+                return False
+
+            self._format_retry_count = 0
+            self.logger.debug(f"Task complete: {parsed['final']}")
+            self.memory.remember_conversation("assistant", str(parsed["final"]))
+            return True
+        
+        # Check for action
+        if "action" in parsed:
+            self._format_retry_count = 0
+            action = Action(
+                tool=parsed["action"],
+                args=parsed.get("args", {}),
+                thought=parsed.get("thought", "")
+            )
+            if action.thought:
+                self.memory.remember_conversation("assistant", action.thought, metadata={"kind": "reasoning"})
+            action.mark_executing()
+            
+            result = await self._execute_tool(action.tool, action.args)
+            
+            if result.success:
+                action.mark_success(result.output)
+            else:
+                action.mark_failed(result.error)
+            
+            self.state.record_action(action)
+            
+            # Remember the action in memory
+            self.memory.remember_action(
+                action=f"{action.tool}({action.args})",
+                result=str(result.output or result.error)[:500],
+                success=result.success
+            )
+            
+            # Add action result to messages
+            self.messages.append(Message(role="assistant", content=json.dumps(parsed)))
+            self.messages.append(Message(
+                role="user",
+                content=f"Tool result: {result.output or result.error}"
+            ))
+            return False
+        
+        # No clear action, continue
+        self.messages.append(Message(role="assistant", content=response.content))
+        return False
+    
+    async def run(self, goal: str) -> str:
+        """Run the agent to accomplish a goal."""
+        # Validate configuration before starting
+        try:
+            self.config.llm.validate()
+        except ValueError as e:
+            self.logger.debug(f"Configuration error: {e}")
+            return f"Failed to start: {e}"
+        
+        self.logger.debug(f"Starting AstraAgent with goal: {goal}")
+        self.state.set_goal(goal)
+        self.state.is_running = True
+        self.messages = []  # Reset messages
+        self._format_retry_count = 0
+        
+        # Remember the goal
+        self.memory.remember(
+            content=f"User goal: {goal}",
+            memory_type="conversation",
+            importance=0.8,
+            tags=["goal", "user_request"]
+        )
+        self.memory.remember_conversation("user", goal, metadata={"kind": "goal"})
+        
+        try:
+            while not await self.step():
+                if self.state.is_paused:
+                    self.logger.debug("Agent paused")
+                    break
+                
+                # Check for critical errors
+                if self.state.last_error and "No API key" in self.state.last_error:
+                    break
+                
+                # Brief pause between iterations
+                await asyncio.sleep(0.1)
+            
+            summary = self._generate_summary()
+            self.logger.debug(f"Agent finished:\n{summary}")
+            
+            # Remember the result
+            self.memory.remember(
+                content=f"Completed goal: {goal} | Result: {summary[:200]}",
+                memory_type="observation",
+                importance=0.7,
+                tags=["completion", "result"]
+            )
+            
+            return summary
+            
+        except KeyboardInterrupt:
+            self.logger.debug("Agent interrupted")
+            return "Agent was interrupted by user."
+        except Exception as e:
+            self.logger.error(f"Agent error: {e}")
+            return f"Agent failed with error: {e}"
+        finally:
+            self.state.is_running = False
+            self.memory.save()
+    
+    def _generate_summary(self) -> str:
+        """Generate a summary of what was accomplished."""
+        # Use ASCII-safe characters for Windows compatibility
+        summary = [
+            f"=== AstraAgent Session Summary ===",
+            f"Goal: {self.state.current_goal}",
+            f"Iterations: {self.state.iteration_count}",
+            f"Actions: {self.state.total_actions} (OK:{self.state.successful_actions} FAIL:{self.state.failed_actions})",
+            f"Success Rate: {self.state.success_rate:.1f}%",
+            f"Duration: {self.state.duration:.1f}s",
+            f"Tokens Used: {self.state.total_tokens_used}",
+        ]
+        
+        if self.state.last_error:
+            summary.append(f"\nLast Error: {self.state.last_error}")
+        
+        if self.state.artifacts_created:
+            summary.append(f"\nArtifacts Created:")
+            for artifact in self.state.artifacts_created:
+                summary.append(f"  - {artifact}")
+        
+        if self.state.errors_encountered:
+            summary.append(f"\nErrors Encountered: {len(self.state.errors_encountered)}")
+        
+        return "\n".join(summary)
+    
+    def pause(self):
+        """Pause the agent."""
+        self.state.is_paused = True
+    
+    def resume(self):
+        """Resume the agent."""
+        self.state.is_paused = False
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get current agent status."""
+        return self.state.to_dict()
+    
+    def shutdown(self):
+        """Shutdown the agent cleanly."""
+        self.memory.shutdown()
+        self.logger.debug("AstraAgent shutdown complete")