tunacode-cli 0.0.47__py3-none-any.whl → 0.0.48__py3-none-any.whl

tunacode/core/agents/main.py

@@ -30,11 +30,9 @@ except ImportError:
     STREAMING_AVAILABLE = False
 
 from tunacode.constants import READ_ONLY_TOOLS
-from tunacode.core.recursive import RecursiveTaskExecutor
 from tunacode.core.state import StateManager
 from tunacode.core.token_usage.api_response_parser import ApiResponseParser
 from tunacode.core.token_usage.cost_calculator import CostCalculator
-from tunacode.exceptions import ToolBatchingJSONError, UserAbortError
 from tunacode.services.mcp import get_mcp_servers
 from tunacode.tools.bash import bash
 from tunacode.tools.glob import glob
@@ -473,17 +471,9 @@ async def _process_node(
         if not has_tool_calls and buffering_callback:
             for part in node.model_response.parts:
                 if hasattr(part, "content") and isinstance(part.content, str):
-                    try:
-                        await extract_and_execute_tool_calls(
-                            part.content, buffering_callback, state_manager
-                        )
-                    except ToolBatchingJSONError as e:
-                        # Handle JSON parsing failure after retries
-                        logger.error(f"Tool batching JSON error: {e}")
-                        if state_manager.session.show_thoughts:
-                            await ui.error(str(e))
-                        # Continue processing other parts instead of failing completely
-                        continue
+                    await extract_and_execute_tool_calls(
+                        part.content, buffering_callback, state_manager
+                    )
 
     # Final flush: disabled temporarily while fixing the parallel execution design
     # The buffer is not being used in the current implementation
@@ -752,335 +742,251 @@ async def process_request(
     tool_callback: Optional[ToolCallback] = None,
     streaming_callback: Optional[callable] = None,
 ) -> AgentRun:
-    try:
-        agent = get_or_create_agent(model, state_manager)
-        mh = state_manager.session.messages.copy()
-        # Get max iterations from config (default: 40)
-        max_iterations = state_manager.session.user_config.get("settings", {}).get(
-            "max_iterations", 40
-        )
-        fallback_enabled = state_manager.session.user_config.get("settings", {}).get(
-            "fallback_response", True
-        )
-
-        # Check if recursive execution is enabled
-        use_recursive = state_manager.session.user_config.get("settings", {}).get(
-            "use_recursive_execution", True
-        )
-        recursive_threshold = state_manager.session.user_config.get("settings", {}).get(
-            "recursive_complexity_threshold", 0.7
-        )
+    agent = get_or_create_agent(model, state_manager)
+    mh = state_manager.session.messages.copy()
+    # Get max iterations from config (default: 40)
+    max_iterations = state_manager.session.user_config.get("settings", {}).get("max_iterations", 40)
+    fallback_enabled = state_manager.session.user_config.get("settings", {}).get(
+        "fallback_response", True
+    )
 
-        # Check if recursive execution should be used
-        if use_recursive and state_manager.session.current_recursion_depth == 0:
-            try:
-                # Initialize recursive executor
-                recursive_executor = RecursiveTaskExecutor(
-                    state_manager=state_manager,
-                    max_depth=state_manager.session.max_recursion_depth,
-                    min_complexity_threshold=recursive_threshold,
-                    default_iteration_budget=max_iterations,
-                )
+    from tunacode.configuration.models import ModelRegistry
+    from tunacode.core.token_usage.usage_tracker import UsageTracker
+
+    parser = ApiResponseParser()
+    registry = ModelRegistry()
+    calculator = CostCalculator(registry)
+    usage_tracker = UsageTracker(parser, calculator, state_manager)
+    response_state = ResponseState()
+
+    # Reset iteration tracking for this request
+    state_manager.session.iteration_count = 0
+
+    # Create a request-level buffer for batching read-only tools across nodes
+    tool_buffer = ToolBuffer()
+
+    # Show TUNACODE.md preview if it was loaded and thoughts are enabled
+    if state_manager.session.show_thoughts and hasattr(state_manager, "tunacode_preview"):
+        from tunacode.ui import console as ui
+
+        await ui.muted(state_manager.tunacode_preview)
+        # Clear the preview after displaying it once
+        delattr(state_manager, "tunacode_preview")
+
+    # Show what we're sending to the API when thoughts are enabled
+    if state_manager.session.show_thoughts:
+        from tunacode.ui import console as ui
+
+        await ui.muted("\n" + "=" * 60)
+        await ui.muted("📤 SENDING TO API:")
+        await ui.muted(f"Message: {message}")
+        await ui.muted(f"Model: {model}")
+        await ui.muted(f"Message History Length: {len(mh)}")
+        await ui.muted("=" * 60)
+
+    async with agent.iter(message, message_history=mh) as agent_run:
+        i = 0
+        async for node in agent_run:
+            state_manager.session.current_iteration = i + 1
+
+            # Handle token-level streaming for model request nodes
+            if streaming_callback and STREAMING_AVAILABLE and Agent.is_model_request_node(node):
+                async with node.stream(agent_run.ctx) as request_stream:
+                    async for event in request_stream:
+                        if isinstance(event, PartDeltaEvent) and isinstance(
+                            event.delta, TextPartDelta
+                        ):
+                            # Stream individual token deltas
+                            if event.delta.content_delta:
+                                await streaming_callback(event.delta.content_delta)
+
+            await _process_node(
+                node,
+                tool_callback,
+                state_manager,
+                tool_buffer,
+                streaming_callback,
+                usage_tracker,
+            )
+            if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
+                if node.result.output:
+                    response_state.has_user_response = True
+            i += 1
+            state_manager.session.iteration_count = i
 
-                # Analyze task complexity
-                complexity_result = await recursive_executor.decomposer.analyze_and_decompose(
-                    message
-                )
+            # Display iteration progress if thoughts are enabled
+            if state_manager.session.show_thoughts:
+                from tunacode.ui import console as ui
 
-                if (
-                    complexity_result.should_decompose
-                    and complexity_result.total_complexity >= recursive_threshold
-                ):
-                    if state_manager.session.show_thoughts:
-                        from tunacode.ui import console as ui
+                await ui.muted(f"\nITERATION: {i}/{max_iterations}")
 
-                        await ui.muted(
-                            f"\n🔄 RECURSIVE EXECUTION: Task complexity {complexity_result.total_complexity:.2f} >= {recursive_threshold}"
-                        )
-                        await ui.muted(f"Reasoning: {complexity_result.reasoning}")
-                        await ui.muted(f"Subtasks: {len(complexity_result.subtasks)}")
+                # Show summary of tools used so far
+                if state_manager.session.tool_calls:
+                    tool_summary = {}
+                    for tc in state_manager.session.tool_calls:
+                        tool_name = tc.get("tool", "unknown")
+                        tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
 
-                    # Execute recursively
-                    success, result, error = await recursive_executor.execute_task(
-                        request=message, parent_task_id=None, depth=0
+                    summary_str = ", ".join(
+                        [f"{name}: {count}" for name, count in tool_summary.items()]
                     )
+                    await ui.muted(f"TOOLS USED: {summary_str}")
 
-                    # For now, fall back to normal execution
-                    # TODO: Properly integrate recursive execution results
-                    pass
-            except Exception as e:
-                logger.warning(f"Recursive execution failed, falling back to normal: {e}")
-                # Continue with normal execution
-
-        from tunacode.configuration.models import ModelRegistry
-        from tunacode.core.token_usage.usage_tracker import UsageTracker
-
-        parser = ApiResponseParser()
-        registry = ModelRegistry()
-        calculator = CostCalculator(registry)
-        usage_tracker = UsageTracker(parser, calculator, state_manager)
-        response_state = ResponseState()
+            if i >= max_iterations:
+                if state_manager.session.show_thoughts:
+                    from tunacode.ui import console as ui
 
-        # Reset iteration tracking for this request
-        state_manager.session.iteration_count = 0
+                    await ui.warning(f"Reached maximum iterations ({max_iterations})")
+                break
 
-        # Create a request-level buffer for batching read-only tools across nodes
-        tool_buffer = ToolBuffer()
+        # Final flush: execute any remaining buffered read-only tools
+        if tool_callback and tool_buffer.has_tasks():
+            import time
 
-        # Show TUNACODE.md preview if it was loaded and thoughts are enabled
-        if state_manager.session.show_thoughts and hasattr(state_manager, "tunacode_preview"):
             from tunacode.ui import console as ui
 
-            await ui.muted(state_manager.tunacode_preview)
-            # Clear the preview after displaying it once
-            delattr(state_manager, "tunacode_preview")
-
-        # Show what we're sending to the API when thoughts are enabled
-        if state_manager.session.show_thoughts:
-            from tunacode.ui import console as ui
+            buffered_tasks = tool_buffer.flush()
+            start_time = time.time()
 
             await ui.muted("\n" + "=" * 60)
-            await ui.muted("📤 SENDING TO API:")
-            await ui.muted(f"Message: {message}")
-            await ui.muted(f"Model: {model}")
-            await ui.muted(f"Message History Length: {len(mh)}")
+            await ui.muted(
+                f"🚀 FINAL BATCH: Executing {len(buffered_tasks)} buffered read-only tools"
+            )
             await ui.muted("=" * 60)
 
-        async with agent.iter(message, message_history=mh) as agent_run:
-            i = 0
-            async for node in agent_run:
-                state_manager.session.current_iteration = i + 1
-
-                # Handle token-level streaming for model request nodes
-                if streaming_callback and STREAMING_AVAILABLE and Agent.is_model_request_node(node):
-                    async with node.stream(agent_run.ctx) as request_stream:
-                        async for event in request_stream:
-                            if isinstance(event, PartDeltaEvent) and isinstance(
-                                event.delta, TextPartDelta
-                            ):
-                                # Stream individual token deltas
-                                if event.delta.content_delta:
-                                    await streaming_callback(event.delta.content_delta)
-
-                await _process_node(
-                    node,
-                    tool_callback,
-                    state_manager,
-                    tool_buffer,
-                    streaming_callback,
-                    usage_tracker,
-                )
-                if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
-                    if node.result.output:
-                        response_state.has_user_response = True
-                i += 1
-                state_manager.session.iteration_count = i
-
-                # Display iteration progress if thoughts are enabled
-                if state_manager.session.show_thoughts:
-                    from tunacode.ui import console as ui
-
-                    await ui.muted(f"\nITERATION: {i}/{max_iterations}")
-
-                    # Show summary of tools used so far
-                    if state_manager.session.tool_calls:
-                        tool_summary = {}
-                        for tc in state_manager.session.tool_calls:
-                            tool_name = tc.get("tool", "unknown")
-                            tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
-
-                        summary_str = ", ".join(
-                            [f"{name}: {count}" for name, count in tool_summary.items()]
-                        )
-                        await ui.muted(f"TOOLS USED: {summary_str}")
-
-                if i >= max_iterations:
-                    if state_manager.session.show_thoughts:
-                        from tunacode.ui import console as ui
-
-                        await ui.warning(f"Reached maximum iterations ({max_iterations})")
-                    break
+            for idx, (part, node) in enumerate(buffered_tasks, 1):
+                tool_desc = f"  [{idx}] {part.tool_name}"
+                if hasattr(part, "args") and isinstance(part.args, dict):
+                    if part.tool_name == "read_file" and "file_path" in part.args:
+                        tool_desc += f" → {part.args['file_path']}"
+                    elif part.tool_name == "grep" and "pattern" in part.args:
+                        tool_desc += f" → pattern: '{part.args['pattern']}'"
+                        if "include_files" in part.args:
+                            tool_desc += f", files: '{part.args['include_files']}'"
+                    elif part.tool_name == "list_dir" and "directory" in part.args:
+                        tool_desc += f" → {part.args['directory']}"
+                    elif part.tool_name == "glob" and "pattern" in part.args:
+                        tool_desc += f" → pattern: '{part.args['pattern']}'"
+                await ui.muted(tool_desc)
+            await ui.muted("=" * 60)
 
-            # Final flush: execute any remaining buffered read-only tools
-            if tool_callback and tool_buffer.has_tasks():
-                import time
+            await execute_tools_parallel(buffered_tasks, tool_callback)
 
-                from tunacode.ui import console as ui
+            elapsed_time = (time.time() - start_time) * 1000
+            sequential_estimate = len(buffered_tasks) * 100
+            speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
 
-                buffered_tasks = tool_buffer.flush()
-                start_time = time.time()
+            await ui.muted(
+                f"✅ Final batch completed in {elapsed_time:.0f}ms "
+                f"(~{speedup:.1f}x faster than sequential)\n"
+            )
 
-                if state_manager.session.show_thoughts:
-                    await ui.muted("\n" + "=" * 60)
-                    await ui.muted(
-                        f"🚀 FINAL BATCH: Executing {len(buffered_tasks)} buffered read-only tools"
-                    )
-                    await ui.muted("=" * 60)
+        # If we need to add a fallback response, create a wrapper
+        if not response_state.has_user_response and i >= max_iterations and fallback_enabled:
+            patch_tool_messages("Task incomplete", state_manager=state_manager)
+            response_state.has_final_synthesis = True
+
+            # Extract context from the agent run
+            tool_calls_summary = []
+            files_modified = set()
+            commands_run = []
+
+            # Analyze message history for context
+            for msg in state_manager.session.messages:
+                if hasattr(msg, "parts"):
+                    for part in msg.parts:
+                        if hasattr(part, "part_kind") and part.part_kind == "tool-call":
+                            tool_name = getattr(part, "tool_name", "unknown")
+                            tool_calls_summary.append(tool_name)
+
+                            # Track specific operations
+                            if tool_name in ["write_file", "update_file"] and hasattr(part, "args"):
+                                if isinstance(part.args, dict) and "file_path" in part.args:
+                                    files_modified.add(part.args["file_path"])
+                            elif tool_name in ["run_command", "bash"] and hasattr(part, "args"):
+                                if isinstance(part.args, dict) and "command" in part.args:
+                                    commands_run.append(part.args["command"])
+
+            # Build fallback response with context
+            fallback = FallbackResponse(
+                summary="Reached maximum iterations without producing a final response.",
+                progress=f"Completed {i} iterations (limit: {max_iterations})",
+            )
 
-                    for idx, (part, node) in enumerate(buffered_tasks, 1):
-                        tool_desc = f"  [{idx}] {part.tool_name}"
-                        if hasattr(part, "args") and isinstance(part.args, dict):
-                            if part.tool_name == "read_file" and "file_path" in part.args:
-                                tool_desc += f" → {part.args['file_path']}"
-                            elif part.tool_name == "grep" and "pattern" in part.args:
-                                tool_desc += f" → pattern: '{part.args['pattern']}'"
-                                if "include_files" in part.args:
-                                    tool_desc += f", files: '{part.args['include_files']}'"
-                            elif part.tool_name == "list_dir" and "directory" in part.args:
-                                tool_desc += f" → {part.args['directory']}"
-                            elif part.tool_name == "glob" and "pattern" in part.args:
-                                tool_desc += f" → pattern: '{part.args['pattern']}'"
-                        await ui.muted(tool_desc)
-                    await ui.muted("=" * 60)
+            # Get verbosity setting
+            verbosity = state_manager.session.user_config.get("settings", {}).get(
+                "fallback_verbosity", "normal"
+            )
 
-                await execute_tools_parallel(buffered_tasks, tool_callback)
+            if verbosity in ["normal", "detailed"]:
+                # Add what was attempted
+                if tool_calls_summary:
+                    tool_counts = {}
+                    for tool in tool_calls_summary:
+                        tool_counts[tool] = tool_counts.get(tool, 0) + 1
+
+                    fallback.issues.append(f"Executed {len(tool_calls_summary)} tool calls:")
+                    for tool, count in sorted(tool_counts.items()):
+                        fallback.issues.append(f"  • {tool}: {count}x")
+
+                if verbosity == "detailed":
+                    if files_modified:
+                        fallback.issues.append(f"\nFiles modified ({len(files_modified)}):")
+                        for f in sorted(files_modified)[:5]:  # Limit to 5 files
+                            fallback.issues.append(f"  • {f}")
+                        if len(files_modified) > 5:
+                            fallback.issues.append(f"  • ... and {len(files_modified) - 5} more")
+
+                    if commands_run:
+                        fallback.issues.append(f"\nCommands executed ({len(commands_run)}):")
+                        for cmd in commands_run[:3]:  # Limit to 3 commands
+                            # Truncate long commands
+                            display_cmd = cmd if len(cmd) <= 60 else cmd[:57] + "..."
+                            fallback.issues.append(f"  • {display_cmd}")
+                        if len(commands_run) > 3:
+                            fallback.issues.append(f"  • ... and {len(commands_run) - 3} more")
+
+            # Add helpful next steps
+            fallback.next_steps.append(
+                "The task may be too complex - try breaking it into smaller steps"
+            )
+            fallback.next_steps.append("Check the output above for any errors or partial progress")
+            if files_modified:
+                fallback.next_steps.append("Review modified files to see what changes were made")
 
-                elapsed_time = (time.time() - start_time) * 1000
-                sequential_estimate = len(buffered_tasks) * 100
-                speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
+            # Create comprehensive output
+            output_parts = [fallback.summary, ""]
 
-                if state_manager.session.show_thoughts:
-                    await ui.muted(
-                        f"✅ Final batch completed in {elapsed_time:.0f}ms "
-                        f"(~{speedup:.1f}x faster than sequential)\n"
-                    )
+            if fallback.progress:
+                output_parts.append(f"Progress: {fallback.progress}")
 
-            # If we need to add a fallback response, create a wrapper
-            if not response_state.has_user_response and i >= max_iterations and fallback_enabled:
-                patch_tool_messages("Task incomplete", state_manager=state_manager)
-                response_state.has_final_synthesis = True
-
-                # Extract context from the agent run
-                tool_calls_summary = []
-                files_modified = set()
-                commands_run = []
-
-                # Analyze message history for context
-                for msg in state_manager.session.messages:
-                    if hasattr(msg, "parts"):
-                        for part in msg.parts:
-                            if hasattr(part, "part_kind") and part.part_kind == "tool-call":
-                                tool_name = getattr(part, "tool_name", "unknown")
-                                tool_calls_summary.append(tool_name)
-
-                                # Track specific operations
-                                if tool_name in ["write_file", "update_file"] and hasattr(
-                                    part, "args"
-                                ):
-                                    if isinstance(part.args, dict) and "file_path" in part.args:
-                                        files_modified.add(part.args["file_path"])
-                                elif tool_name in ["run_command", "bash"] and hasattr(part, "args"):
-                                    if isinstance(part.args, dict) and "command" in part.args:
-                                        commands_run.append(part.args["command"])
-
-                # Build fallback response with context
-                fallback = FallbackResponse(
-                    summary="Reached maximum iterations without producing a final response.",
-                    progress=f"Completed {i} iterations (limit: {max_iterations})",
-                )
+            if fallback.issues:
+                output_parts.append("\nWhat happened:")
+                output_parts.extend(fallback.issues)
 
-                # Get verbosity setting
-                verbosity = state_manager.session.user_config.get("settings", {}).get(
-                    "fallback_verbosity", "normal"
-                )
+            if fallback.next_steps:
+                output_parts.append("\nSuggested next steps:")
+                for step in fallback.next_steps:
+                    output_parts.append(f"  • {step}")
 
-                if verbosity in ["normal", "detailed"]:
-                    # Add what was attempted
-                    if tool_calls_summary:
-                        tool_counts = {}
-                        for tool in tool_calls_summary:
-                            tool_counts[tool] = tool_counts.get(tool, 0) + 1
-
-                        fallback.issues.append(f"Executed {len(tool_calls_summary)} tool calls:")
-                        for tool, count in sorted(tool_counts.items()):
-                            fallback.issues.append(f"  • {tool}: {count}x")
-
-                    if verbosity == "detailed":
-                        if files_modified:
-                            fallback.issues.append(f"\nFiles modified ({len(files_modified)}):")
-                            for f in sorted(files_modified)[:5]:  # Limit to 5 files
-                                fallback.issues.append(f"  • {f}")
-                            if len(files_modified) > 5:
-                                fallback.issues.append(
-                                    f"  • ... and {len(files_modified) - 5} more"
-                                )
-
-                        if commands_run:
-                            fallback.issues.append(f"\nCommands executed ({len(commands_run)}):")
-                            for cmd in commands_run[:3]:  # Limit to 3 commands
-                                # Truncate long commands
-                                display_cmd = cmd if len(cmd) <= 60 else cmd[:57] + "..."
-                                fallback.issues.append(f"  • {display_cmd}")
-                            if len(commands_run) > 3:
-                                fallback.issues.append(f"  • ... and {len(commands_run) - 3} more")
-
-                # Add helpful next steps
-                fallback.next_steps.append(
-                    "The task may be too complex - try breaking it into smaller steps"
-                )
-                fallback.next_steps.append(
-                    "Check the output above for any errors or partial progress"
-                )
-                if files_modified:
-                    fallback.next_steps.append(
-                        "Review modified files to see what changes were made"
-                    )
+            comprehensive_output = "\n".join(output_parts)
 
-                # Create comprehensive output
-                output_parts = [fallback.summary, ""]
-
-                if fallback.progress:
-                    output_parts.append(f"Progress: {fallback.progress}")
-
-                if fallback.issues:
-                    output_parts.append("\nWhat happened:")
-                    output_parts.extend(fallback.issues)
-
-                if fallback.next_steps:
-                    output_parts.append("\nSuggested next steps:")
-                    for step in fallback.next_steps:
-                        output_parts.append(f"  • {step}")
-
-                comprehensive_output = "\n".join(output_parts)
-
-                # Create a wrapper object that mimics AgentRun with the required attributes
-                class AgentRunWrapper:
-                    def __init__(self, wrapped_run, fallback_result):
-                        self._wrapped = wrapped_run
-                        self._result = fallback_result
-                        self.response_state = response_state
-
-                    def __getattribute__(self, name):
-                        # Handle special attributes first to avoid conflicts
-                        if name in ["_wrapped", "_result", "response_state"]:
-                            return object.__getattribute__(self, name)
-
-                        # Explicitly handle 'result' to return our fallback result
-                        if name == "result":
-                            return object.__getattribute__(self, "_result")
-
-                        # Delegate all other attributes to the wrapped object
-                        try:
-                            return getattr(object.__getattribute__(self, "_wrapped"), name)
-                        except AttributeError:
-                            raise AttributeError(
-                                f"'{type(self).__name__}' object has no attribute '{name}'"
-                            )
-
-                return AgentRunWrapper(agent_run, SimpleResult(comprehensive_output))
-
-            # For non-fallback cases, we still need to handle the response_state
-            # Create a minimal wrapper just to add response_state
-            class AgentRunWithState:
-                def __init__(self, wrapped_run):
+            # Create a wrapper object that mimics AgentRun with the required attributes
+            class AgentRunWrapper:
+                def __init__(self, wrapped_run, fallback_result):
                     self._wrapped = wrapped_run
+                    self._result = fallback_result
                     self.response_state = response_state
 
                 def __getattribute__(self, name):
-                    # Handle special attributes first
-                    if name in ["_wrapped", "response_state"]:
+                    # Handle special attributes first to avoid conflicts
+                    if name in ["_wrapped", "_result", "response_state"]:
                         return object.__getattribute__(self, name)
 
+                    # Explicitly handle 'result' to return our fallback result
+                    if name == "result":
+                        return object.__getattribute__(self, "_result")
+
                     # Delegate all other attributes to the wrapped object
                     try:
                         return getattr(object.__getattribute__(self, "_wrapped"), name)
@@ -1089,6 +995,26 @@ async def process_request(
                             f"'{type(self).__name__}' object has no attribute '{name}'"
                         )
 
-            return AgentRunWithState(agent_run)
-    except asyncio.CancelledError:
-        raise UserAbortError("User aborted the request.")
+            return AgentRunWrapper(agent_run, SimpleResult(comprehensive_output))
+
+        # For non-fallback cases, we still need to handle the response_state
+        # Create a minimal wrapper just to add response_state
+        class AgentRunWithState:
+            def __init__(self, wrapped_run):
+                self._wrapped = wrapped_run
+                self.response_state = response_state
+
+            def __getattribute__(self, name):
+                # Handle special attributes first
+                if name in ["_wrapped", "response_state"]:
+                    return object.__getattribute__(self, name)
+
+                # Delegate all other attributes to the wrapped object
+                try:
+                    return getattr(object.__getattribute__(self, "_wrapped"), name)
+                except AttributeError:
+                    raise AttributeError(
+                        f"'{type(self).__name__}' object has no attribute '{name}'"
+                    )
+
+        return AgentRunWithState(agent_run)