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

tunacode/cli/commands/__init__.py

@@ -7,6 +7,8 @@ This package provides a modular command system with:
 
 The main public API provides backward compatibility with the original
 commands.py module while enabling better organization and maintainability.
+
+CLAUDE_ANCHOR[commands-module]: Command registry and dispatch system
 """
 
 # Import base classes and infrastructure

tunacode/cli/commands/implementations/plan.py

@@ -0,0 +1,50 @@
+"""Plan mode commands for TunaCode."""
+
+from typing import List
+
+from ....types import CommandContext
+from ....ui import console as ui
+from ..base import Command, CommandCategory, CommandSpec, SimpleCommand
+
+
+class PlanCommand(SimpleCommand):
+    """Enter plan mode for read-only research and planning."""
+    
+    spec = CommandSpec(
+        name="plan",
+        aliases=["/plan"],
+        description="Enter Plan Mode - read-only research phase",
+        category=CommandCategory.DEVELOPMENT,
+    )
+    
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        """Enter plan mode."""
+        context.state_manager.enter_plan_mode()
+        
+        await ui.info("🔍 Entering Plan Mode")
+        await ui.info("• Only read-only operations available")
+        await ui.info("• Use tools to research and analyze the codebase")
+        await ui.info("• Use 'exit_plan_mode' tool to present your plan")
+        await ui.info("• Read-only tools: read_file, grep, list_dir, glob")
+        await ui.success("✅ Plan Mode active - indicator will appear above next input")
+
+
+class ExitPlanCommand(SimpleCommand):
+    """Exit plan mode manually."""
+    
+    spec = CommandSpec(
+        name="exit-plan",
+        aliases=["/exit-plan"],
+        description="Exit Plan Mode and return to normal mode",
+        category=CommandCategory.DEVELOPMENT,
+    )
+    
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        """Exit plan mode manually."""
+        if not context.state_manager.is_plan_mode():
+            await ui.warning("Not currently in Plan Mode")
+            return
+        
+        context.state_manager.exit_plan_mode()
+        await ui.success("🚪 Exiting Plan Mode - returning to normal mode")
+        await ui.info("✅ All tools are now available - '⏸ PLAN MODE ON' status removed")

tunacode/cli/commands/registry.py

@@ -1,4 +1,7 @@
-"""Command registry and factory for TunaCode CLI commands."""
+"""Command registry and factory for TunaCode CLI commands.
+
+CLAUDE_ANCHOR[command-registry]: Central command registration and execution
+"""
 
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Type
@@ -20,6 +23,7 @@ from .implementations.debug import (
 )
 from .implementations.development import BranchCommand, InitCommand
 from .implementations.model import ModelCommand
+from .implementations.plan import ExitPlanCommand, PlanCommand
 from .implementations.system import (
     ClearCommand,
     HelpCommand,
@@ -126,6 +130,8 @@ class CommandRegistry:
             InitCommand,
             TemplateCommand,
             TodoCommand,
+            PlanCommand,        # Add plan command
+            ExitPlanCommand,    # Add exit plan command
         ]
 
         # Register all discovered commands

tunacode/cli/repl.py

@@ -3,6 +3,8 @@ Module: tunacode.cli.repl
 
 Interactive REPL (Read-Eval-Print Loop) implementation for TunaCode.
 Handles user input, command processing, and agent interaction in an interactive shell.
+
+CLAUDE_ANCHOR[repl-module]: Core REPL loop and user interaction handling
 """
 
 # ============================================================================
@@ -41,7 +43,7 @@ MSG_TOOL_INTERRUPTED = "Tool execution was interrupted"
 MSG_REQUEST_CANCELLED = "Request cancelled"
 MSG_SESSION_ENDED = "Session ended. Happy coding!"
 MSG_AGENT_BUSY = "Agent is busy, press Ctrl+C to interrupt."
-MSG_HIT_CTRL_C = "Hit Ctrl+C again to exit"
+MSG_HIT_ABORT_KEY = "Hit ESC or Ctrl+C again to exit"
 SHELL_ENV_VAR = "SHELL"
 DEFAULT_SHELL = "bash"
 
@@ -52,6 +54,324 @@ logger = logging.getLogger(__name__)
 # The _tool_handler function has been moved to repl_components.tool_executor
 
 
+def _transform_to_implementation_request(original_request: str) -> str:
+    """
+    Transform a planning request into an implementation request.
+
+    This ensures that after plan approval, the agent understands it should
+    implement rather than plan again.
+    """
+    # Remove plan-related language and add implementation language
+    request = original_request.lower()
+
+    if "plan" in request:
+        # Transform "plan a md file" -> "create a md file"
+        # Transform "plan to implement" -> "implement"
+        request = request.replace("plan a ", "create a ")
+        request = request.replace("plan an ", "create an ")
+        request = request.replace("plan to ", "")
+        request = request.replace("plan ", "create ")
+
+    # Add clear implementation instruction
+    implementation_request = f"{request}\n\nIMPORTANT: Actually implement and create the file(s) - do not just plan or outline. The plan has been approved, now execute the implementation."
+
+    return implementation_request
+
+
+async def _display_plan(plan_doc) -> None:
+    """Display the plan in a formatted way."""
+
+    if not plan_doc:
+        await ui.error("⚠️ Error: No plan document found to display")
+        return
+
+    output = []
+    output.append(f"[bold cyan]🎯 {plan_doc.title}[/bold cyan]")
+    output.append("")
+
+    if plan_doc.overview:
+        output.append(f"[bold]📝 Overview:[/bold] {plan_doc.overview}")
+        output.append("")
+
+    # Files section
+    if plan_doc.files_to_modify:
+        output.append("[bold]📝 Files to Modify:[/bold]")
+        for f in plan_doc.files_to_modify:
+            output.append(f"  • {f}")
+        output.append("")
+
+    if plan_doc.files_to_create:
+        output.append("[bold]📄 Files to Create:[/bold]")
+        for f in plan_doc.files_to_create:
+            output.append(f"  • {f}")
+        output.append("")
+
+    # Implementation steps
+    output.append("[bold]🔧 Implementation Steps:[/bold]")
+    for i, step in enumerate(plan_doc.steps, 1):
+        output.append(f"  {i}. {step}")
+    output.append("")
+
+    # Testing approach
+    if plan_doc.tests:
+        output.append("[bold]🧪 Testing Approach:[/bold]")
+        for test in plan_doc.tests:
+            output.append(f"  • {test}")
+        output.append("")
+
+    # Success criteria
+    if plan_doc.success_criteria:
+        output.append("[bold]✅ Success Criteria:[/bold]")
+        for criteria in plan_doc.success_criteria:
+            output.append(f"  • {criteria}")
+        output.append("")
+
+    # Risks and considerations
+    if plan_doc.risks:
+        output.append("[bold]⚠️ Risks & Considerations:[/bold]")
+        for risk in plan_doc.risks:
+            output.append(f"  • {risk}")
+        output.append("")
+
+    # Open questions
+    if plan_doc.open_questions:
+        output.append("[bold]❓ Open Questions:[/bold]")
+        for question in plan_doc.open_questions:
+            output.append(f"  • {question}")
+        output.append("")
+
+    # References
+    if plan_doc.references:
+        output.append("[bold]📚 References:[/bold]")
+        for ref in plan_doc.references:
+            output.append(f"  • {ref}")
+        output.append("")
+
+    # Rollback plan
+    if plan_doc.rollback:
+        output.append(f"[bold]🔄 Rollback Plan:[/bold] {plan_doc.rollback}")
+        output.append("")
+
+    # Display the plan in a cyan panel
+    await ui.panel("📋 IMPLEMENTATION PLAN", "\n".join(output), border_style="cyan")
+
+
+async def _detect_and_handle_text_plan(state_manager, agent_response, original_request):
+    """
+    Detect if agent presented a plan in text format and handle it.
+
+    This is a fallback for when agents ignore the present_plan tool requirement.
+    """
+    try:
+        # Extract response text
+        response_text = ""
+        if hasattr(agent_response, 'messages') and agent_response.messages:
+            latest_msg = agent_response.messages[-1]
+            if hasattr(latest_msg, 'content'):
+                response_text = str(latest_msg.content)
+            elif hasattr(latest_msg, 'text'):
+                response_text = str(latest_msg.text)
+        elif hasattr(agent_response, 'result') and hasattr(agent_response.result, 'output'):
+            response_text = str(agent_response.result.output)
+        else:
+            response_text = str(agent_response)
+
+        # Skip if agent just returned TUNACODE_TASK_COMPLETE or showed present_plan as text
+        if "TUNACODE_TASK_COMPLETE" in response_text:
+            logger.debug("Agent returned TUNACODE_TASK_COMPLETE instead of calling present_plan")
+            await ui.warning("⚠️ Agent failed to call present_plan tool. Please provide clearer instructions to plan the task.")
+            return
+
+        if "present_plan(" in response_text:
+            logger.debug("Agent showed present_plan as text instead of executing it")
+            await ui.error("❌ Agent showed present_plan as text instead of EXECUTING it as a tool!")
+            await ui.info("The agent must EXECUTE the present_plan tool, not show it as code.")
+            await ui.info("Try again with: 'Execute the present_plan tool to create a plan for...'")
+            return
+
+        # Check for plan indicators
+        plan_indicators = [
+            "plan for", "implementation plan", "here's a plan", "i'll create a plan",
+            "plan to write", "plan to create", "markdown file", "outline for the",
+            "plan title", "overview:", "steps:", "file title and introduction",
+            "main functions", "sections to cover", "structure for", "plan overview"
+        ]
+
+        has_plan_indicators = any(indicator in response_text.lower() for indicator in plan_indicators)
+
+        # Also check for structured content (numbered lists, bullet points, sections)
+        has_structure = bool(
+            ("1." in response_text or "2." in response_text or "3." in response_text) or
+            ("•" in response_text and response_text.count("•") >= 3) or
+            ("Title:" in response_text and "Overview:" in response_text)
+        )
+
+        if has_plan_indicators and has_structure:
+            # Agent presented a text plan - simulate the approval flow
+            await ui.line()
+            await ui.info("📋 Plan detected in text format - extracting for review")
+
+            # Create a simple plan from the text
+            from tunacode.types import PlanDoc, PlanPhase
+
+            # Extract title (simple heuristic)
+            title = "TunaCode Functions Overview Markdown File"
+            if "title:" in response_text.lower():
+                lines = response_text.split("\n")
+                for line in lines:
+                    if "title:" in line.lower():
+                        title = line.split(":", 1)[1].strip().strip('"')
+                        break
+
+            # Create basic plan structure from detected text
+            plan_doc = PlanDoc(
+                title=title,
+                overview="Create a comprehensive markdown file documenting TunaCode's main functions",
+                steps=[
+                    "Draft document structure with sections",
+                    "Detail each function with descriptions and examples",
+                    "Add usage guidelines and best practices",
+                    "Review and finalize content"
+                ],
+                files_to_modify=[],
+                files_to_create=["TunaCode_Functions_Overview.md"],
+                success_criteria=["Clear documentation of all main TunaCode functions"]
+            )
+
+            # Set plan ready state and trigger approval
+            state_manager.session.plan_phase = PlanPhase.PLAN_READY
+            state_manager.session.current_plan = plan_doc
+
+            await _handle_plan_approval(state_manager, original_request)
+
+    except Exception as e:
+        logger.error(f"Error detecting text plan: {e}")
+        # If detection fails, just continue normally
+
+
+async def _handle_plan_approval(state_manager, original_request=None):
+    """
+    Handle plan approval when a plan has been presented via present_plan tool.
+
+    This function:
+    1. Shows the user approval options (approve/modify/reject)
+    2. Handles the user's decision appropriately
+    3. Continues with implementation if approved
+    """
+    try:
+        from tunacode.types import PlanPhase
+
+        # Exit plan mode and move to review phase
+        state_manager.session.plan_phase = PlanPhase.REVIEW_DECISION
+        plan_doc = state_manager.session.current_plan
+        state_manager.exit_plan_mode(plan_doc)
+
+        await ui.line()
+        await ui.info("📋 Plan has been prepared and Plan Mode exited")
+        await ui.line()
+
+        # Display the plan content now
+        await _display_plan(plan_doc)
+
+        # Display approval options with better styling
+        await ui.line()
+        # Create content with exactly 45 characters per line for perfect alignment
+        content = (
+            "[bold cyan]The implementation plan has been presented.  [/bold cyan]\n\n"
+            "[yellow]Choose your action:                          [/yellow]\n\n"
+            "  [bold green]a[/bold green] → Approve and proceed with implementation\n"
+            "  [bold yellow]m[/bold yellow] → Modify the plan (return to Plan Mode)  \n"
+            "  [bold red]r[/bold red] → Reject and create different approach   \n"
+        )
+        await ui.panel("🎯 Plan Review", content, border_style="cyan")
+        await ui.line()
+
+        # Handle double-escape pattern like main REPL
+        from tunacode.ui.keybindings import create_key_bindings
+        kb = create_key_bindings(state_manager)
+
+        while True:
+            try:
+                response = await ui.input(
+                    session_key="plan_approval",
+                    pretext="  → Your choice [a/m/r]: ",
+                    key_bindings=kb,
+                    state_manager=state_manager
+                )
+                response = response.strip().lower()
+
+                # Reset abort flags on successful input
+                state_manager.session.approval_abort_pressed = False
+                state_manager.session.approval_last_abort_time = 0.0
+                break
+
+            except UserAbortError:
+                import time
+                current_time = time.time()
+
+                # Get current session state
+                approval_abort_pressed = getattr(state_manager.session, 'approval_abort_pressed', False)
+                approval_last_abort_time = getattr(state_manager.session, 'approval_last_abort_time', 0.0)
+
+                # Reset if more than 3 seconds have passed
+                if current_time - approval_last_abort_time > 3.0:
+                    approval_abort_pressed = False
+                    state_manager.session.approval_abort_pressed = False
+
+                if approval_abort_pressed:
+                    # Second escape - return to Plan Mode
+                    await ui.line()
+                    await ui.info("🔄 Returning to Plan Mode for further planning")
+                    await ui.line()
+                    state_manager.enter_plan_mode()
+                    # Clean up approval flags
+                    state_manager.session.approval_abort_pressed = False
+                    state_manager.session.approval_last_abort_time = 0.0
+                    return
+
+                # First escape - show warning and continue the loop
+                state_manager.session.approval_abort_pressed = True
+                state_manager.session.approval_last_abort_time = current_time
+                await ui.line()
+                await ui.warning("Hit ESC or Ctrl+C again to return to Plan Mode")
+                await ui.line()
+                continue
+
+        if response in ['a', 'approve']:
+            await ui.line()
+            await ui.success("✅ Plan approved - proceeding with implementation")
+            state_manager.approve_plan()
+            state_manager.session.plan_phase = None
+
+            # Continue processing the original request now that we're in normal mode
+            if original_request:
+                await ui.info("🚀 Executing implementation...")
+                await ui.line()
+                # Transform the original request to make it clear we want implementation, not more planning
+                implementation_request = _transform_to_implementation_request(original_request)
+                await process_request(implementation_request, state_manager, output=True)
+
+        elif response in ['m', 'modify']:
+            await ui.line()
+            await ui.info("📝 Returning to Plan Mode for modifications")
+            state_manager.enter_plan_mode()
+
+        elif response in ['r', 'reject']:
+            await ui.line()
+            await ui.warning("🔄 Plan rejected - returning to Plan Mode")
+            state_manager.enter_plan_mode()
+
+        else:
+            await ui.line()
+            await ui.warning("⚠️ Invalid choice - please enter a, m, or r")
+            state_manager.session.plan_phase = None
+
+    except Exception as e:
+        logger.error(f"Error in plan approval: {e}")
+        # If anything goes wrong, reset plan phase
+        state_manager.session.plan_phase = None
+
+
 # ============================================================================
 # COMMAND SYSTEM
 # ============================================================================
@@ -94,7 +414,10 @@ async def _handle_command(command: str, state_manager: StateManager) -> CommandR
 
 
 async def process_request(text: str, state_manager: StateManager, output: bool = True):
-    """Process input using the agent, handling cancellation safely."""
+    """Process input using the agent, handling cancellation safely.
+
+    CLAUDE_ANCHOR[process-request-repl]: REPL's main request processor with error handling
+    """
     import uuid
 
     # Generate a unique ID for this request for correlated logging
@@ -172,6 +495,14 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 await streaming_panel.stop()
                 state_manager.session.streaming_panel = None
                 state_manager.session.is_streaming_active = False
+
+            # Check if plan is ready for user review OR if agent presented text plan
+            from tunacode.types import PlanPhase
+            if hasattr(state_manager.session, 'plan_phase') and state_manager.session.plan_phase == PlanPhase.PLAN_READY:
+                await _handle_plan_approval(state_manager, text)
+            elif state_manager.is_plan_mode() and not getattr(state_manager.session, '_continuing_from_plan', False):
+                # Check if agent presented a text plan instead of using the tool
+                await _detect_and_handle_text_plan(state_manager, res, text)
         else:
             # Use normal agent processing
             res = await agent.process_request(
@@ -181,6 +512,14 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 tool_callback=tool_callback_with_state,
             )
 
+        # Check if plan is ready for user review OR if agent presented text plan
+        from tunacode.types import PlanPhase
+        if hasattr(state_manager.session, 'plan_phase') and state_manager.session.plan_phase == PlanPhase.PLAN_READY:
+            await _handle_plan_approval(state_manager, text)
+        elif state_manager.is_plan_mode() and not getattr(state_manager.session, '_continuing_from_plan', False):
+            # Check if agent presented a text plan instead of using the tool
+            await _detect_and_handle_text_plan(state_manager, res, text)
+
         if output:
             if state_manager.session.show_thoughts:
                 new_msgs = state_manager.session.messages[start_idx:]
@@ -200,7 +539,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 await ui.muted(MSG_REQUEST_COMPLETED)
             else:
                 # Use the dedicated function for displaying agent output
-                await display_agent_output(res, enable_streaming)
+                await display_agent_output(res, enable_streaming, state_manager)
 
             # Always show files in context after agent response
             if state_manager.session.files_in_context:
@@ -245,7 +584,8 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
 async def repl(state_manager: StateManager):
     """Main REPL loop that handles user interaction and input processing."""
     action = None
-    ctrl_c_pressed = False
+    abort_pressed = False
+    last_abort_time = 0.0
 
     model_name = state_manager.session.current_model
     max_tokens = (
@@ -270,16 +610,26 @@ async def repl(state_manager: StateManager):
             try:
                 line = await ui.multiline_input(state_manager, _command_registry)
             except UserAbortError:
-                if ctrl_c_pressed:
+                import time
+
+                current_time = time.time()
+
+                # Reset if more than 3 seconds have passed
+                if current_time - last_abort_time > 3.0:
+                    abort_pressed = False
+
+                if abort_pressed:
                     break
-                ctrl_c_pressed = True
-                await ui.warning(MSG_HIT_CTRL_C)
+
+                abort_pressed = True
+                last_abort_time = current_time
+                await ui.warning(MSG_HIT_ABORT_KEY)
                 continue
 
             if not line:
                 continue
 
-            ctrl_c_pressed = False
+            abort_pressed = False
 
             if line.lower() in ["exit", "quit"]:
                 break

tunacode/cli/repl_components/output_display.py

@@ -10,7 +10,7 @@ from tunacode.ui import console as ui
 MSG_REQUEST_COMPLETED = "Request completed"
 
 
-async def display_agent_output(res, enable_streaming: bool) -> None:
+async def display_agent_output(res, enable_streaming: bool, state_manager=None) -> None:
     """Display agent output using guard clauses to flatten nested conditionals."""
     if enable_streaming:
         return
@@ -29,5 +29,22 @@ async def display_agent_output(res, enable_streaming: bool) -> None:
 
     if '"tool_uses"' in output:
         return
+    
+    # In plan mode, don't display any agent text output at all
+    # The plan will be displayed via the present_plan tool
+    if state_manager and state_manager.is_plan_mode():
+        return
+    
+    # Filter out plan mode system prompts and tool definitions
+    if any(phrase in output for phrase in [
+        "PLAN MODE - TOOL EXECUTION ONLY",
+        "🔧 PLAN MODE",
+        "TOOL EXECUTION ONLY 🔧",
+        "planning assistant that ONLY communicates",
+        "namespace functions {",
+        "namespace multi_tool_use {",
+        "You are trained on data up to"
+    ]):
+        return
 
     await ui.agent(output)

tunacode/cli/repl_components/tool_executor.py

@@ -43,8 +43,9 @@ async def tool_handler(part, state_manager: StateManager):
     if tool_handler_instance.should_confirm(part.tool_name):
         await ui.info(f"Tool({part.tool_name})")
 
-    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-        state_manager.session.spinner.stop()
+    # Keep spinner running during tool execution - it will be updated with tool status
+    # if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+    #     state_manager.session.spinner.stop()
 
     streaming_panel = None
     if state_manager.session.is_streaming_active and hasattr(
@@ -58,6 +59,15 @@ async def tool_handler(part, state_manager: StateManager):
         args = parse_args(part.args)
 
         def confirm_func():
+            # Check if tool is blocked in plan mode first
+            if tool_handler_instance.is_tool_blocked_in_plan_mode(part.tool_name):
+                from tunacode.constants import READ_ONLY_TOOLS
+                error_msg = (f"🔍 Plan Mode: Tool '{part.tool_name}' is not available in Plan Mode.\n"
+                           f"Only read-only tools are allowed: {', '.join(READ_ONLY_TOOLS)}\n"
+                           f"Use 'exit_plan_mode' tool to present your plan and exit Plan Mode.")
+                print(f"\n❌ {error_msg}\n")
+                return True  # Abort the tool
+            
             if not tool_handler_instance.should_confirm(part.tool_name):
                 return False
             request = tool_handler_instance.create_confirmation_request(part.tool_name, args)
@@ -80,5 +90,6 @@ async def tool_handler(part, state_manager: StateManager):
         if streaming_panel and tool_handler_instance.should_confirm(part.tool_name):
             await streaming_panel.start()
 
-        if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-            state_manager.session.spinner.start()
+        # Spinner continues running - no need to restart
+        # if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+        #     state_manager.session.spinner.start()

tunacode/constants.py

@@ -9,7 +9,7 @@ from enum import Enum
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.54"
+APP_VERSION = "0.0.56"
 
 
 # File patterns
@@ -44,6 +44,7 @@ class ToolName(str, Enum):
     LIST_DIR = "list_dir"
     GLOB = "glob"
     TODO = "todo"
+    EXIT_PLAN_MODE = "exit_plan_mode"
 
 
 # Tool names (backward compatibility)
@@ -56,9 +57,10 @@ TOOL_GREP = ToolName.GREP
 TOOL_LIST_DIR = ToolName.LIST_DIR
 TOOL_GLOB = ToolName.GLOB
 TOOL_TODO = ToolName.TODO
+TOOL_EXIT_PLAN_MODE = ToolName.EXIT_PLAN_MODE
 
 # Tool categorization
-READ_ONLY_TOOLS = [ToolName.READ_FILE, ToolName.GREP, ToolName.LIST_DIR, ToolName.GLOB]
+READ_ONLY_TOOLS = [ToolName.READ_FILE, ToolName.GREP, ToolName.LIST_DIR, ToolName.GLOB, ToolName.EXIT_PLAN_MODE]
 WRITE_TOOLS = [ToolName.WRITE_FILE, ToolName.UPDATE_FILE]
 EXECUTE_TOOLS = [ToolName.BASH, ToolName.RUN_COMMAND]
 

tunacode/core/agents/agent_components/__init__.py

@@ -1,6 +1,17 @@
 """Agent components package for modular agent functionality."""
 
 from .agent_config import get_or_create_agent
+from .agent_helpers import (
+    create_empty_response_message,
+    create_fallback_response,
+    create_progress_summary,
+    create_user_message,
+    format_fallback_output,
+    get_recent_tools_context,
+    get_tool_description,
+    get_tool_summary,
+    get_user_prompt_part_class,
+)
 from .json_tool_parser import extract_and_execute_tool_calls, parse_json_tool_calls
 from .message_handler import get_model_messages, patch_tool_messages
 from .node_processor import _process_node
@@ -24,4 +35,13 @@ __all__ = [
     "check_task_completion",
     "ToolBuffer",
     "execute_tools_parallel",
+    "create_empty_response_message",
+    "create_fallback_response",
+    "create_progress_summary",
+    "create_user_message",
+    "format_fallback_output",
+    "get_recent_tools_context",
+    "get_tool_description",
+    "get_tool_summary",
+    "get_user_prompt_part_class",
 ]