amd-gaia 0.15.1__py3-none-any.whl → 0.15.3__py3-none-any.whl

gaia/agents/base/agent.py

@@ -61,10 +61,6 @@ class Agent(abc.ABC):
     STATE_ERROR_RECOVERY = "ERROR_RECOVERY"
     STATE_COMPLETION = "COMPLETION"
 
-    # Define tools that can execute directly without requiring a plan
-    # Subclasses can override this to specify domain-specific simple tools
-    SIMPLE_TOOLS = []
-
     def __init__(
         self,
         use_claude: bool = False,
@@ -72,7 +68,7 @@ class Agent(abc.ABC):
         claude_model: str = "claude-sonnet-4-20250514",
         base_url: Optional[str] = None,
         model_id: str = None,
-        max_steps: int = 5,
+        max_steps: int = 20,
         debug_prompts: bool = False,
         show_prompts: bool = False,
         output_dir: str = None,
@@ -82,6 +78,7 @@ class Agent(abc.ABC):
         debug: bool = False,
         output_handler=None,
         max_plan_iterations: int = 3,
+        max_consecutive_repeats: int = 4,
         min_context_size: int = 32768,
         skip_lemonade: bool = False,
     ):
@@ -104,6 +101,7 @@ class Agent(abc.ABC):
             debug: If True, enables debug output for troubleshooting (default: False)
             output_handler: Custom OutputHandler for displaying agent output (default: None, creates console based on silent_mode)
             max_plan_iterations: Maximum number of plan-execute-replan cycles (default: 3, 0 = unlimited)
+            max_consecutive_repeats: Maximum consecutive identical tool calls before stopping (default: 4)
             min_context_size: Minimum context size required for this agent (default: 32768).
             skip_lemonade: If True, skip Lemonade server initialization (default: False).
                           Use this when connecting to a different OpenAI-compatible backend.
@@ -124,6 +122,7 @@ class Agent(abc.ABC):
         self.debug = debug
         self.last_result = None  # Store the most recent result
         self.max_plan_iterations = max_plan_iterations
+        self.max_consecutive_repeats = max_consecutive_repeats
         self._current_query: Optional[str] = (
             None  # Store current query for error context
         )
@@ -158,17 +157,17 @@ class Agent(abc.ABC):
             self.console = self._create_console()
 
         # Initialize LLM client for local model
-        self.system_prompt = self._get_system_prompt()
+        # Note: System prompt will be composed after _register_tools()
+        # This allows mixins to be initialized first (in subclass __init__)
 
         # Register tools for this agent
         self._register_tools()
 
-        # Update system prompt with available tools and response format
-        tools_description = self._format_tools_for_prompt()
-        self.system_prompt += f"\n\n==== AVAILABLE TOOLS ====\n{tools_description}\n"
+        # Note: system_prompt is now a lazy @property that composes on first access
+        # Tool descriptions and response format are added in _compose_system_prompt()
 
-        # Add JSON response format instructions (shared across all agents)
-        self.system_prompt += """
+        # Store response format template for use in composition
+        self._response_format_template = """
 ==== RESPONSE FORMAT ====
 You must respond ONLY in valid JSON. No text before { or after }.
 
@@ -224,13 +223,127 @@ You must respond ONLY in valid JSON. No text before { or after }.
         if self.show_prompts:
             self.console.print_prompt(self.system_prompt, "Initial System Prompt")
 
-    @abc.abstractmethod
+    def _get_mixin_prompts(self) -> list[str]:
+        """
+        Auto-collect system prompt fragments from inherited mixins.
+
+        Checks for mixin methods following the pattern: get_*_system_prompt()
+        Override this method to modify, reorder, or filter mixin prompts.
+
+        Returns:
+            List of prompt fragments from mixins (empty list if no mixins provide prompts)
+
+        Example:
+            def _get_mixin_prompts(self) -> list[str]:
+                prompts = super()._get_mixin_prompts()
+                # Modify SD prompt
+                if prompts:
+                    prompts[0] = prompts[0].replace("whimsical", "serious")
+                return prompts
+        """
+        prompts = []
+
+        # Check for SD mixin prompts
+        if hasattr(self, "get_sd_system_prompt"):
+            fragment = self.get_sd_system_prompt()
+            if fragment:
+                prompts.append(fragment)
+
+        # Check for VLM mixin prompts
+        if hasattr(self, "get_vlm_system_prompt"):
+            fragment = self.get_vlm_system_prompt()
+            if fragment:
+                prompts.append(fragment)
+
+        # Add more mixin checks here as new prompt-providing mixins are created
+
+        return prompts
+
+    def _compose_system_prompt(self) -> str:
+        """
+        Compose final system prompt from mixin fragments + agent custom + tools + format.
+
+        Override this method for complete control over prompt composition order.
+
+        Returns:
+            Composed system prompt string
+
+        Example:
+            def _compose_system_prompt(self) -> str:
+                # Custom composition order
+                parts = [
+                    "Base instructions first",
+                    *self._get_mixin_prompts(),
+                    self._get_system_prompt(),
+                ]
+                return "\n\n".join(p for p in parts if p)
+        """
+        parts = []
+
+        # Add mixin prompts first
+        parts.extend(self._get_mixin_prompts())
+
+        # Add agent-specific prompt
+        custom = self._get_system_prompt()
+        if custom:
+            parts.append(custom)
+
+        # Add tool descriptions (if tools registered)
+        if hasattr(self, "_format_tools_for_prompt"):
+            tools_description = self._format_tools_for_prompt()
+            if tools_description:
+                parts.append(f"==== AVAILABLE TOOLS ====\n{tools_description}")
+
+        # Add response format (if template set)
+        if hasattr(self, "_response_format_template"):
+            parts.append(self._response_format_template)
+
+        return "\n\n".join(p for p in parts if p)
+
+    @property
+    def system_prompt(self) -> str:
+        """
+        Lazy-loaded system prompt composed from mixins + agent custom.
+
+        Computed on first access to allow mixins to initialize in subclass __init__.
+
+        To see the prompt for debugging:
+            print(agent.system_prompt)
+        """
+        if not hasattr(self, "_system_prompt_cache"):
+            self._system_prompt_cache = self._compose_system_prompt()
+        return self._system_prompt_cache
+
+    @system_prompt.setter
+    def system_prompt(self, value: str):
+        """Allow setting system prompt (used when appending tool descriptions)."""
+        self._system_prompt_cache = value
+
     def _get_system_prompt(self) -> str:
         """
-        Generate the system prompt for the agent.
-        Subclasses must implement this to provide domain-specific prompts.
+        Return agent-specific system prompt additions.
+
+        Default implementation returns empty string (use only mixin prompts).
+        Override this method to add custom instructions.
+
+        When using mixins that provide prompts (e.g., SDToolsMixin):
+        - Return "" to use only mixin prompts (default behavior)
+        - Return custom instructions to append to mixin prompts
+        - Override _compose_system_prompt() for full control over composition
+
+        Returns:
+            Agent-specific system prompt (empty string by default)
+
+        Example:
+            # Use only mixin prompts (default)
+            def _get_system_prompt(self) -> str:
+                return ""
+
+            # Add custom instructions
+            def _get_system_prompt(self) -> str:
+                return "Always save metadata to logs"
         """
-        raise NotImplementedError("Subclasses must implement _get_system_prompt")
+        return ""  # Default: use only mixin prompts
 
     def _create_console(self):
         """
@@ -280,7 +393,7 @@ You must respond ONLY in valid JSON. No text before { or after }.
         self.console.print_header(f"🛠️ Registered Tools for {self.__class__.__name__}")
         self.console.print_separator()
 
-        for name, tool_info in _TOOL_REGISTRY.items():
+        for name, tool_info in self.get_tools_info().items():
             # Format parameters
             params = []
             for param_name, param_info in tool_info["parameters"].items():
@@ -313,6 +426,14 @@ You must respond ONLY in valid JSON. No text before { or after }.
 
         return None
 
+    def get_tools_info(self) -> Dict[str, Any]:
+        """Get information about all registered tools."""
+        return _TOOL_REGISTRY
+
+    def get_tools(self) -> List[Dict[str, Any]]:
+        """Get a list of registered tools for the agent."""
+        return list(_TOOL_REGISTRY.values())
+
     def _extract_json_from_response(self, response: str) -> Optional[Dict[str, Any]]:
         """
         Apply multiple extraction strategies to find valid JSON in the response.
@@ -743,6 +864,106 @@ You must respond ONLY in valid JSON. No text before { or after }.
         # Valid conversational response - wrap it in expected format
         return {"thought": "", "goal": "", "answer": response.strip()}
 
+    def _resolve_plan_parameters(
+        self, tool_args: Any, step_results: List[Dict[str, Any]], _depth: int = 0
+    ) -> Any:
+        """
+        Recursively resolve placeholder references in tool arguments from previous step results.
+
+        Supports dynamic parameter substitution in multi-step plans:
+        - $PREV.field - Get field from previous step result
+        - $STEP_0.field - Get field from specific step result (0-indexed)
+
+        Args:
+            tool_args: Tool arguments that may contain placeholders
+            step_results: List of results from previously executed steps
+            _depth: Internal recursion depth counter (max 50 levels)
+
+        Returns:
+            Tool arguments with placeholders resolved to actual values
+
+        Examples:
+            >>> step_results = [{"image_path": "/path/to/img.png", "status": "success"}]
+            >>> tool_args = {"image_path": "$PREV.image_path", "style": "dramatic"}
+            >>> resolved = agent._resolve_plan_parameters(tool_args, step_results)
+            >>> resolved
+            {"image_path": "/path/to/img.png", "style": "dramatic"}
+
+        Backward Compatibility:
+            - If no placeholders exist, returns original tool_args unchanged
+            - If placeholder references invalid step/field, returns placeholder string unchanged
+
+        Limitations:
+            - Field names cannot contain dots (e.g., $PREV.user.name not supported - use $PREV.user_name)
+            - Maximum nesting depth of 50 levels to prevent stack overflow
+            - No type checking - resolved values are used as-is (tools should validate inputs)
+        """
+        # Prevent stack overflow from deeply nested structures
+        MAX_DEPTH = 50
+        if _depth > MAX_DEPTH:
+            logger.warning(
+                f"Maximum recursion depth ({MAX_DEPTH}) exceeded in parameter resolution, returning unchanged"
+            )
+            return tool_args
+
+        # Handle dict: recursively resolve each value
+        if isinstance(tool_args, dict):
+            return {
+                k: self._resolve_plan_parameters(v, step_results, _depth + 1)
+                for k, v in tool_args.items()
+            }
+
+        # Handle list: recursively resolve each item
+        elif isinstance(tool_args, list):
+            return [
+                self._resolve_plan_parameters(item, step_results, _depth + 1)
+                for item in tool_args
+            ]
+
+        # Handle string: check for placeholder patterns
+        elif isinstance(tool_args, str):
+            # Handle $PREV.field - get field from previous step
+            if tool_args.startswith("$PREV.") and step_results:
+                field = tool_args[6:]  # Strip "$PREV."
+                prev_result = step_results[-1]
+                if isinstance(prev_result, dict) and field in prev_result:
+                    resolved = prev_result[field]
+                    logger.debug(
+                        f"Resolved {tool_args} -> {resolved} from previous step result"
+                    )
+                    return resolved
+                else:
+                    logger.warning(
+                        f"Could not resolve {tool_args}: field '{field}' not found in previous result"
+                    )
+                    return tool_args  # Return unchanged if field not found
+
+            # Handle $STEP_N.field - get field from specific step
+            match = re.match(r"\$STEP_(\d+)\.(.+)", tool_args)
+            if match and step_results:
+                step_idx = int(match.group(1))
+                field = match.group(2)
+                if 0 <= step_idx < len(step_results):
+                    step_result = step_results[step_idx]
+                    if isinstance(step_result, dict) and field in step_result:
+                        resolved = step_result[field]
+                        logger.debug(
+                            f"Resolved {tool_args} -> {resolved} from step {step_idx} result"
+                        )
+                        return resolved
+                    else:
+                        logger.warning(
+                            f"Could not resolve {tool_args}: field '{field}' not found in step {step_idx} result"
+                        )
+                else:
+                    logger.warning(
+                        f"Could not resolve {tool_args}: step {step_idx} out of range (0-{len(step_results)-1})"
+                    )
+                return tool_args  # Return unchanged if reference invalid
+
+        # For all other types (int, float, bool, None), return unchanged
+        return tool_args
+
     def _execute_tool(self, tool_name: str, tool_args: Dict[str, Any]) -> Any:
         """
         Execute a tool by name with the provided arguments.
@@ -1133,9 +1354,10 @@ You must respond ONLY in valid JSON. No text before { or after }.
         steps_taken = 0
         final_answer = None
         error_count = 0
-        last_tool_call = None  # Track the last tool call to prevent loops
+        tool_call_history = []  # Track recent tool calls to detect loops (last 5 calls)
         last_error = None  # Track the last error to handle it properly
-        previous_outputs = []  # Track previous tool outputs
+        previous_outputs = []  # Track previous tool outputs (truncated for context)
+        step_results = []  # Track full tool results for parameter substitution
 
         # Reset state management
         self.execution_state = self.STATE_PLANNING
@@ -1152,7 +1374,7 @@ You must respond ONLY in valid JSON. No text before { or after }.
         steps_limit = max_steps if max_steps is not None else self.max_steps
 
         # Print initial message with max steps info
-        self.console.print_processing_start(user_input, steps_limit)
+        self.console.print_processing_start(user_input, steps_limit, self.model_id)
         logger.debug(f"Using max_steps: {steps_limit}")
 
         prompt = f"User request: {user_input}\n\n"
@@ -1177,43 +1399,6 @@ You must respond ONLY in valid JSON. No text before { or after }.
             steps_taken += 1
             logger.debug(f"Step {steps_taken}/{steps_limit}")
 
-            # Check if we're at the limit and ask user if they want to continue
-            if steps_taken == steps_limit and final_answer is None:
-                # Show what was accomplished
-                max_steps_msg = self._generate_max_steps_message(
-                    conversation, steps_taken, steps_limit
-                )
-                self.console.print_warning(max_steps_msg)
-
-                # Ask user if they want to continue (skip in silent mode OR if stdin is not available)
-                # IMPORTANT: Never call input() in API/CI contexts to avoid blocking threads
-                import sys
-
-                has_stdin = sys.stdin and sys.stdin.isatty()
-                if has_stdin and not (
-                    hasattr(self, "silent_mode") and self.silent_mode
-                ):
-                    try:
-                        response = (
-                            input("\nContinue with 50 more steps? (y/n): ")
-                            .strip()
-                            .lower()
-                        )
-                        if response in ["y", "yes"]:
-                            steps_limit += 50
-                            self.console.print_info(
-                                f"✓ Continuing with {steps_limit} total steps...\n"
-                            )
-                        else:
-                            self.console.print_info("Stopping at user request.")
-                            break
-                    except (EOFError, KeyboardInterrupt):
-                        self.console.print_info("\nStopping at user request.")
-                        break
-                else:
-                    # Silent mode - just stop
-                    break
-
             # Display current step
             self.console.print_step_header(steps_taken, steps_limit)
 
@@ -1247,6 +1432,9 @@ You must respond ONLY in valid JSON. No text before { or after }.
                     tool_name = next_step["tool"]
                     tool_args = next_step["tool_args"]
 
+                    # Resolve dynamic parameters from previous step results
+                    tool_args = self._resolve_plan_parameters(tool_args, step_results)
+
                     # Create a parsed response structure as if it came from the LLM
                     parsed = {
                         "thought": f"Executing step {self.current_step + 1} of the plan",
@@ -1298,6 +1486,9 @@ You must respond ONLY in valid JSON. No text before { or after }.
                         }
                     )
 
+                    # Store full result for parameter substitution in subsequent plan steps
+                    step_results.append(tool_result)
+
                     # Share tool output with subsequent LLM calls
                     messages.append(
                         self._create_tool_message(tool_name, truncated_result)
@@ -1459,9 +1650,14 @@ You must respond ONLY in valid JSON. No text before { or after }.
                     )
 
                     # Create a specific error recovery prompt
+                    last_tool = (
+                        tool_call_history[-1][0]
+                        if tool_call_history
+                        else "unknown tool"
+                    )
                     prompt = (
                         "TOOL EXECUTION FAILED!\n\n"
-                        f"You were trying to execute: {last_tool_call[0] if last_tool_call else 'unknown tool'}\n"
+                        f"You were trying to execute: {last_tool}\n"
                         f"Error: {last_error}\n\n"
                         f"Original task: {user_input}\n\n"
                         f"Current plan step {self.current_step + 1}/{self.total_plan_steps} failed.\n"
@@ -1483,6 +1679,7 @@ You must respond ONLY in valid JSON. No text before { or after }.
                     self.current_plan = None
                     self.current_step = 0
                     self.total_plan_steps = 0
+                    step_results.clear()  # Clear stale results from failed plan
 
                 elif self.execution_state == self.STATE_COMPLETION:
                     self.console.print_state_info("COMPLETION: Finalizing response")
@@ -1668,9 +1865,6 @@ You must respond ONLY in valid JSON. No text before { or after }.
             # Add assistant response to messages for chat history
             messages.append({"role": "assistant", "content": response})
 
-            # Validate the response has a plan if required
-            self._validate_plan_required(parsed, steps_taken)
-
             # If the LLM needs to create a plan first, re-prompt it specifically for that
             if "needs_plan" in parsed and parsed["needs_plan"]:
                 # Prepare a special prompt that specifically requests a plan
@@ -1825,8 +2019,15 @@ You must respond ONLY in valid JSON. No text before { or after }.
                 for i, step in enumerate(parsed["plan"]):
                     if not isinstance(step, dict):
                         invalid_steps.append((i, type(step).__name__, step))
-                    elif "tool" not in step or "tool_args" not in step:
-                        invalid_steps.append((i, "missing fields", step))
+                    elif "tool" not in step:
+                        invalid_steps.append((i, "missing tool field", step))
+                    elif "tool_args" not in step:
+                        # Auto-add empty tool_args for convenience
+                        # LLMs sometimes omit this for tools with all optional parameters
+                        step["tool_args"] = {}
+                        logger.debug(
+                            f"Auto-added empty tool_args for step {i+1}: {step['tool']}"
+                        )
 
                 if invalid_steps:
                     logger.error(f"Invalid plan steps found: {invalid_steps}")
@@ -1901,12 +2102,27 @@ You must respond ONLY in valid JSON. No text before { or after }.
                 # Start progress indicator for tool execution
                 self.console.start_progress(f"Executing {tool_name}")
 
-                # Check for repeated tool calls
-                if last_tool_call == (tool_name, str(tool_args)):
+                # Check for repeated tool calls (allow up to 3 identical calls)
+                current_call = (tool_name, str(tool_args))
+                tool_call_history.append(current_call)
+
+                # Keep only last 5 calls for loop detection
+                if len(tool_call_history) > 5:
+                    tool_call_history.pop(0)
+
+                # Count consecutive identical calls
+                consecutive_count = 0
+                for call in reversed(tool_call_history):
+                    if call == current_call:
+                        consecutive_count += 1
+                    else:
+                        break
+
+                # Stop after max_consecutive_repeats identical calls
+                if consecutive_count >= self.max_consecutive_repeats:
                     # Stop progress indicator
                     self.console.stop_progress()
 
-                    logger.warning(f"Detected repeated tool call: {tool_name}")
                     # Force a final answer if the same tool is called repeatedly
                     final_answer = (
                         f"Task completed with {tool_name}. No further action needed."
@@ -1942,9 +2158,6 @@ You must respond ONLY in valid JSON. No text before { or after }.
                 # Share tool output with subsequent LLM calls
                 messages.append(self._create_tool_message(tool_name, truncated_result))
 
-                # Update last tool call
-                last_tool_call = (tool_name, str(tool_args))
-
                 # For single-step plans, we still need to let the LLM process the result
                 # This is especially important for RAG queries where the LLM needs to
                 # synthesize the retrieved information into a coherent answer
@@ -2015,8 +2228,42 @@ You must respond ONLY in valid JSON. No text before { or after }.
                 self.console.print_final_answer(final_answer, streaming=self.streaming)
                 break
 
-            # Validate plan required
-            self._validate_plan_required(parsed, steps_taken)
+            # Check if we're at the limit and ask user if they want to continue
+            if steps_taken == steps_limit and final_answer is None:
+                # Show what was accomplished
+                max_steps_msg = self._generate_max_steps_message(
+                    conversation, steps_taken, steps_limit
+                )
+                self.console.print_warning(max_steps_msg)
+
+                # Ask user if they want to continue (skip in silent mode OR if stdin is not available)
+                # IMPORTANT: Never call input() in API/CI contexts to avoid blocking threads
+                import sys
+
+                has_stdin = sys.stdin and sys.stdin.isatty()
+                if has_stdin and not (
+                    hasattr(self, "silent_mode") and self.silent_mode
+                ):
+                    try:
+                        response = (
+                            input("\nContinue with 50 more steps? (y/n): ")
+                            .strip()
+                            .lower()
+                        )
+                        if response in ["y", "yes"]:
+                            steps_limit += 50
+                            self.console.print_info(
+                                f"✓ Continuing with {steps_limit} total steps...\n"
+                            )
+                        else:
+                            self.console.print_info("Stopping at user request.")
+                            break
+                    except (EOFError, KeyboardInterrupt):
+                        self.console.print_info("\nStopping at user request.")
+                        break
+                else:
+                    # Silent mode - just stop
+                    break
 
         # Print completion message
         self.console.print_completion(steps_taken, steps_limit)
@@ -2132,46 +2379,3 @@ You must respond ONLY in valid JSON. No text before { or after }.
             List of error messages
         """
         return self.error_history
-
-    def _validate_plan_required(self, parsed: Dict[str, Any], step: int) -> None:
-        """
-        Validate that the response includes a plan when required by the agent.
-
-        Args:
-            parsed: The parsed response from the LLM
-            step: The current step number
-        """
-        # Skip validation if we're not in planning mode or if we're already executing a plan
-        if self.execution_state != self.STATE_PLANNING or self.current_plan is not None:
-            return
-
-        # Allow simple single-tool operations without requiring a plan
-        if "tool" in parsed and step == 1:
-            tool_name = parsed.get("tool", "")
-            # List of tools that can execute directly without a plan
-            simple_tools = self.SIMPLE_TOOLS
-            if tool_name in simple_tools:
-                logger.debug(f"Allowing direct execution of simple tool: {tool_name}")
-                return
-
-        # Check if plan is missing on the first step
-        # BUT: Allow direct answers without plans (for simple conversational queries)
-        if "plan" not in parsed and "answer" not in parsed and step == 1:
-            warning_msg = f"No plan found in step {step} response. The agent should create a plan for all tasks."
-            logger.warning(warning_msg)
-            self.console.print_warning(warning_msg)
-
-            # For the first step, we'll add a flag to indicate we need to re-prompt for a plan
-            parsed["needs_plan"] = True
-
-            # If there's a tool in the response, store it but don't execute it yet
-            if "tool" in parsed:
-                parsed["deferred_tool"] = parsed["tool"]
-                parsed["deferred_tool_args"] = parsed.get("tool_args", {})
-                # Remove the tool so it won't be executed
-                del parsed["tool"]
-                if "tool_args" in parsed:
-                    del parsed["tool_args"]
-
-            # Set state to indicate we need planning
-            self.execution_state = self.STATE_PLANNING

gaia/agents/base/api_agent.py

@@ -13,7 +13,6 @@ Inheritance patterns:
     - Future: FooAgent(MCPAgent, ApiAgent, Agent) - Multiple inheritance
 """
 
-
 from typing import Any, Dict
 
 from .agent import Agent