tunacode-cli 0.0.70__py3-none-any.whl → 0.0.78.6__py3-none-any.whl

tunacode/core/agents/agent_components/node_processor.py

@@ -5,7 +5,8 @@ from typing import Any, Awaitable, Callable, Optional, Tuple
 
 from tunacode.core.logging.logger import get_logger
 from tunacode.core.state import StateManager
-from tunacode.types import UsageTrackerProtocol
+from tunacode.exceptions import UserAbortError
+from tunacode.types import AgentState, UsageTrackerProtocol
 from tunacode.ui.tool_descriptions import get_batch_description, get_tool_description
 
 from .response_state import ResponseState
@@ -15,17 +16,6 @@ from .truncation_checker import check_for_truncation
 
 logger = get_logger(__name__)
 
-# Import streaming types with fallback for older versions
-try:
-    from pydantic_ai.messages import PartDeltaEvent, TextPartDelta
-
-    STREAMING_AVAILABLE = True
-except ImportError:
-    # Fallback for older pydantic-ai versions
-    PartDeltaEvent = None
-    TextPartDelta = None
-    STREAMING_AVAILABLE = False
-
 
 async def _process_node(
     node,
@@ -39,8 +29,9 @@ async def _process_node(
     """Process a single node from the agent response.
 
     Returns:
-        tuple: (is_empty: bool, reason: Optional[str]) - True if empty/problematic response detected,
-               with reason being one of: "empty", "truncated", "intention_without_action"
+        tuple: (is_empty: bool, reason: Optional[str]) - True if empty/problematic
+               response detected, with reason being one of: "empty", "truncated",
+               "intention_without_action"
     """
     from tunacode.ui import console as ui
 
@@ -52,6 +43,12 @@ async def _process_node(
     has_intention = False
     has_tool_calls = False
 
+    # Transition to ASSISTANT at the start of node processing
+    if response_state and response_state.can_transition_to(AgentState.ASSISTANT):
+        response_state.transition_to(AgentState.ASSISTANT)
+        if state_manager.session.show_thoughts:
+            await ui.muted("STATE → ASSISTANT (reasoning)")
+
     if hasattr(node, "request"):
         state_manager.session.messages.append(node.request)
 
@@ -93,15 +90,22 @@ async def _process_node(
                             # Agent is trying to complete with pending tools!
                             if state_manager.session.show_thoughts:
                                 await ui.warning(
-                                    "⚠️ PREMATURE COMPLETION DETECTED - Agent queued tools but marked complete"
+                                    "⚠️ PREMATURE COMPLETION DETECTED - "
+                                    "Agent queued tools but marked complete"
                                 )
                                 await ui.muted("   Overriding completion to allow tool execution")
                             # Don't mark as complete - let the tools run first
                             # Update the content to remove the marker but don't set task_completed
                             part.content = cleaned_content
                             # Log this as an issue
+                            pending_tools_count = sum(
+                                1
+                                for p in node.model_response.parts
+                                if getattr(p, "part_kind", "") == "tool-call"
+                            )
                             logger.warning(
-                                f"Agent attempted premature completion with {sum(1 for p in node.model_response.parts if getattr(p, 'part_kind', '') == 'tool-call')} pending tools"
+                                f"Agent attempted premature completion with {pending_tools_count} "
+                                f"pending tools"
                             )
                         else:
                             # Check if content suggests pending actions
@@ -125,7 +129,8 @@ async def _process_node(
                                 phrase in combined_text for phrase in pending_phrases
                             )
 
-                            # Also check for action verbs at end of content suggesting incomplete action
+                            # Also check for action verbs at end of content
+                            # suggesting incomplete action
                             action_endings = [
                                 "checking",
                                 "searching",
@@ -144,25 +149,37 @@ async def _process_node(
                                 # Too early to complete with pending intentions
                                 if state_manager.session.show_thoughts:
                                     await ui.warning(
-                                        "⚠️ SUSPICIOUS COMPLETION - Stated intentions but completing early"
+                                        "⚠️ SUSPICIOUS COMPLETION - "
+                                        "Stated intentions but completing early"
                                     )
                                     found_phrases = [
                                         p for p in pending_phrases if p in combined_text
                                     ]
-                                    await ui.muted(
-                                        f"   Iteration {state_manager.session.iteration_count} with pending: {found_phrases}"
+                                    iteration_msg = (
+                                        f"   Iteration {state_manager.session.iteration_count} "
+                                        f"with pending: {found_phrases}"
                                     )
+                                    await ui.muted(iteration_msg)
                                     if ends_with_action:
+                                        action_verb = (
+                                            combined_text.split()[-1]
+                                            if combined_text.split()
+                                            else ""
+                                        )
                                         await ui.muted(
-                                            f"   Content ends with action verb: '{combined_text.split()[-1] if combined_text.split() else ''}'"
+                                            f"   Content ends with action verb: '{action_verb}'"
                                         )
                                 # Still allow it but log warning
                                 logger.warning(
-                                    f"Task completion with pending intentions detected: {found_phrases}"
+                                    f"Task completion with pending intentions detected: "
+                                    f"{found_phrases}"
                                 )
 
-                            # Normal completion
-                            response_state.task_completed = True
+                            # Normal completion - transition to RESPONSE state and mark completion
+                            response_state.transition_to(AgentState.RESPONSE)
+                            if state_manager.session.show_thoughts:
+                                await ui.muted("STATE → RESPONSE (completion detected)")
+                            response_state.set_completion_detected(True)
                             response_state.has_user_response = True
                             # Update the part content to remove the marker
                             part.content = cleaned_content
@@ -175,7 +192,8 @@ async def _process_node(
                 combined_content = " ".join(all_content_parts).strip()
                 appears_truncated = check_for_truncation(combined_content)
 
-            # If we only got empty content and no tool calls, we should NOT consider this a valid response
+            # If we only got empty content and no tool calls, we should NOT consider this
+            # a valid response
             # This prevents the agent from stopping when it gets empty responses
             if not has_non_empty_content and not any(
                 hasattr(part, "part_kind") and part.part_kind == "tool-call"
@@ -197,17 +215,6 @@ async def _process_node(
                     await ui.muted("⚠️ TRUNCATED RESPONSE DETECTED - CONTINUING")
                     await ui.muted(f"   Last content: ...{combined_content[-100:]}")
 
-        # Stream content to callback if provided
-        # Use this as fallback when true token streaming is not available
-        if streaming_callback and not STREAMING_AVAILABLE:
-            for part in node.model_response.parts:
-                if hasattr(part, "content") and isinstance(part.content, str):
-                    content = part.content.strip()
-                    if content and not content.startswith('{"thought"'):
-                        # Stream non-JSON content (actual response content)
-                        if streaming_callback:
-                            await streaming_callback(content)
-
         # Enhanced display when thoughts are enabled
         if state_manager.session.show_thoughts:
             await _display_raw_api_response(node, ui)
@@ -217,6 +224,14 @@ async def _process_node(
             node, buffering_callback, state_manager, tool_buffer, response_state
         )
 
+    # If there were no tools and we processed a model response, transition to RESPONSE
+    if response_state and response_state.can_transition_to(AgentState.RESPONSE):
+        # Only transition if not already completed (set by completion marker path)
+        if not response_state.is_completed():
+            response_state.transition_to(AgentState.RESPONSE)
+            if state_manager.session.show_thoughts:
+                await ui.muted("STATE → RESPONSE (handled output)")
+
     # Determine empty response reason
     if empty_response_detected:
         if appears_truncated:
@@ -295,138 +310,147 @@ async def _process_tool_calls(
     tool_buffer: Optional[ToolBuffer],
     response_state: Optional[ResponseState],
 ) -> None:
-    """Process tool calls from the node."""
+    """
+    Process tool calls from the node using smart batching strategy.
+
+    Smart batching optimization:
+    - Collect all read-only tools into a single batch (regardless of write tools in between)
+    - Execute all read-only tools in one parallel batch
+    - Execute write/execute tools sequentially in their original order
+
+    This maximizes parallel execution efficiency by avoiding premature buffer flushes.
+    """
     from tunacode.constants import READ_ONLY_TOOLS
     from tunacode.ui import console as ui
 
     # Track if we're processing tool calls
     is_processing_tools = False
 
-    # Process tool calls
+    # Phase 1: Collect and categorize all tools
+    read_only_tasks = []
+    write_execute_tasks = []
+
     for part in node.model_response.parts:
         if hasattr(part, "part_kind") and part.part_kind == "tool-call":
             is_processing_tools = True
-            if tool_callback:
-                # Check if this is a read-only tool that can be batched
-                if tool_buffer is not None and part.tool_name in READ_ONLY_TOOLS:
-                    # Add to buffer instead of executing immediately
-                    tool_buffer.add(part, node)
-
-                    # Update spinner to show we're collecting tools
-                    buffered_count = len(tool_buffer.read_only_tasks)
-                    await ui.update_spinner_message(
-                        f"[bold #00d7ff]Collecting tools ({buffered_count} buffered)...[/bold #00d7ff]",
-                        state_manager,
-                    )
+            # Transition to TOOL_EXECUTION on first tool call
+            if response_state and response_state.can_transition_to(AgentState.TOOL_EXECUTION):
+                response_state.transition_to(AgentState.TOOL_EXECUTION)
+                if state_manager.session.show_thoughts:
+                    await ui.muted("STATE → TOOL_EXECUTION (executing tools)")
 
+            if tool_callback:
+                # Categorize: read-only vs write/execute
+                if part.tool_name in READ_ONLY_TOOLS:
+                    read_only_tasks.append((part, node))
                     if state_manager.session.show_thoughts:
                         await ui.muted(
-                            f"⏸️ BUFFERED: {part.tool_name} (will execute in parallel batch)"
+                            f"⏸️ COLLECTED: {part.tool_name} (will execute in parallel batch)"
                         )
                 else:
-                    # Write/execute tool - process any buffered reads first
-                    if tool_buffer is not None and tool_buffer.has_tasks():
-                        import time
-
-                        from .tool_executor import execute_tools_parallel
-
-                        buffered_tasks = tool_buffer.flush()
-                        batch_id = getattr(state_manager.session, "batch_counter", 0) + 1
-                        state_manager.session.batch_counter = batch_id
-
-                        start_time = time.time()
-
-                        # Update spinner message for batch execution
-                        tool_names = [part.tool_name for part, _ in buffered_tasks]
-                        batch_msg = get_batch_description(len(buffered_tasks), tool_names)
-                        await ui.update_spinner_message(
-                            f"[bold #00d7ff]{batch_msg}...[/bold #00d7ff]", state_manager
+                    write_execute_tasks.append((part, node))
+                    if state_manager.session.show_thoughts:
+                        await ui.muted(
+                            f"📝 COLLECTED: {part.tool_name} (will execute sequentially)"
                         )
 
-                        # Enhanced visual feedback for parallel execution (suppress in plan mode)
-                        if not state_manager.is_plan_mode():
-                            await ui.muted("\n" + "=" * 60)
-                            await ui.muted(
-                                f"🚀 PARALLEL BATCH #{batch_id}: Executing {len(buffered_tasks)} read-only tools concurrently"
-                            )
-                            await ui.muted("=" * 60)
-
-                            # Display details of what's being executed
-                            for idx, (buffered_part, _) in enumerate(buffered_tasks, 1):
-                                tool_desc = f"  [{idx}] {buffered_part.tool_name}"
-                                if hasattr(buffered_part, "args") and isinstance(
-                                    buffered_part.args, dict
-                                ):
-                                    if (
-                                        buffered_part.tool_name == "read_file"
-                                        and "file_path" in buffered_part.args
-                                    ):
-                                        tool_desc += f" → {buffered_part.args['file_path']}"
-                                    elif (
-                                        buffered_part.tool_name == "grep"
-                                        and "pattern" in buffered_part.args
-                                    ):
-                                        tool_desc += (
-                                            f" → pattern: '{buffered_part.args['pattern']}'"
-                                        )
-                                        if "include_files" in buffered_part.args:
-                                            tool_desc += (
-                                                f", files: '{buffered_part.args['include_files']}'"
-                                            )
-                                    elif (
-                                        buffered_part.tool_name == "list_dir"
-                                        and "directory" in buffered_part.args
-                                    ):
-                                        tool_desc += f" → {buffered_part.args['directory']}"
-                                    elif (
-                                        buffered_part.tool_name == "glob"
-                                        and "pattern" in buffered_part.args
-                                    ):
-                                        tool_desc += (
-                                            f" → pattern: '{buffered_part.args['pattern']}'"
-                                        )
-                                await ui.muted(tool_desc)
-                            await ui.muted("=" * 60)
+    # Phase 2: Execute read-only tools in ONE parallel batch
+    if read_only_tasks and tool_callback:
+        from .tool_executor import execute_tools_parallel
 
-                        await execute_tools_parallel(buffered_tasks, tool_callback)
+        batch_id = getattr(state_manager.session, "batch_counter", 0) + 1
+        state_manager.session.batch_counter = batch_id
 
-                        elapsed_time = (time.time() - start_time) * 1000
-                        sequential_estimate = (
-                            len(buffered_tasks) * 100
-                        )  # Assume 100ms per tool average
-                        speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
-
-                        if not state_manager.is_plan_mode():
-                            await ui.muted(
-                                f"✅ Parallel batch completed in {elapsed_time:.0f}ms "
-                                f"(~{speedup:.1f}x faster than sequential)\n"
-                            )
-
-                        # Reset spinner message back to thinking
-                        from tunacode.constants import UI_THINKING_MESSAGE
-
-                        await ui.update_spinner_message(UI_THINKING_MESSAGE, state_manager)
+        # Update spinner to show batch collection
+        await ui.update_spinner_message(
+            f"[bold #00d7ff]Collected {len(read_only_tasks)} read-only tools...[/bold #00d7ff]",
+            state_manager,
+        )
 
-                    # Now execute the write/execute tool
-                    if state_manager.session.show_thoughts:
-                        await ui.warning(f"⚠️ SEQUENTIAL: {part.tool_name} (write/execute tool)")
+        # Update spinner message for batch execution
+        tool_names = [part.tool_name for part, _ in read_only_tasks]
+        batch_msg = get_batch_description(len(read_only_tasks), tool_names)
+        await ui.update_spinner_message(
+            f"[bold #00d7ff]{batch_msg}...[/bold #00d7ff]", state_manager
+        )
 
-                    # Update spinner for sequential tool
-                    tool_args = getattr(part, "args", {}) if hasattr(part, "args") else {}
-                    # Parse args if they're a JSON string
-                    if isinstance(tool_args, str):
-                        import json
+        # Build batch content as markdown for Rich panel
+        batch_content = (
+            f"**PARALLEL BATCH #{batch_id}**: "
+            f"Executing {len(read_only_tasks)} read-only tools concurrently\n\n"
+        )
 
-                        try:
-                            tool_args = json.loads(tool_args)
-                        except (json.JSONDecodeError, TypeError):
-                            tool_args = {}
-                    tool_desc = get_tool_description(part.tool_name, tool_args)
-                    await ui.update_spinner_message(
-                        f"[bold #00d7ff]{tool_desc}...[/bold #00d7ff]", state_manager
-                    )
+        # Display details of what's being executed
+        for idx, (part, _) in enumerate(read_only_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']}`"
+            batch_content += f"{tool_desc}\n"
+
+        await execute_tools_parallel(read_only_tasks, tool_callback)
+
+        # Display batch execution in green Rich panel
+        await ui.batch(batch_content)
+
+        # Reset spinner message back to thinking
+        from tunacode.constants import UI_THINKING_MESSAGE
+
+        await ui.update_spinner_message(UI_THINKING_MESSAGE, state_manager)
+
+    # Phase 3: Execute write/execute tools sequentially
+    for part, node in write_execute_tasks:
+        if state_manager.session.show_thoughts:
+            await ui.warning(f"⚠️ SEQUENTIAL: {part.tool_name} (write/execute tool)")
+
+        # Update spinner for sequential tool
+        tool_args = getattr(part, "args", {}) if hasattr(part, "args") else {}
+        # Parse args if they're a JSON string
+        if isinstance(tool_args, str):
+            import json
+
+            try:
+                tool_args = json.loads(tool_args)
+            except (json.JSONDecodeError, TypeError):
+                tool_args = {}
+        tool_desc = get_tool_description(part.tool_name, tool_args)
+        await ui.update_spinner_message(
+            f"[bold #00d7ff]{tool_desc}...[/bold #00d7ff]", state_manager
+        )
 
-                    await tool_callback(part, node)
+        # Execute the tool with robust error handling
+        try:
+            await tool_callback(part, node)
+        except UserAbortError:
+            raise
+        except Exception as tool_err:
+            logger.error(
+                "Tool callback failed: tool=%s iter=%s err=%s",
+                getattr(part, "tool_name", "<unknown>"),
+                getattr(state_manager.session, "current_iteration", "?"),
+                tool_err,
+                exc_info=True,
+            )
+            # Surface to UI when thoughts are enabled, then continue gracefully
+            if getattr(state_manager.session, "show_thoughts", False):
+                await ui.warning(
+                    f"❌ Tool failed: {getattr(part, 'tool_name', '<unknown>')} — continuing"
+                )
+        finally:
+            # Tool execution completed - resource cleanup handled by BaseTool.execute()
+            tool_name = getattr(part, "tool_name", "<unknown>")
+            logger.debug(
+                "Tool execution completed (success or failure): tool=%s",
+                tool_name,
+            )
 
     # Track tool calls in session
     if is_processing_tools:
@@ -440,6 +464,16 @@ async def _process_tool_calls(
                 }
                 state_manager.session.tool_calls.append(tool_info)
 
+    # After tools are processed, transition back to RESPONSE
+    if (
+        is_processing_tools
+        and response_state
+        and response_state.can_transition_to(AgentState.RESPONSE)
+    ):
+        response_state.transition_to(AgentState.RESPONSE)
+        if state_manager.session.show_thoughts:
+            await ui.muted("STATE → RESPONSE (tools finished)")
+
     # Update has_user_response based on presence of actual response content
     if (
         response_state

tunacode/core/agents/agent_components/response_state.py

@@ -1,13 +1,130 @@
 """Response state management for tracking agent processing state."""
 
-from dataclasses import dataclass
+import threading
+from dataclasses import dataclass, field
+from typing import Optional
+
+from tunacode.types import AgentState
+
+from .state_transition import AGENT_TRANSITION_RULES, AgentStateMachine
 
 
 @dataclass
 class ResponseState:
-    """Track state across agent response processing."""
+    """Enhanced response state using enum-based state machine."""
+
+    # Internal state machine
+    _state_machine: AgentStateMachine = field(
+        default_factory=lambda: AgentStateMachine(AgentState.USER_INPUT, AGENT_TRANSITION_RULES)
+    )
+
+    # Backward compatibility boolean flags (derived from enum state)
+    _has_user_response: bool = False
+    _task_completed: bool = False
+    _awaiting_user_guidance: bool = False
+    _has_final_synthesis: bool = False
+    # Thread-safe lock for boolean flag access
+    _lock: threading.RLock = field(default_factory=threading.RLock, init=False, repr=False)
+
+    def __post_init__(self):
+        """Initialize the state machine."""
+        if not hasattr(self, "_state_machine"):
+            self._state_machine = AgentStateMachine(AgentState.USER_INPUT, AGENT_TRANSITION_RULES)
+        if not hasattr(self, "_lock"):
+            self._lock = threading.RLock()
+
+    @property
+    def current_state(self) -> AgentState:
+        """Get the current enum state."""
+        return self._state_machine.current_state
+
+    def transition_to(self, new_state: AgentState) -> None:
+        """Transition to a new state."""
+        self._state_machine.transition_to(new_state)
+
+    def can_transition_to(self, target_state: AgentState) -> bool:
+        """Check if a transition to the target state is allowed."""
+        return self._state_machine.can_transition_to(target_state)
+
+    # Backward compatibility properties
+    @property
+    def has_user_response(self) -> bool:
+        """Legacy boolean flag for user response detection."""
+        with self._lock:
+            return self._has_user_response
+
+    @has_user_response.setter
+    def has_user_response(self, value: bool) -> None:
+        """Set the legacy has_user_response flag."""
+        with self._lock:
+            self._has_user_response = value
+
+    @property
+    def task_completed(self) -> bool:
+        """Legacy boolean flag for task completion (derived from state machine)."""
+        with self._lock:
+            # If explicitly set true, honor it; otherwise derive from state machine
+            return bool(self._task_completed or self._state_machine.is_completed())
+
+    @task_completed.setter
+    def task_completed(self, value: bool) -> None:
+        """Set the legacy task_completed flag and sync with state machine."""
+        with self._lock:
+            self._task_completed = bool(value)
+            if value:
+                # Ensure state reflects completion in RESPONSE
+                try:
+                    if (
+                        self._state_machine.current_state != AgentState.RESPONSE
+                        and self._state_machine.can_transition_to(AgentState.RESPONSE)
+                    ):
+                        self._state_machine.transition_to(AgentState.RESPONSE)
+                except Exception:
+                    # Best-effort: ignore invalid transition in legacy paths
+                    pass
+                self._state_machine.set_completion_detected(True)
+            else:
+                self._state_machine.set_completion_detected(False)
+
+    @property
+    def awaiting_user_guidance(self) -> bool:
+        """Legacy boolean flag for awaiting user guidance."""
+        with self._lock:
+            return self._awaiting_user_guidance
+
+    @awaiting_user_guidance.setter
+    def awaiting_user_guidance(self, value: bool) -> None:
+        """Set the legacy awaiting_user_guidance flag."""
+        with self._lock:
+            self._awaiting_user_guidance = value
+
+    @property
+    def has_final_synthesis(self) -> bool:
+        """Legacy boolean flag for final synthesis."""
+        with self._lock:
+            return self._has_final_synthesis
+
+    @has_final_synthesis.setter
+    def has_final_synthesis(self, value: bool) -> None:
+        """Set the legacy has_final_synthesis flag."""
+        with self._lock:
+            self._has_final_synthesis = value
+
+    # Enhanced state management methods
+    def set_completion_detected(self, detected: bool = True) -> None:
+        """Mark that completion has been detected in the RESPONSE state."""
+        self._state_machine.set_completion_detected(detected)
+
+    def is_completed(self) -> bool:
+        """Check if the task is completed according to the state machine."""
+        return self._state_machine.is_completed()
 
-    has_user_response: bool = False
-    task_completed: bool = False
-    awaiting_user_guidance: bool = False
-    has_final_synthesis: bool = False
+    def reset_state(self, initial_state: Optional[AgentState] = None) -> None:
+        """Reset the state machine to initial state."""
+        with self._lock:
+            self._state_machine.reset(initial_state)
+            # Reset legacy flags
+            self._has_user_response = False
+            self._task_completed = False
+            self._awaiting_user_guidance = False
+            self._has_final_synthesis = False