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

{amd_gaia-0.15.2.dist-info → amd_gaia-0.15.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-gaia
-Version: 0.15.2
+Version: 0.15.3
 Summary: GAIA is a lightweight agent framework designed for the edge and AI PCs.
 Home-page: https://github.com/amd/gaia
 Author: AMD
@@ -24,6 +24,7 @@ Requires-Dist: accelerate
 Requires-Dist: python-dotenv
 Requires-Dist: aiohttp
 Requires-Dist: rich
+Requires-Dist: requests
 Requires-Dist: watchdog>=2.1.0
 Requires-Dist: pillow>=9.0.0
 Provides-Extra: api

{amd_gaia-0.15.2.dist-info → amd_gaia-0.15.3.dist-info}/RECORD

@@ -1,16 +1,16 @@
-amd_gaia-0.15.2.dist-info/licenses/LICENSE.md,sha256=yIF_ozJFJ83xmRHBrFVeGoc12JVoCphi1cy07CsfroQ,1083
+amd_gaia-0.15.3.dist-info/licenses/LICENSE.md,sha256=yIF_ozJFJ83xmRHBrFVeGoc12JVoCphi1cy07CsfroQ,1083
 gaia/__init__.py,sha256=4SNDd1YBqgMNkH71EY3x81E_CSM4gc3Wl7GClCl1KTI,843
-gaia/cli.py,sha256=sjgL2Ch7Zs0gSclHCdDfuw-lFHRaIzI0-fQ-aWGVYKQ,220283
+gaia/cli.py,sha256=XVeH4gPwNKtZFiB1BRzXWMdPbBMX-I9SQExhHGVhmCQ,229473
 gaia/logger.py,sha256=lrE9P2uL97TO35rfRyNMOdjo_BcNlvlym2N18B4sT7Y,6560
 gaia/perf_analysis.py,sha256=RJjv8d52zkbZzPlv7lLLwtQS7qiQY7VX-g-W0skcdyU,11070
 gaia/security.py,sha256=O2XKjAEGkjleWN-MKQPXgk6C4k_n-K4X2OYAdm6YtDA,6816
 gaia/util.py,sha256=QYOjlm4dEJePwptjMJOkVGYXbw7wAee4o4P1KOUKicY,1569
-gaia/version.py,sha256=WRkdcNEUd-2Zi922mMofuQyPsGTDnxUCP8Q-YNQWf10,2840
+gaia/version.py,sha256=wXv7VMa67cVUCUNBTglC1chdHs0T6hx5h4ACCNNcSvo,2840
 gaia/agents/__init__.py,sha256=-xX8KhEOt3OglQnHJh_fh2WlRibvnNptOsRMzpkUb-c,471
 gaia/agents/base/__init__.py,sha256=rgZ1-KKULJpy337UWHaEyU-SPTmqbUHTjBuaiAI87I8,364
-gaia/agents/base/agent.py,sha256=q2UrK-Fa16EC5xASK-F2eJtsG5RJp2f8nbSZM3Avav0,94355
+gaia/agents/base/agent.py,sha256=_aEQXgMiEev2PbFKNM_JPprdfLJVHuN1arhUxL09tx0,104720
 gaia/agents/base/api_agent.py,sha256=vjFGufBikYcgigjWPxNP-IGJl3joyHsT43mr7uOXs4I,3906
-gaia/agents/base/console.py,sha256=Y-pTmzy7ap3EvoyjhVFfvb5xqAhrXeOaxPlTS_yOXEM,69801
+gaia/agents/base/console.py,sha256=efBfN9DTjVZkBzqOdAeuyxBXYArrEUyq-4ir70jRfxs,78183
 gaia/agents/base/errors.py,sha256=UQs9Zt-Rhl480d5h3qoAzC8UKZsdy-gQGzrDlE73DFA,7011
 gaia/agents/base/mcp_agent.py,sha256=j53OIpwvn-bGOnq5UxlctLcX65mjaxKPziveWRiGalw,2352
 gaia/agents/base/tools.py,sha256=zghYt8bVCiwEz-zcrsQpNom3e_JMoY4X1VgP_siYywU,2796
@@ -99,6 +99,8 @@ gaia/agents/routing/system_prompt.py,sha256=XOuQRYvsh4GDLwUcSoutf2Zz-YwTq3g33GVu
 gaia/agents/summarize/__init__.py,sha256=hZgWtAdKKiyHjc1sy0HwAiwJeQFyKd_Mo5cHC7Pzdrc,247
 gaia/agents/summarize/agent.py,sha256=xoe-6Bb2QeaDWA11GLkfLutaMYnx3ucDMpwJCxAFzdU,37679
 gaia/agents/summarize/prompts.py,sha256=Is-WrNnbl86acOCh_Y_eYhfY6PU68_MUhO1k0AUaEtY,6266
+gaia/agents/tools/__init__.py,sha256=Lmo8XNPbEBcBMudi1sWbPdRMkhl8huFZwefvseA3qNQ,302
+gaia/agents/tools/file_tools.py,sha256=vMEhwjb_c1u-SNOUK5Ac_lXTKd_Bo70Ff2UwGjXQriI,29118
 gaia/api/__init__.py,sha256=BGWiO7Hg75lgf5cjujA4QIl65L-gbpR7WYiRlQI7f6A,641
 gaia/api/agent_registry.py,sha256=tmYZOE7KTn1UdXtEGSTLtmBmMsQMVlhVgX-0m--UrHY,7997
 gaia/api/app.py,sha256=63xtdFjHxQczzl9D5f6zme9chORtj8wD3-Zdcbg3hE8,10081
@@ -140,18 +142,18 @@ gaia/eval/webapp/public/app.js,sha256=-qqTCqIXLJ2JKBMcXnNPM04XBD-ioX_4JzR50Gr3qu
 gaia/eval/webapp/public/index.html,sha256=qfo97RArd77bSMAWQrNnUVp7_To8e6XCXV3iHqNmw1E,4738
 gaia/eval/webapp/public/styles.css,sha256=toAtkMtfYB16ZApZXTQQ6i7IYC2S9CahUT6oj1a0B0Y,71381
 gaia/installer/__init__.py,sha256=NvQ-XNJsAnjwfyF2YwkerNcztTMDMxKXf_9NGoNYQdY,503
-gaia/installer/init_command.py,sha256=vx9PMct5Uxs_6PKvsN4GbsqE_AmPStJHenk72ka43VE,47854
-gaia/installer/lemonade_installer.py,sha256=DL8ziWnXubbj-5Tc7eBuEO_Sfa7t1Y7cLq0qUKqxXYg,21611
+gaia/installer/init_command.py,sha256=UDxHMR3wb6TQI-C_pPQHBFayPD4TomTV09l17igvSVc,63506
+gaia/installer/lemonade_installer.py,sha256=sxG1mMqTQYZs-9bMFPN4uwDZPMeGpvzo1W-PvgByj_U,24393
 gaia/llm/__init__.py,sha256=fdu07-f682NvxLR-wgwaY5s0L-ZEphXD0sfUp-LAQn8,355
 gaia/llm/base_client.py,sha256=g9JXXWslQLdwzeURnddmZzj7u27VMu2nILm5OSCA05Q,1701
 gaia/llm/exceptions.py,sha256=aQ7sk_KtwW5MlJP6HFFnnKDhevNfsNIvYOTF8UUJnaQ,413
 gaia/llm/factory.py,sha256=IkbCHCIbLADWuU1_HoooJTDhr0xu_mDQVzhxtc-S9tY,2508
-gaia/llm/lemonade_client.py,sha256=pv-736R1Qpodfa2XLLJQesV4I7WeEu69SYjrMke7P_w,126772
-gaia/llm/lemonade_manager.py,sha256=R93qqmsuYqSf4gLG0R1BTTkZxu9WCLmKCHLvzu1K_yE,11017
+gaia/llm/lemonade_client.py,sha256=Zm1O4iyruLv_sZ9lg1RU-K0c6No5hC1rWhc5lg7dIGg,132213
+gaia/llm/lemonade_manager.py,sha256=gAetsv8xafBZYsEoH6yS-zvieUj02dSdzzsnFta003I,13276
 gaia/llm/vlm_client.py,sha256=D4bV-XmO2-Lu34qFGqP5l0zN6p0x85to3aJRGQ4SA0A,13247
 gaia/llm/providers/__init__.py,sha256=h2qbDWhOfE9G6YHgLMYzTw5bv1L63cSGuwEzML6iJU8,329
 gaia/llm/providers/claude.py,sha256=r22rb8sZR-wt-LzNEDU49drftPOn5ZY1MrftO65_78M,3262
-gaia/llm/providers/lemonade.py,sha256=BbeSzNzqRnEiUn9P55TYUf9kuGN_NL1ib9XO9pPH5Sw,4004
+gaia/llm/providers/lemonade.py,sha256=iA9CaZo09uMMJgac8xFq1_oDEhf0YSiIy0QJl9TWFrI,4398
 gaia/llm/providers/openai_provider.py,sha256=eU1NRtSPCfW0wKiK2ePcWNczvwt1E4koD9aL_D6cwc0,2502
 gaia/mcp/agent_mcp_server.py,sha256=YU_BgRRK0VPaJJgO1CgFodFuYrO6XoRCo3cfltpTlQY,10152
 gaia/mcp/blender_mcp_client.py,sha256=M5aI5esMPFqVrxYE0m7_xPAI-y8eTMgorlcflfyMM44,4967
@@ -175,8 +177,8 @@ gaia/testing/mocks.py,sha256=ojqkCYXBEAiMqiv6icfCVKOL6fw0RIc-Cv67uq08jNI,13895
 gaia/utils/__init__.py,sha256=HnxwoKZvPoYWcSdf-iu5rYzwySkpuqSAwyFSFIHjBNI,733
 gaia/utils/file_watcher.py,sha256=ZTlPvAmrSUtm42he29YCHfy3YByg03C4tFTPWM4ZsEc,22388
 gaia/utils/parsing.py,sha256=PZ0aizm-pVox2pAqZA8Xc-k10c-bAXh71C5RkbyniyA,6695
-amd_gaia-0.15.2.dist-info/METADATA,sha256=N7qMt4xbXkMCfIXQ25E6KTELtE8Rwk7SDpJnk7TffMA,8463
-amd_gaia-0.15.2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-amd_gaia-0.15.2.dist-info/entry_points.txt,sha256=nXsKQ1xgHlGqfZgBksSaEOL0TA8zV7lXJaxVSlgsygE,223
-amd_gaia-0.15.2.dist-info/top_level.txt,sha256=79yz2gLmqK4bFQkuN8_cnHVY-lobuVT0Ww4YoO6OFvU,5
-amd_gaia-0.15.2.dist-info/RECORD,,
+amd_gaia-0.15.3.dist-info/METADATA,sha256=acP0sK3j-2ediOZ1kgr-hPi3vR4ULZfIRqsGqgD0Eg4,8487
+amd_gaia-0.15.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+amd_gaia-0.15.3.dist-info/entry_points.txt,sha256=nXsKQ1xgHlGqfZgBksSaEOL0TA8zV7lXJaxVSlgsygE,223
+amd_gaia-0.15.3.dist-info/top_level.txt,sha256=79yz2gLmqK4bFQkuN8_cnHVY-lobuVT0Ww4YoO6OFvU,5
+amd_gaia-0.15.3.dist-info/RECORD,,

{amd_gaia-0.15.2.dist-info → amd_gaia-0.15.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gaia/agents/base/agent.py

@@ -68,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,
@@ -78,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,
     ):
@@ -100,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.
@@ -120,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
         )
@@ -154,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 }.
 
@@ -220,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):
         """
@@ -747,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.
@@ -1137,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
@@ -1156,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"
@@ -1214,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",
@@ -1265,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)
@@ -1426,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"
@@ -1450,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")
@@ -1789,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}")
@@ -1865,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."
@@ -1906,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