tunacode-cli 0.0.44__py3-none-any.whl → 0.0.46__py3-none-any.whl

tunacode/core/agents/main.py

@@ -30,12 +30,11 @@ except ImportError:
     STREAMING_AVAILABLE = False
 
 from tunacode.constants import READ_ONLY_TOOLS
-from tunacode.core.agents.dspy_integration import DSPyIntegration
 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
+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
@@ -519,18 +518,6 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 # Use a default system prompt if neither file exists
                 system_prompt = "You are a helpful AI assistant for software development tasks."
 
-        # Enhance with DSPy optimization if enabled
-        use_dspy = state_manager.session.user_config.get("settings", {}).get(
-            "use_dspy_optimization", True
-        )
-        if use_dspy:
-            try:
-                dspy_integration = DSPyIntegration(state_manager)
-                system_prompt = dspy_integration.enhance_system_prompt(system_prompt)
-                logger.info("Enhanced system prompt with DSPy optimizations")
-            except Exception as e:
-                logger.warning(f"Failed to enhance prompt with DSPy: {e}")
-
         # Load TUNACODE.md context
         # Use sync version of get_code_style to avoid nested event loop issues
         try:
@@ -765,356 +752,335 @@ async def process_request(
     tool_callback: Optional[ToolCallback] = None,
     streaming_callback: Optional[callable] = None,
 ) -> AgentRun:
-    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 DSPy optimization is enabled and if this is a complex task
-    use_dspy = state_manager.session.user_config.get("settings", {}).get(
-        "use_dspy_optimization", True
-    )
-    dspy_integration = None
-    task_breakdown = None
-
-    # 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
-    )
+    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
+        )
 
-    if use_dspy:
-        try:
-            dspy_integration = DSPyIntegration(state_manager)
+        # 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
+        )
 
-            # Check if this is a complex task that needs planning
-            if dspy_integration.should_use_task_planner(message):
-                task_breakdown = dspy_integration.get_task_breakdown(message)
-                if task_breakdown and task_breakdown.get("requires_todo"):
-                    # Auto-create todos for complex tasks
-                    from tunacode.tools.todo import TodoTool
+        # 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,
+                )
 
-                    todo_tool = TodoTool(state_manager=state_manager)
+                # Analyze task complexity
+                complexity_result = await recursive_executor.decomposer.analyze_and_decompose(
+                    message
+                )
 
+                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("DSPy: Detected complex task - creating todo list")
-
-                    # Create todos from subtasks
-                    todos = []
-                    for subtask in task_breakdown["subtasks"][:5]:  # Limit to first 5
-                        todos.append(
-                            {
-                                "content": subtask["task"],
-                                "priority": subtask.get("priority", "medium"),
-                            }
+                        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)}")
 
-                    if todos:
-                        await todo_tool._execute(action="add_multiple", todos=todos)
-        except Exception as e:
-            logger.warning(f"DSPy task planning failed: {e}")
-
-    # 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,
-            )
+                    # Execute recursively
+                    success, result, error = await recursive_executor.execute_task(
+                        request=message, parent_task_id=None, depth=0
+                    )
 
-            # Analyze task complexity
-            complexity_result = await recursive_executor.decomposer.analyze_and_decompose(message)
+                    # 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
 
-            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
+        from tunacode.configuration.models import ModelRegistry
+        from tunacode.core.token_usage.usage_tracker import UsageTracker
 
-                    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)}")
+        parser = ApiResponseParser()
+        registry = ModelRegistry()
+        calculator = CostCalculator(registry)
+        usage_tracker = UsageTracker(parser, calculator, state_manager)
+        response_state = ResponseState()
 
-                # Execute recursively
-                success, result, error = await recursive_executor.execute_task(
-                    request=message, parent_task_id=None, depth=0
-                )
+        # Reset iteration tracking for this request
+        state_manager.session.iteration_count = 0
 
-                # Create AgentRun response
-                from datetime import datetime
+        # Create a request-level buffer for batching read-only tools across nodes
+        tool_buffer = ToolBuffer()
 
-                if success:
-                    return AgentRun(
-                        messages=[{"role": "assistant", "content": str(result)}],
-                        timestamp=datetime.now(),
-                        model=model,
-                        iterations=1,
-                        status="success",
-                    )
-                else:
-                    return AgentRun(
-                        messages=[{"role": "assistant", "content": f"Task failed: {error}"}],
-                        timestamp=datetime.now(),
-                        model=model,
-                        iterations=1,
-                        status="error",
-                    )
-        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()
-
-    # 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
+        # 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
 
-            # Display iteration progress if thoughts are enabled
-            if state_manager.session.show_thoughts:
-                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")
 
-                await ui.muted(f"\nITERATION: {i}/{max_iterations}")
+        # 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
 
-                # 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
+            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)
 
-                    summary_str = ", ".join(
-                        [f"{name}: {count}" for name, count in tool_summary.items()]
-                    )
-                    await ui.muted(f"TOOLS USED: {summary_str}")
+        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
 
-            if i >= max_iterations:
+                # Display iteration progress if thoughts are enabled
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
 
-                    await ui.warning(f"Reached maximum iterations ({max_iterations})")
-                break
+                    await ui.muted(f"\nITERATION: {i}/{max_iterations}")
 
-        # Final flush: execute any remaining buffered read-only tools
-        if tool_callback and tool_buffer.has_tasks():
-            import time
+                    # 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
 
-            from tunacode.ui import console as ui
-
-            buffered_tasks = tool_buffer.flush()
-            start_time = time.time()
+                        summary_str = ", ".join(
+                            [f"{name}: {count}" for name, count in tool_summary.items()]
+                        )
+                        await ui.muted(f"TOOLS USED: {summary_str}")
 
-            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 i >= max_iterations:
+                    if state_manager.session.show_thoughts:
+                        from tunacode.ui import console as ui
 
-                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)
+                        await ui.warning(f"Reached maximum iterations ({max_iterations})")
+                    break
 
-            await execute_tools_parallel(buffered_tasks, tool_callback)
+            # Final flush: execute any remaining buffered read-only tools
+            if tool_callback and tool_buffer.has_tasks():
+                import time
 
-            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
+                from tunacode.ui import console as ui
 
-            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"
-                )
+                buffered_tasks = tool_buffer.flush()
+                start_time = time.time()
 
-        # 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 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)
 
-            # Get verbosity setting
-            verbosity = state_manager.session.user_config.get("settings", {}).get(
-                "fallback_verbosity", "normal"
-            )
+                    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)
 
-            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")
+                await execute_tools_parallel(buffered_tasks, tool_callback)
 
-            # Create comprehensive output
-            output_parts = [fallback.summary, ""]
+                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
 
-            if fallback.progress:
-                output_parts.append(f"Progress: {fallback.progress}")
+                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.issues:
-                output_parts.append("\nWhat happened:")
-                output_parts.extend(fallback.issues)
+            # 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.next_steps:
-                output_parts.append("\nSuggested next steps:")
-                for step in fallback.next_steps:
-                    output_parts.append(f"  • {step}")
+                # Get verbosity setting
+                verbosity = state_manager.session.user_config.get("settings", {}).get(
+                    "fallback_verbosity", "normal"
+                )
 
-            comprehensive_output = "\n".join(output_parts)
+                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"
+                    )
 
-            # Create a wrapper object that mimics AgentRun with the required attributes
-            class AgentRunWrapper:
-                def __init__(self, wrapped_run, fallback_result):
+                # 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):
                     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"]:
+                    # Handle special attributes first
+                    if name in ["_wrapped", "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)
@@ -1123,26 +1089,6 @@ async def process_request(
                             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):
-                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)
+            return AgentRunWithState(agent_run)
+    except asyncio.CancelledError:
+        raise UserAbortError("User aborted the request.")