tunacode-cli 0.0.54__py3-none-any.whl → 0.0.56__py3-none-any.whl

tunacode/core/agents/agent_components/agent_config.py

@@ -8,6 +8,7 @@ from tunacode.core.logging.logger import get_logger
 from tunacode.core.state import StateManager
 from tunacode.services.mcp import get_mcp_servers
 from tunacode.tools.bash import bash
+from tunacode.tools.present_plan import create_present_plan_tool
 from tunacode.tools.glob import glob
 from tunacode.tools.grep import grep
 from tunacode.tools.list_dir import list_dir
@@ -65,7 +66,11 @@ def load_tunacode_context() -> str:
 
 def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
     """Get existing agent or create new one for the specified model."""
+    import logging
+    logger = logging.getLogger(__name__)
+    
     if model not in state_manager.session.agents:
+        logger.debug(f"Creating new agent for model {model}, plan_mode={state_manager.is_plan_mode()}")
         max_retries = state_manager.session.user_config.get("settings", {}).get("max_retries", 3)
 
         # Lazy import Agent and Tool
@@ -78,8 +83,105 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
         # Load TUNACODE.md context
         system_prompt += load_tunacode_context()
 
-        # Initialize todo tool
+        # Add plan mode context if in plan mode
+        if state_manager.is_plan_mode():
+            # REMOVE all TUNACODE_TASK_COMPLETE instructions from the system prompt
+            system_prompt = system_prompt.replace("TUNACODE_TASK_COMPLETE", "PLAN_MODE_TASK_PLACEHOLDER")
+            # Remove the completion guidance that conflicts with plan mode
+            lines_to_remove = [
+                "When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE",
+                "4. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE", 
+                "**How to signal completion:**",
+                "TUNACODE_TASK_COMPLETE",
+                "[Your summary of what was accomplished]",
+                "**IMPORTANT**: Always evaluate if you've completed the task. If yes, use TUNACODE_TASK_COMPLETE.",
+                "This prevents wasting iterations and API calls."
+            ]
+            for line in lines_to_remove:
+                system_prompt = system_prompt.replace(line, "")
+            plan_mode_override = """
+🔍 PLAN MODE - YOU MUST USE THE present_plan TOOL 🔍
+
+CRITICAL: You are in Plan Mode. You MUST execute the present_plan TOOL, not show it as text.
+
+❌ WRONG - DO NOT SHOW THE FUNCTION AS TEXT:
+```
+present_plan(title="...", ...)  # THIS IS WRONG - DON'T SHOW AS CODE
+```
+
+✅ CORRECT - ACTUALLY EXECUTE THE TOOL:
+You must EXECUTE present_plan as a tool call, just like you execute read_file or grep.
+
+CRITICAL RULES:
+1. DO NOT show present_plan() as code or text
+2. DO NOT write "Here's the plan" or any text description
+3. DO NOT use TUNACODE_TASK_COMPLETE
+4. DO NOT use markdown code blocks for present_plan
+
+YOU MUST EXECUTE THE TOOL:
+When the user asks you to "plan" something, you must:
+1. Research using read_only tools (optional)
+2. EXECUTE present_plan tool with the plan data
+3. The tool will handle displaying the plan
+
+Example of CORRECT behavior:
+User: "plan a markdown file"
+You: [Execute read_file/grep if needed for research]
+     [Then EXECUTE present_plan tool - not as text but as an actual tool call]
+
+Remember: present_plan is a TOOL like read_file or grep. You must EXECUTE it, not SHOW it.
+
+Available tools:
+- read_file, grep, list_dir, glob: For research
+- present_plan: EXECUTE this tool to present the plan (DO NOT show as text)
+
+"""
+            # COMPLETELY REPLACE system prompt in plan mode - nuclear option
+            system_prompt = """
+🔧 PLAN MODE - TOOL EXECUTION ONLY 🔧
+
+You are a planning assistant that ONLY communicates through tool execution.
+
+CRITICAL: You cannot respond with text. You MUST use tools for everything.
+
+AVAILABLE TOOLS:
+- read_file(filepath): Read file contents
+- grep(pattern): Search for text patterns  
+- list_dir(directory): List directory contents
+- glob(pattern): Find files matching patterns
+- present_plan(title, overview, steps, files_to_create, success_criteria): Present structured plan
+
+MANDATORY WORKFLOW:
+1. User asks you to plan something
+2. You research using read-only tools (if needed)
+3. You EXECUTE present_plan tool with structured data
+4. DONE
+
+FORBIDDEN:
+- Text responses
+- Showing function calls as code
+- Saying "here is the plan"
+- Any text completion
+
+EXAMPLE:
+User: "plan a markdown file"
+You: [Call read_file or grep for research if needed]
+     [Call present_plan tool with actual parameters - NOT as text]
+
+The present_plan tool takes these parameters:
+- title: Brief title string
+- overview: What the plan accomplishes  
+- steps: List of implementation steps
+- files_to_create: List of files to create
+- success_criteria: List of success criteria
+
+YOU MUST EXECUTE present_plan TOOL TO COMPLETE ANY PLANNING TASK.
+"""
+
+        # Initialize tools that need state manager
         todo_tool = TodoTool(state_manager=state_manager)
+        present_plan = create_present_plan_tool(state_manager)
+        logger.debug(f"Tools initialized, present_plan available: {present_plan is not None}")
 
         # Add todo context if available
         try:
@@ -89,12 +191,21 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
         except Exception as e:
             logger.warning(f"Warning: Failed to load todos: {e}")
 
-        # Create agent with all tools
-        state_manager.session.agents[model] = Agent(
-            model=model,
-            system_prompt=system_prompt,
-            tools=[
+        # Create tool list based on mode
+        if state_manager.is_plan_mode():
+            # Plan mode: Only read-only tools + present_plan
+            tools_list = [
+                Tool(present_plan, max_retries=max_retries),
+                Tool(glob, max_retries=max_retries),
+                Tool(grep, max_retries=max_retries),
+                Tool(list_dir, max_retries=max_retries),
+                Tool(read_file, max_retries=max_retries),
+            ]
+        else:
+            # Normal mode: All tools
+            tools_list = [
                 Tool(bash, max_retries=max_retries),
+                Tool(present_plan, max_retries=max_retries),
                 Tool(glob, max_retries=max_retries),
                 Tool(grep, max_retries=max_retries),
                 Tool(list_dir, max_retries=max_retries),
@@ -103,7 +214,23 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 Tool(todo_tool._execute, max_retries=max_retries),
                 Tool(update_file, max_retries=max_retries),
                 Tool(write_file, max_retries=max_retries),
-            ],
+            ]
+        
+        # Log which tools are being registered
+        logger.debug(f"Creating agent: plan_mode={state_manager.is_plan_mode()}, tools={len(tools_list)}")
+        if state_manager.is_plan_mode():
+            logger.debug(f"PLAN MODE TOOLS: {[str(tool) for tool in tools_list]}")
+            logger.debug(f"present_plan tool type: {type(present_plan)}")
+        
+        if "PLAN MODE - YOU MUST USE THE present_plan TOOL" in system_prompt:
+            logger.debug("✅ Plan mode instructions ARE in system prompt")
+        else:
+            logger.debug("❌ Plan mode instructions NOT in system prompt")
+        
+        state_manager.session.agents[model] = Agent(
+            model=model,
+            system_prompt=system_prompt,
+            tools=tools_list,
             mcp_servers=get_mcp_servers(state_manager),
         )
     return state_manager.session.agents[model]

tunacode/core/agents/agent_components/agent_helpers.py

@@ -0,0 +1,219 @@
+"""Helper functions for agent operations to reduce code duplication."""
+
+from typing import Any
+
+from tunacode.core.state import StateManager
+from tunacode.types import FallbackResponse
+
+
+class UserPromptPartFallback:
+    """Fallback class for UserPromptPart when pydantic_ai is not available."""
+
+    def __init__(self, content: str, part_kind: str):
+        self.content = content
+        self.part_kind = part_kind
+
+
+# Cache for UserPromptPart class
+_USER_PROMPT_PART_CLASS = None
+
+
+def get_user_prompt_part_class():
+    """Get UserPromptPart class with caching and fallback for test environment."""
+    global _USER_PROMPT_PART_CLASS
+
+    if _USER_PROMPT_PART_CLASS is not None:
+        return _USER_PROMPT_PART_CLASS
+
+    try:
+        import importlib
+
+        messages = importlib.import_module("pydantic_ai.messages")
+        _USER_PROMPT_PART_CLASS = getattr(messages, "UserPromptPart", None)
+
+        if _USER_PROMPT_PART_CLASS is None:
+            _USER_PROMPT_PART_CLASS = UserPromptPartFallback
+    except Exception:
+        _USER_PROMPT_PART_CLASS = UserPromptPartFallback
+
+    return _USER_PROMPT_PART_CLASS
+
+
+def create_user_message(content: str, state_manager: StateManager):
+    """Create a user message and add it to the session messages."""
+    from .message_handler import get_model_messages
+
+    model_request_cls = get_model_messages()[0]
+    UserPromptPart = get_user_prompt_part_class()
+    user_prompt_part = UserPromptPart(content=content, part_kind="user-prompt")
+    message = model_request_cls(parts=[user_prompt_part], kind="request")
+    state_manager.session.messages.append(message)
+    return message
+
+
+def get_tool_summary(tool_calls: list[dict[str, Any]]) -> dict[str, int]:
+    """Generate a summary of tool usage from tool calls."""
+    tool_summary: dict[str, int] = {}
+    for tc in tool_calls:
+        tool_name = tc.get("tool", "unknown")
+        tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
+    return tool_summary
+
+
+def get_tool_description(tool_name: str, tool_args: dict[str, Any]) -> str:
+    """Get a descriptive string for a tool call."""
+    tool_desc = tool_name
+    if tool_name in ["grep", "glob"] and isinstance(tool_args, dict):
+        pattern = tool_args.get("pattern", "")
+        tool_desc = f"{tool_name}('{pattern}')"
+    elif tool_name == "read_file" and isinstance(tool_args, dict):
+        path = tool_args.get("file_path", tool_args.get("filepath", ""))
+        tool_desc = f"{tool_name}('{path}')"
+    return tool_desc
+
+
+def get_recent_tools_context(tool_calls: list[dict[str, Any]], limit: int = 3) -> str:
+    """Get a context string describing recent tool usage."""
+    if not tool_calls:
+        return "No tools used yet"
+
+    last_tools = []
+    for tc in tool_calls[-limit:]:
+        tool_name = tc.get("tool", "unknown")
+        tool_args = tc.get("args", {})
+        tool_desc = get_tool_description(tool_name, tool_args)
+        last_tools.append(tool_desc)
+
+    return f"Recent tools: {', '.join(last_tools)}"
+
+
+def create_empty_response_message(
+    message: str,
+    empty_reason: str,
+    tool_calls: list[dict[str, Any]],
+    iteration: int,
+    state_manager: StateManager,
+) -> str:
+    """Create an aggressive message for handling empty responses."""
+    tools_context = get_recent_tools_context(tool_calls)
+
+    content = f"""FAILURE DETECTED: You returned {("an " + empty_reason if empty_reason != "empty" else "an empty")} response.
+
+This is UNACCEPTABLE. You FAILED to produce output.
+
+Task: {message[:200]}...
+{tools_context}
+Current iteration: {iteration}
+
+TRY AGAIN RIGHT NOW:
+
+1. If your search returned no results → Try a DIFFERENT search pattern
+2. If you found what you need → Use TUNACODE_TASK_COMPLETE
+3. If you're stuck → EXPLAIN SPECIFICALLY what's blocking you
+4. If you need to explore → Use list_dir or broader searches
+
+YOU MUST PRODUCE REAL OUTPUT IN THIS RESPONSE. NO EXCUSES.
+EXECUTE A TOOL OR PROVIDE SUBSTANTIAL CONTENT.
+DO NOT RETURN ANOTHER EMPTY RESPONSE."""
+
+    return content
+
+
+def create_progress_summary(tool_calls: list[dict[str, Any]]) -> tuple[dict[str, int], str]:
+    """Create a progress summary from tool calls."""
+    tool_summary = get_tool_summary(tool_calls)
+
+    if tool_summary:
+        summary_str = ", ".join([f"{name}: {count}" for name, count in tool_summary.items()])
+    else:
+        summary_str = "No tools used yet"
+
+    return tool_summary, summary_str
+
+
+def create_fallback_response(
+    iterations: int,
+    max_iterations: int,
+    tool_calls: list[dict[str, Any]],
+    messages: list[Any],
+    verbosity: str = "normal",
+) -> FallbackResponse:
+    """Create a comprehensive fallback response when iteration limit is reached."""
+    fallback = FallbackResponse(
+        summary="Reached maximum iterations without producing a final response.",
+        progress=f"Completed {iterations} iterations (limit: {max_iterations})",
+    )
+
+    # Extract context from messages
+    tool_calls_summary = []
+    files_modified = set()
+    commands_run = []
+
+    for msg in 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"])
+
+    if verbosity in ["normal", "detailed"]:
+        # Add what was attempted
+        if tool_calls_summary:
+            tool_counts: dict[str, int] = {}
+            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]:
+                    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]:
+                    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")
+
+    return fallback
+
+
+def format_fallback_output(fallback: FallbackResponse) -> str:
+    """Format a fallback response into a comprehensive output string."""
+    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}")
+
+    return "\n".join(output_parts)

tunacode/core/agents/agent_components/node_processor.py

@@ -6,10 +6,12 @@ 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.ui.tool_descriptions import get_batch_description, get_tool_description
 
 from .response_state import ResponseState
 from .task_completion import check_task_completion
 from .tool_buffer import ToolBuffer
+from .truncation_checker import check_for_truncation
 
 logger = get_logger(__name__)
 
@@ -171,7 +173,7 @@ async def _process_node(
             # Check for truncation patterns
             if all_content_parts:
                 combined_content = " ".join(all_content_parts).strip()
-                appears_truncated = _check_for_truncation(combined_content)
+                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
             # This prevents the agent from stopping when it gets empty responses
@@ -229,79 +231,6 @@ async def _process_node(
     return False, None
 
 
-def _check_for_truncation(combined_content: str) -> bool:
-    """Check if content appears to be truncated."""
-    if not combined_content:
-        return False
-
-    # Truncation indicators:
-    # 1. Ends with "..." or "…" (but not part of a complete sentence)
-    # 2. Ends mid-word (no punctuation, space, or complete word)
-    # 3. Contains incomplete markdown/code blocks
-    # 4. Ends with incomplete parentheses/brackets
-
-    # Check for ellipsis at end suggesting truncation
-    if combined_content.endswith(("...", "…")) and not combined_content.endswith(("....", "….")):
-        return True
-
-    # Check for mid-word truncation (ends with letters but no punctuation)
-    if combined_content and combined_content[-1].isalpha():
-        # Look for incomplete words by checking if last "word" seems cut off
-        words = combined_content.split()
-        if words:
-            last_word = words[-1]
-            # Common complete word endings vs likely truncations
-            complete_endings = (
-                "ing",
-                "ed",
-                "ly",
-                "er",
-                "est",
-                "tion",
-                "ment",
-                "ness",
-                "ity",
-                "ous",
-                "ive",
-                "able",
-                "ible",
-            )
-            incomplete_patterns = (
-                "referen",
-                "inte",
-                "proces",
-                "analy",
-                "deve",
-                "imple",
-                "execu",
-            )
-
-            if any(last_word.lower().endswith(pattern) for pattern in incomplete_patterns):
-                return True
-            elif len(last_word) > 2 and not any(
-                last_word.lower().endswith(end) for end in complete_endings
-            ):
-                # Likely truncated if doesn't end with common suffix
-                return True
-
-    # Check for unclosed markdown code blocks
-    code_block_count = combined_content.count("```")
-    if code_block_count % 2 != 0:
-        return True
-
-    # Check for unclosed brackets/parentheses (more opens than closes)
-    open_brackets = (
-        combined_content.count("[") + combined_content.count("(") + combined_content.count("{")
-    )
-    close_brackets = (
-        combined_content.count("]") + combined_content.count(")") + combined_content.count("}")
-    )
-    if open_brackets > close_brackets:
-        return True
-
-    return False
-
-
 async def _display_raw_api_response(node: Any, ui: Any) -> None:
     """Display raw API response data when thoughts are enabled."""
 
@@ -382,6 +311,14 @@ async def _process_tool_calls(
                 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,
+                    )
+
                     if state_manager.session.show_thoughts:
                         await ui.muted(
                             f"⏸️ BUFFERED: {part.tool_name} (will execute in parallel batch)"
@@ -399,45 +336,53 @@ async def _process_tool_calls(
 
                         start_time = time.time()
 
-                        # Enhanced visual feedback for parallel execution
-                        await ui.muted("\n" + "=" * 60)
-                        await ui.muted(
-                            f"🚀 PARALLEL BATCH #{batch_id}: Executing {len(buffered_tasks)} read-only tools concurrently"
+                        # 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
                         )
-                        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
+
+                        # 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
                                 ):
-                                    tool_desc += f" → pattern: '{buffered_part.args['pattern']}'"
-                            await ui.muted(tool_desc)
-                        await ui.muted("=" * 60)
+                                    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)
 
                         await execute_tools_parallel(buffered_tasks, tool_callback)
 
@@ -447,14 +392,36 @@ async def _process_tool_calls(
                         )  # Assume 100ms per tool average
                         speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
 
-                        await ui.muted(
-                            f"✅ Parallel batch completed in {elapsed_time:.0f}ms "
-                            f"(~{speedup:.1f}x faster than sequential)\n"
-                        )
+                        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)
 
                     # 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 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)
 
     # Track tool calls in session