tunacode-cli 0.0.36__py3-none-any.whl → 0.0.37__py3-none-any.whl

tunacode/cli/commands/implementations/__init__.py

@@ -12,13 +12,14 @@ from .debug import (
 )
 from .development import BranchCommand, InitCommand
 from .model import ModelCommand
-from .system import ClearCommand, HelpCommand, RefreshConfigCommand, UpdateCommand
+from .system import ClearCommand, HelpCommand, RefreshConfigCommand, StreamingCommand, UpdateCommand
 
 __all__ = [
     # System commands
     "HelpCommand",
     "ClearCommand",
     "RefreshConfigCommand",
+    "StreamingCommand",
     "UpdateCommand",
     # Debug commands
     "YoloCommand",

tunacode/cli/commands/implementations/system.py

@@ -175,3 +175,42 @@ class UpdateCommand(SimpleCommand):
             await ui.error(f"Update failed: {e}")
         except FileNotFoundError:
             await ui.error(f"Could not find {installation_method} executable")
+
+
+class StreamingCommand(SimpleCommand):
+    """Toggle streaming display on/off."""
+
+    spec = CommandSpec(
+        name="streaming",
+        aliases=["/streaming"],
+        description="Toggle streaming display on/off",
+        category=CommandCategory.SYSTEM,
+    )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        current_setting = context.state_manager.session.user_config.get("settings", {}).get(
+            "enable_streaming", True
+        )
+
+        if args and args[0].lower() in ["on", "true", "1", "enable", "enabled"]:
+            new_setting = True
+        elif args and args[0].lower() in ["off", "false", "0", "disable", "disabled"]:
+            new_setting = False
+        else:
+            # Toggle current setting
+            new_setting = not current_setting
+
+        # Update the configuration
+        if "settings" not in context.state_manager.session.user_config:
+            context.state_manager.session.user_config["settings"] = {}
+        context.state_manager.session.user_config["settings"]["enable_streaming"] = new_setting
+
+        status = "enabled" if new_setting else "disabled"
+        await ui.success(f"Streaming display {status}")
+
+        if new_setting:
+            await ui.muted(
+                "Responses will be displayed progressively as they are generated (default)"
+            )
+        else:
+            await ui.muted("Responses will be displayed all at once after completion")

tunacode/cli/commands/registry.py

@@ -19,7 +19,13 @@ from .implementations.debug import (
 )
 from .implementations.development import BranchCommand, InitCommand
 from .implementations.model import ModelCommand
-from .implementations.system import ClearCommand, HelpCommand, RefreshConfigCommand, UpdateCommand
+from .implementations.system import (
+    ClearCommand,
+    HelpCommand,
+    RefreshConfigCommand,
+    StreamingCommand,
+    UpdateCommand,
+)
 
 
 @dataclass
@@ -106,6 +112,7 @@ class CommandRegistry:
             FixCommand,
             ParseToolsCommand,
             RefreshConfigCommand,
+            StreamingCommand,
             UpdateCommand,
             HelpCommand,
             BranchCommand,

tunacode/cli/repl.py

@@ -70,8 +70,9 @@ async def _tool_confirm(tool_call, node, state_manager: StateManager):
             await _tool_ui.log_mcp(title, args)
         return
 
-    # Stop spinner during user interaction
-    state_manager.session.spinner.stop()
+    # Stop spinner during user interaction (only if not streaming)
+    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+        state_manager.session.spinner.stop()
 
     # Create confirmation request
     request = tool_handler.create_confirmation_request(tool_call.tool_name, args)
@@ -84,7 +85,10 @@ async def _tool_confirm(tool_call, node, state_manager: StateManager):
         raise UserAbortError("User aborted.")
 
     await ui.line()  # Add line after user input
-    state_manager.session.spinner.start()
+
+    # Restart spinner (only if not streaming)
+    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+        state_manager.session.spinner.start()
 
 
 async def _tool_handler(part, node, state_manager: StateManager):
@@ -96,7 +100,19 @@ async def _tool_handler(part, node, state_manager: StateManager):
     if tool_handler.should_confirm(part.tool_name):
         await ui.info(f"Tool({part.tool_name})")
 
-    state_manager.session.spinner.stop()
+    # Stop spinner only if not streaming
+    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+        state_manager.session.spinner.stop()
+
+    # Track if we need to stop/restart streaming panel
+    streaming_panel = None
+    if state_manager.session.is_streaming_active and hasattr(
+        state_manager.session, "streaming_panel"
+    ):
+        streaming_panel = state_manager.session.streaming_panel
+        # Stop the streaming panel to prevent UI interference during confirmation
+        if streaming_panel and tool_handler.should_confirm(part.tool_name):
+            await streaming_panel.stop()
 
     try:
         args = _parse_args(part.args)
@@ -128,7 +144,13 @@ async def _tool_handler(part, node, state_manager: StateManager):
         patch_tool_messages("Operation aborted by user.", state_manager)
         raise
     finally:
-        state_manager.session.spinner.start()
+        # Restart streaming panel if it was stopped
+        if streaming_panel and tool_handler.should_confirm(part.tool_name):
+            await streaming_panel.start()
+
+        # Restart spinner only if not streaming
+        if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+            state_manager.session.spinner.start()
 
 
 # Initialize command registry
@@ -195,38 +217,77 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             await ui.error(str(e))
             return
 
-        # Use normal agent processing
-        res = await agent.process_request(
-            state_manager.session.current_model,
-            text,
-            state_manager,
-            tool_callback=tool_callback_with_state,
+        # Check if streaming is enabled (default: True for better UX)
+        enable_streaming = state_manager.session.user_config.get("settings", {}).get(
+            "enable_streaming", True
         )
+
+        if enable_streaming:
+            # Stop spinner before starting streaming display (Rich.Live conflict)
+            await ui.spinner(False, state_manager.session.spinner, state_manager)
+
+            # Mark that streaming is active to prevent spinner conflicts
+            state_manager.session.is_streaming_active = True
+
+            # Use streaming agent processing
+            streaming_panel = ui.StreamingAgentPanel()
+            await streaming_panel.start()
+
+            # Store streaming panel reference in session for tool handler access
+            state_manager.session.streaming_panel = streaming_panel
+
+            try:
+
+                async def streaming_callback(content: str):
+                    await streaming_panel.update(content)
+
+                res = await agent.process_request(
+                    state_manager.session.current_model,
+                    text,
+                    state_manager,
+                    tool_callback=tool_callback_with_state,
+                    streaming_callback=streaming_callback,
+                )
+            finally:
+                await streaming_panel.stop()
+                # Clear streaming panel reference
+                state_manager.session.streaming_panel = None
+                # Mark streaming as inactive
+                state_manager.session.is_streaming_active = False
+                # Don't restart spinner - it will be stopped in the outer finally block anyway
+        else:
+            # Use normal agent processing
+            res = await agent.process_request(
+                state_manager.session.current_model,
+                text,
+                state_manager,
+                tool_callback=tool_callback_with_state,
+            )
         if output:
             if state_manager.session.show_thoughts:
                 new_msgs = state_manager.session.messages[start_idx:]
                 for msg in new_msgs:
                     if isinstance(msg, dict) and "thought" in msg:
                         await ui.muted(f"THOUGHT: {msg['thought']}")
-            # Check if result exists and has output
-            if hasattr(res, "result") and res.result is not None and hasattr(res.result, "output"):
-                await ui.agent(res.result.output)
-                # Always show files in context after agent response
-                if state_manager.session.files_in_context:
-                    # Extract just filenames from full paths for readability
-                    filenames = [
-                        Path(f).name for f in sorted(state_manager.session.files_in_context)
-                    ]
-                    await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
-            else:
-                # Fallback: show that the request was processed
-                await ui.muted("Request completed")
-                # Show files in context even for empty responses
-                if state_manager.session.files_in_context:
-                    filenames = [
-                        Path(f).name for f in sorted(state_manager.session.files_in_context)
-                    ]
-                    await ui.muted(f"Files in context: {', '.join(filenames)}")
+
+            # Only display result if not streaming (streaming already showed content)
+            if not enable_streaming:
+                # Check if result exists and has output
+                if (
+                    hasattr(res, "result")
+                    and res.result is not None
+                    and hasattr(res.result, "output")
+                ):
+                    await ui.agent(res.result.output)
+                else:
+                    # Fallback: show that the request was processed
+                    await ui.muted("Request completed")
+
+            # Always show files in context after agent response
+            if state_manager.session.files_in_context:
+                # Extract just filenames from full paths for readability
+                filenames = [Path(f).name for f in sorted(state_manager.session.files_in_context)]
+                await ui.muted(f"\nFiles in context: {', '.join(filenames)}")
     except CancelledError:
         await ui.muted("Request cancelled")
     except UserAbortError:

tunacode/constants.py

@@ -7,7 +7,7 @@ Centralizes all magic strings, UI text, error messages, and application constant
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.36"
+APP_VERSION = "0.0.37"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

tunacode/core/agents/main.py

@@ -12,6 +12,22 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Iterator, List, Optional, Tuple
 
+from pydantic_ai import Agent
+
+# 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
+
 from tunacode.constants import READ_ONLY_TOOLS
 from tunacode.core.state import StateManager
 from tunacode.services.mcp import get_mcp_servers
@@ -197,6 +213,7 @@ async def _process_node(
     tool_callback: Optional[ToolCallback],
     state_manager: StateManager,
     tool_buffer: Optional[ToolBuffer] = None,
+    streaming_callback: Optional[callable] = None,
 ):
     from tunacode.ui import console as ui
     from tunacode.utils.token_counter import estimate_tokens
@@ -216,6 +233,16 @@ async def _process_node(
     if hasattr(node, "model_response"):
         state_manager.session.messages.append(node.model_response)
 
+        # 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)
+                        await streaming_callback(content)
+
         # Enhanced display when thoughts are enabled
         if state_manager.session.show_thoughts:
             # Show raw API response data
@@ -683,6 +710,7 @@ async def process_request(
     message: str,
     state_manager: StateManager,
     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()
@@ -723,7 +751,19 @@ async def process_request(
         i = 0
         async for node in agent_run:
             state_manager.session.current_iteration = i + 1
-            await _process_node(node, tool_callback, state_manager, tool_buffer)
+
+            # 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)
             if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
                 if node.result.output:
                     response_state.has_user_response = True

tunacode/core/agents/utils.py

@@ -0,0 +1,304 @@
+import asyncio
+import importlib
+import json
+import os
+import re
+from collections.abc import Iterator
+from datetime import datetime, timezone
+from typing import Any
+
+from tunacode.constants import READ_ONLY_TOOLS
+from tunacode.types import (
+    ErrorMessage,
+    StateManager,
+    ToolCallback,
+    ToolCallId,
+    ToolName,
+)
+from tunacode.ui import console as ui
+
+
+# Lazy import for Agent and Tool
+def get_agent_tool():
+    pydantic_ai = importlib.import_module("pydantic_ai")
+    return pydantic_ai.Agent, pydantic_ai.Tool
+
+
+def get_model_messages():
+    messages = importlib.import_module("pydantic_ai.messages")
+    return messages.ModelRequest, messages.ToolReturnPart
+
+
+async def execute_tools_parallel(
+    tool_calls: list[tuple[Any, Any]], callback: ToolCallback, return_exceptions: bool = True
+) -> list[Any]:
+    """Execute multiple tool calls in parallel using asyncio.
+
+    Args:
+        tool_calls: List of (part, node) tuples
+        callback: The tool callback function to execute
+        return_exceptions: Whether to return exceptions or raise them
+
+    Returns:
+        List of results in the same order as input, with exceptions for failed calls
+    """
+    # Get max parallel from environment or default to CPU count
+    max_parallel = int(os.environ.get("TUNACODE_MAX_PARALLEL", os.cpu_count() or 4))
+
+    async def execute_with_error_handling(part, node):
+        try:
+            return await callback(part, node)
+        except Exception as e:
+            return e
+
+    # If we have more tools than max_parallel, execute in batches
+    if len(tool_calls) > max_parallel:
+        results = []
+        for i in range(0, len(tool_calls), max_parallel):
+            batch = tool_calls[i : i + max_parallel]
+            batch_tasks = [execute_with_error_handling(part, node) for part, node in batch]
+            batch_results = await asyncio.gather(*batch_tasks, return_exceptions=return_exceptions)
+            results.extend(batch_results)
+        return results
+    tasks = [execute_with_error_handling(part, node) for part, node in tool_calls]
+    return await asyncio.gather(*tasks, return_exceptions=return_exceptions)
+
+
+def batch_read_only_tools(tool_calls: list[Any]) -> Iterator[list[Any]]:
+    """Batch tool calls so read-only tools can be executed in parallel.
+
+    Yields batches where:
+    - Read-only tools are grouped together
+    - Write/execute tools are in their own batch (single item)
+    - Order within each batch is preserved
+
+    Args:
+        tool_calls: List of tool call objects with 'tool' attribute
+
+    Yields:
+        Batches of tool calls
+    """
+    if not tool_calls:
+        return
+
+    current_batch = []
+
+    for tool_call in tool_calls:
+        tool_name = tool_call.tool_name if hasattr(tool_call, "tool_name") else None
+
+        if tool_name in READ_ONLY_TOOLS:
+            # Add to current batch
+            current_batch.append(tool_call)
+        else:
+            # Yield any pending read-only batch
+            if current_batch:
+                yield current_batch
+                current_batch = []
+
+            # Yield write/execute tool as single-item batch
+            yield [tool_call]
+
+    # Yield any remaining read-only tools
+    if current_batch:
+        yield current_batch
+
+
+async def create_buffering_callback(
+    original_callback: ToolCallback, buffer: Any, state_manager: StateManager
+) -> ToolCallback:
+    """Create a callback wrapper that buffers read-only tools for parallel execution.
+
+    Args:
+        original_callback: The original tool callback
+        buffer: ToolBuffer instance to store read-only tools
+        state_manager: StateManager for UI access
+
+    Returns:
+        A wrapped callback function
+    """
+
+    async def buffering_callback(part, node):
+        tool_name = getattr(part, "tool_name", None)
+
+        if tool_name in READ_ONLY_TOOLS:
+            # Buffer read-only tools
+            buffer.add(part, node)
+            # Don't execute yet - will be executed in parallel batch
+            return None
+
+        # Non-read-only tool encountered - flush buffer first
+        if buffer.has_tasks():
+            buffered_tasks = buffer.flush()
+
+            # Execute buffered read-only tools in parallel
+            if state_manager.session.show_thoughts:
+                await ui.muted(f"Executing {len(buffered_tasks)} read-only tools in parallel")
+
+            await execute_tools_parallel(buffered_tasks, original_callback)
+
+        # Execute the non-read-only tool
+        return await original_callback(part, node)
+
+    return buffering_callback
+
+
+async def parse_json_tool_calls(
+    text: str, tool_callback: ToolCallback | None, state_manager: StateManager
+):
+    """Parse JSON tool calls from text when structured tool calling fails.
+    Fallback for when API providers don't support proper tool calling.
+    """
+    if not tool_callback:
+        return
+
+    # Pattern for JSON tool calls: {"tool": "tool_name", "args": {...}}
+    # Find potential JSON objects and parse them
+    potential_jsons = []
+    brace_count = 0
+    start_pos = -1
+
+    for i, char in enumerate(text):
+        if char == "{":
+            if brace_count == 0:
+                start_pos = i
+            brace_count += 1
+        elif char == "}":
+            brace_count -= 1
+            if brace_count == 0 and start_pos != -1:
+                potential_json = text[start_pos : i + 1]
+                try:
+                    parsed = json.loads(potential_json)
+                    if isinstance(parsed, dict) and "tool" in parsed and "args" in parsed:
+                        potential_jsons.append((parsed["tool"], parsed["args"]))
+                except json.JSONDecodeError:
+                    pass
+                start_pos = -1
+
+    matches = potential_jsons
+
+    for tool_name, args in matches:
+        try:
+            # Create a mock tool call object
+            class MockToolCall:
+                def __init__(self, tool_name: str, args: dict):
+                    self.tool_name = tool_name
+                    self.args = args
+                    self.tool_call_id = f"fallback_{datetime.now().timestamp()}"
+
+            class MockNode:
+                pass
+
+            # Execute the tool through the callback
+            mock_call = MockToolCall(tool_name, args)
+            mock_node = MockNode()
+
+            await tool_callback(mock_call, mock_node)
+
+            if state_manager.session.show_thoughts:
+                await ui.muted(f"FALLBACK: Executed {tool_name} via JSON parsing")
+
+        except Exception as e:
+            if state_manager.session.show_thoughts:
+                await ui.error(f"Error executing fallback tool {tool_name}: {e!s}")
+
+
+async def extract_and_execute_tool_calls(
+    text: str, tool_callback: ToolCallback | None, state_manager: StateManager
+):
+    """Extract tool calls from text content and execute them.
+    Supports multiple formats for maximum compatibility.
+    """
+    if not tool_callback:
+        return
+
+    # Format 1: {"tool": "name", "args": {...}}
+    await parse_json_tool_calls(text, tool_callback, state_manager)
+
+    # Format 2: Tool calls in code blocks
+    code_block_pattern = r'```json\s*(\{(?:[^{}]|"[^"]*"|(?:\{[^}]*\}))*"tool"(?:[^{}]|"[^"]*"|(?:\{[^}]*\}))*\})\s*```'
+    code_matches = re.findall(code_block_pattern, text, re.MULTILINE | re.DOTALL)
+
+    for match in code_matches:
+        try:
+            tool_data = json.loads(match)
+            if "tool" in tool_data and "args" in tool_data:
+
+                class MockToolCall:
+                    def __init__(self, tool_name: str, args: dict):
+                        self.tool_name = tool_name
+                        self.args = args
+                        self.tool_call_id = f"codeblock_{datetime.now().timestamp()}"
+
+                class MockNode:
+                    pass
+
+                mock_call = MockToolCall(tool_data["tool"], tool_data["args"])
+                mock_node = MockNode()
+
+                await tool_callback(mock_call, mock_node)
+
+                if state_manager.session.show_thoughts:
+                    await ui.muted(f"FALLBACK: Executed {tool_data['tool']} from code block")
+
+        except (json.JSONDecodeError, KeyError, Exception) as e:
+            if state_manager.session.show_thoughts:
+                await ui.error(f"Error parsing code block tool call: {e!s}")
+
+
+def patch_tool_messages(
+    error_message: ErrorMessage = "Tool operation failed",
+    state_manager: StateManager = None,
+):
+    """Find any tool calls without responses and add synthetic error responses for them.
+    Takes an error message to use in the synthesized tool response.
+
+    Ignores tools that have corresponding retry prompts as the model is already
+    addressing them.
+    """
+    if state_manager is None:
+        raise ValueError("state_manager is required for patch_tool_messages")
+
+    messages = state_manager.session.messages
+
+    if not messages:
+        return
+
+    # Map tool calls to their tool returns
+    tool_calls: dict[ToolCallId, ToolName] = {}  # tool_call_id -> tool_name
+    tool_returns: set[ToolCallId] = set()  # set of tool_call_ids with returns
+    retry_prompts: set[ToolCallId] = set()  # set of tool_call_ids with retry prompts
+
+    for message in messages:
+        if hasattr(message, "parts"):
+            for part in message.parts:
+                if (
+                    hasattr(part, "part_kind")
+                    and hasattr(part, "tool_call_id")
+                    and part.tool_call_id
+                ):
+                    if part.part_kind == "tool-call":
+                        tool_calls[part.tool_call_id] = part.tool_name
+                    elif part.part_kind == "tool-return":
+                        tool_returns.add(part.tool_call_id)
+                    elif part.part_kind == "retry-prompt":
+                        retry_prompts.add(part.tool_call_id)
+
+    # Identify orphaned tools (those without responses and not being retried)
+    for tool_call_id, tool_name in list(tool_calls.items()):
+        if tool_call_id not in tool_returns and tool_call_id not in retry_prompts:
+            # Import ModelRequest and ToolReturnPart lazily
+            model_request_cls, tool_return_part_cls = get_model_messages()
+            messages.append(
+                model_request_cls(
+                    parts=[
+                        tool_return_part_cls(
+                            tool_name=tool_name,
+                            content=error_message,
+                            tool_call_id=tool_call_id,
+                            timestamp=datetime.now(timezone.utc),
+                            part_kind="tool-return",
+                        )
+                    ],
+                    kind="request",
+                )
+            )

tunacode/core/setup/config_setup.py

@@ -107,7 +107,6 @@ class ConfigSetup(BaseSetup):
                     "--key 'your-key' --baseurl 'https://openrouter.ai/api/v1'[/green]"
                 )
                 console.print("\n[yellow]Run 'tunacode --help' for more options[/yellow]\n")
-                from tunacode.exceptions import ConfigurationError
 
                 raise ConfigurationError(
                     "No configuration found. Please use CLI flags to configure."

tunacode/core/state.py

@@ -42,6 +42,10 @@ class SessionState:
     tool_calls: list[dict[str, Any]] = field(default_factory=list)
     iteration_count: int = 0
     current_iteration: int = 0
+    # Track streaming state to prevent spinner conflicts
+    is_streaming_active: bool = False
+    # Track streaming panel reference for tool handler access
+    streaming_panel: Optional[Any] = None
 
 
 class StateManager:

tunacode/ui/console.py

@@ -27,7 +27,9 @@ from .output import (
 
 # Patch banner to use sync fast version
 from .panels import (
+    StreamingAgentPanel,
     agent,
+    agent_streaming,
     dump_messages,
     error,
     help,
@@ -79,11 +81,13 @@ __all__ = [
     "warning",
     # From panels module
     "agent",
+    "agent_streaming",
     "dump_messages",
     "error",
     "help",
     "models",
     "panel",
+    "StreamingAgentPanel",
     "sync_panel",
     "sync_tool_confirm",
     "tool_confirm",

tunacode/ui/panels.py

@@ -3,6 +3,7 @@
 from typing import Any, Optional, Union
 
 from rich.box import ROUNDED
+from rich.live import Live
 from rich.markdown import Markdown
 from rich.padding import Padding
 from rich.panel import Panel
@@ -74,6 +75,79 @@ async def agent(text: str, bottom: int = 1) -> None:
     await panel(title, Markdown(text), bottom=bottom, border_style=colors.primary)
 
 
+class StreamingAgentPanel:
+    """Streaming agent panel using Rich.Live for progressive display."""
+
+    def __init__(self, bottom: int = 1):
+        self.bottom = bottom
+        self.title = f"[bold {colors.primary}]●[/bold {colors.primary}] {APP_NAME}"
+        self.content = ""
+        self.live = None
+
+    def _create_panel(self) -> Panel:
+        """Create a Rich panel with current content."""
+        markdown_content = Markdown(self.content or "Thinking...")
+        panel_obj = Panel(
+            Padding(markdown_content, (0, 1, 0, 1)),
+            title=f"[bold]{self.title}[/bold]",
+            title_align="left",
+            border_style=colors.primary,
+            padding=(0, 1),
+            box=ROUNDED,
+        )
+        return Padding(
+            panel_obj,
+            (
+                DEFAULT_PANEL_PADDING["top"],
+                DEFAULT_PANEL_PADDING["right"],
+                self.bottom,
+                DEFAULT_PANEL_PADDING["left"],
+            ),
+        )
+
+    async def start(self):
+        """Start the live streaming display."""
+        from .output import console
+
+        self.live = Live(self._create_panel(), console=console, refresh_per_second=4)
+        self.live.start()
+
+    async def update(self, content_chunk: str):
+        """Update the streaming display with new content."""
+        self.content += content_chunk
+        if self.live:
+            self.live.update(self._create_panel())
+
+    async def set_content(self, content: str):
+        """Set the complete content (overwrites previous)."""
+        self.content = content
+        if self.live:
+            self.live.update(self._create_panel())
+
+    async def stop(self):
+        """Stop the live streaming display."""
+        if self.live:
+            self.live.stop()
+            self.live = None
+
+
+async def agent_streaming(content_stream, bottom: int = 1):
+    """Display an agent panel with streaming content updates.
+
+    Args:
+        content_stream: Async iterator yielding content chunks
+        bottom: Bottom padding for the panel
+    """
+    panel = StreamingAgentPanel(bottom=bottom)
+    await panel.start()
+
+    try:
+        async for chunk in content_stream:
+            await panel.update(chunk)
+    finally:
+        await panel.stop()
+
+
 async def error(text: str) -> None:
     """Display an error panel."""
     await panel(PANEL_ERROR, text, style=colors.error)

tunacode/ui/utils.py

@@ -0,0 +1,3 @@
+from rich.console import Console as RichConsole
+
+console = RichConsole()

{tunacode_cli-0.0.36.dist-info → tunacode_cli-0.0.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.36
+Version: 0.0.37
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT
@@ -26,9 +26,7 @@ Requires-Dist: pygments==2.19.1
 Requires-Dist: rich==14.0.0
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
-Requires-Dist: black; extra == "dev"
-Requires-Dist: flake8; extra == "dev"
-Requires-Dist: isort; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
@@ -70,7 +68,7 @@ Choose your AI provider and set your API key:
 # OpenAI
 tunacode --model "openai:gpt-4o" --key "sk-your-openai-key"
 
-# Anthropic Claude  
+# Anthropic Claude
 tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
 
 # OpenRouter (100+ models)
@@ -82,13 +80,14 @@ Your config is saved to `~/.config/tunacode.json` (edit directly with `nvim ~/.c
 ### Recommended Models
 
 Based on extensive testing, these models provide the best performance:
+
 - `google/gemini-2.5-pro` - Excellent for complex reasoning
 - `openai/gpt-4.1` - Strong general-purpose model
 - `deepseek/deepseek-r1-0528` - Great for code generation
 - `openai/gpt-4.1-mini` - Fast and cost-effective
 - `anthropic/claude-4-sonnet-20250522` - Superior context handling
 
-*Note: Formal evaluations coming soon. Any model can work, but these have shown the best results in practice.*
+_Note: Formal evaluations coming soon. Any model can work, but these have shown the best results in practice._
 
 ## Start Coding
 
@@ -98,16 +97,16 @@ tunacode
 
 ## Basic Commands
 
-| Command | Description |
-| ------- | ----------- |
-| `/help` | Show all commands |
-| `/model <provider:name>` | Switch model |
-| `/clear` | Clear message history |
-| `/compact` | Summarize conversation |
-| `/branch <name>` | Create Git branch |
-| `/yolo` | Skip confirmations |
-| `!<command>` | Run shell command |
-| `exit` | Exit TunaCode |
+| Command                  | Description            |
+| ------------------------ | ---------------------- |
+| `/help`                  | Show all commands      |
+| `/model <provider:name>` | Switch model           |
+| `/clear`                 | Clear message history  |
+| `/compact`               | Summarize conversation |
+| `/branch <name>`         | Create Git branch      |
+| `/yolo`                  | Skip confirmations     |
+| `!<command>`             | Run shell command      |
+| `exit`                   | Exit TunaCode          |
 
 ## Performance
 
@@ -122,11 +121,12 @@ Multiple file reads, directory listings, and searches execute concurrently using
 - **Streaming UI**: Currently working on implementing streaming responses for better user experience
 - **Bug Fixes**: Actively addressing issues - please report any bugs you encounter!
 
-*Note: While the tool is fully functional, we're focusing on stability and core features before optimizing for speed.*
+_Note: While the tool is fully functional, we're focusing on stability and core features before optimizing for speed._
 
 ## Safety First
 
 ⚠️ **Important**: TunaCode can modify your codebase. Always:
+
 - Use Git branches before making changes
 - Review file modifications before confirming
 - Keep backups of important work

{tunacode_cli-0.0.36.dist-info → tunacode_cli-0.0.37.dist-info}/RECORD

@@ -1,5 +1,5 @@
 tunacode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tunacode/constants.py,sha256=SUeDFVdhj0Z4SxhlMn5km_34uKHDAW6gQZqHDybEgfE,4074
+tunacode/constants.py,sha256=ri3tiaz69KDnxnTdQDQxcz85_qXe4P3JE7KafTpDroU,4074
 tunacode/context.py,sha256=6sterdRvPOyG3LU0nEAXpBsEPZbO3qtPyTlJBi-_VXE,2612
 tunacode/exceptions.py,sha256=mTWXuWyr1k16CGLWN2tsthDGi7lbx1JK0ekIqogYDP8,3105
 tunacode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -7,35 +7,36 @@ tunacode/setup.py,sha256=XPt4eAK-qcIZQv64jGZ_ryxcImDwps9OmXjJfIS1xcs,1899
 tunacode/types.py,sha256=BciT-uxnQ44iC-4QiDY72OD23LOtqSyMOuK_N0ttlaA,7676
 tunacode/cli/__init__.py,sha256=zgs0UbAck8hfvhYsWhWOfBe5oK09ug2De1r4RuQZREA,55
 tunacode/cli/main.py,sha256=PIcFnfmIoI_pmK2y-zB_ouJbzR5fbSI7zsKQNPB_J8o,2406
-tunacode/cli/repl.py,sha256=ELnJBk3Vn2almXmmCIjGfgi7J5kNNVnO0o4KNYGXF9Q,14556
+tunacode/cli/repl.py,sha256=SoW5QiMohHB6BLuP8grCdNrrJq-HTF80p6RFmoMMeqk,17227
 tunacode/cli/textual_app.py,sha256=14-Nt0IIETmyHBrNn9uwSF3EwCcutwTp6gdoKgNm0sY,12593
 tunacode/cli/textual_bridge.py,sha256=LvqiTtF0hu3gNujzpKaW9h-m6xzEP3OH2M8KL2pCwRc,6333
 tunacode/cli/commands/__init__.py,sha256=YMrLz7szrmseJCRZGGX6_TyO3dJU8_QDCOFEhRAztzo,1634
 tunacode/cli/commands/base.py,sha256=GxUuDsDSpz0iXryy8MrEw88UM3C3yxL__kDK1QhshoA,2517
-tunacode/cli/commands/registry.py,sha256=9m8rbtrjd9oaVPnCeU4UhIWR8qa7QpPUrWDR2aqFyzE,8079
-tunacode/cli/commands/implementations/__init__.py,sha256=B0w124eXbcI3Aaai9nllbciFOWvLFTPlZ0RdLlCLP3M,875
+tunacode/cli/commands/registry.py,sha256=d2dSAKrz_c02zU2AKtWghqPmm-p7XG_L81yj9nI1qu8,8152
+tunacode/cli/commands/implementations/__init__.py,sha256=sRFG2aktjtWt-M0Co_GdeLjODiVjEFqHDcLyyVabj8M,917
 tunacode/cli/commands/implementations/conversation.py,sha256=EsnsZB6yyVI_sbNNMvk37tCz3iAj4E85R9ev696qeqg,4683
 tunacode/cli/commands/implementations/debug.py,sha256=TdP72Dpd3Nq3lwwyj0qZEdbSjDDmRyFu-0t6ttPFNno,6769
 tunacode/cli/commands/implementations/development.py,sha256=kZRdVgReVmGU0uijFxtPio2RYkTrYMufOwgI1Aj1_NU,2729
 tunacode/cli/commands/implementations/model.py,sha256=uthx6IX9KwgwywNTDklkJpqCbaTX9h1_p-eVmqL73WQ,2245
-tunacode/cli/commands/implementations/system.py,sha256=AuUfZ2cMGlzMpT7yh2Yr5HnpY6DhcjmXZCrd3NkzVz4,6435
+tunacode/cli/commands/implementations/system.py,sha256=2cGw5iCJO3aNhXTFF28CgAIyLgslvHmpfyL2ZHVB6oQ,7903
 tunacode/configuration/__init__.py,sha256=MbVXy8bGu0yKehzgdgZ_mfWlYGvIdb1dY2Ly75nfuPE,17
 tunacode/configuration/defaults.py,sha256=lNeJUW1S8zj4-XTCkMP9UaDc-tHWXLff9K8t0uPA_oE,801
 tunacode/configuration/models.py,sha256=XPobkLM_TzKTuMIWhK-svJfGRGFT9r2LhKEM6rv6QHk,3756
 tunacode/configuration/settings.py,sha256=KoN0u6GG3Hh_TWt02D_wpRfbACYri3gCDTXHtJfHl2w,994
 tunacode/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/code_index.py,sha256=jgAx3lSWP_DwnyiP5Jkm1YvX4JJyI4teMzlNrJSpEOA,15661
-tunacode/core/state.py,sha256=x0ZHqfaz8P5EhJoqeVNBa7O9BRytuzFCHK7wFao2R_E,1611
+tunacode/core/state.py,sha256=d2xUa7sRYizVc1mkaQN4aU034VSeh9nxQadzpL-aRas,1810
 tunacode/core/tool_handler.py,sha256=BPjR013OOO0cLXPdLeL2FDK0ixUwOYu59FfHdcdFhp4,2277
 tunacode/core/agents/__init__.py,sha256=UUJiPYb91arwziSpjd7vIk7XNGA_4HQbsOIbskSqevA,149
-tunacode/core/agents/main.py,sha256=s1B5oGKDjdUCH5xpL-Cy6i3cAr-tPM9_RDByOs7-qtE,39456
+tunacode/core/agents/main.py,sha256=BkAyqSr-xgENdyEmrPrx-E21ljclSU36EJh675Vhttk,41173
+tunacode/core/agents/utils.py,sha256=VaNsPB2l1dAP-VlS_QLRKvCb4NW0pXNRoxkh12AGXAg,10744
 tunacode/core/background/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/background/manager.py,sha256=rJdl3eDLTQwjbT7VhxXcJbZopCNR3M8ZGMbmeVnwwMc,1126
 tunacode/core/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/setup/__init__.py,sha256=lzdpY6rIGf9DDlDBDGFvQZaSOQeFsNglHbkpq1-GtU8,376
 tunacode/core/setup/agent_setup.py,sha256=trELO8cPnWo36BBnYmXDEnDPdhBg0p-VLnx9A8hSSSQ,1401
 tunacode/core/setup/base.py,sha256=cbyT2-xK2mWgH4EO17VfM_OM2bj0kT895NW2jSXbe3c,968
-tunacode/core/setup/config_setup.py,sha256=LnIGZrqDCWUhiMhJMnKX1gyaZhy6pKM8xf_fy_t9B3U,14516
+tunacode/core/setup/config_setup.py,sha256=xOQcjlFEL7HtGXH7wtpu83S6oA9K02wLYR1r-cWINpI,14449
 tunacode/core/setup/coordinator.py,sha256=oVTN2xIeJERXitVJpkIk9tDGLs1D1bxIRmaogJwZJFI,2049
 tunacode/core/setup/environment_setup.py,sha256=n3IrObKEynHZSwtUJ1FddMg2C4sHz7ca42awemImV8s,2225
 tunacode/core/setup/git_safety_setup.py,sha256=CRIqrQt0QUJQRS344njty_iCqTorrDhHlXRuET7w0Tk,6714
@@ -55,16 +56,17 @@ tunacode/tools/update_file.py,sha256=bW1MhTzRjBDjJzqQ6A1yCVEbkr1oIqtEC8uqcg_rfY4
 tunacode/tools/write_file.py,sha256=prL6u8XOi9ZyPU-YNlG9YMLbSLrDJXDRuDX73ncXh-k,2699
 tunacode/ui/__init__.py,sha256=aRNE2pS50nFAX6y--rSGMNYwhz905g14gRd6g4BolYU,13
 tunacode/ui/completers.py,sha256=Jx1zyCESwdm_4ZopvCBtb0bCJF-bRy8aBWG2yhPQtDc,4878
-tunacode/ui/console.py,sha256=8Z_GqmxgjSy-k7hrEMiT6NRSW9-pv0LVAWiEaun0UKw,1983
+tunacode/ui/console.py,sha256=YXNFlnV7n4wyaIy-VohzIMJJ71C7fzgcjuLheNIO-QU,2079
 tunacode/ui/constants.py,sha256=A76B_KpM8jCuBYRg4cPmhi8_j6LLyWttO7_jjv47r3w,421
 tunacode/ui/decorators.py,sha256=e2KM-_pI5EKHa2M045IjUe4rPkTboxaKHXJT0K3461g,1914
 tunacode/ui/input.py,sha256=6LlEwKIXYXusNDI2PD0DDjRymQgu5mf2v06TsHbUln0,2957
 tunacode/ui/keybindings.py,sha256=h0MlD73CW_3i2dQzb9EFSPkqy0raZ_isgjxUiA9u6ts,691
 tunacode/ui/lexers.py,sha256=tmg4ic1enyTRLzanN5QPP7D_0n12YjX_8ZhsffzhXA4,1340
 tunacode/ui/output.py,sha256=kjVklUZumGwjV8LeB7aX1WjcwAbURnuudZZY1t4qsN4,4499
-tunacode/ui/panels.py,sha256=iyV8W85PQbmXe1dCUi_NdCqy9NsBXvQvAVO1mEldfmg,5913
+tunacode/ui/panels.py,sha256=IZpiWBb7jVXaycH5BPAnqTCs2-_ccJYq2V55MxkVHzQ,8199
 tunacode/ui/prompt_manager.py,sha256=U2cntB34vm-YwOj3gzFRUK362zccrz8pigQfpxr5sv8,4650
 tunacode/ui/tool_ui.py,sha256=S5-k1HwRlSqiQ8shGQ_QYGXQbuzb6Pg7u3CTqZwffdQ,6533
+tunacode/ui/utils.py,sha256=P3RVc1j9XfRfLn3cEkaZnLD-pJKN_p27xmuaV4evHPo,73
 tunacode/ui/validators.py,sha256=MMIMT1I2v0l2jIy-gxX_4GSApvUTi8XWIOACr_dmoBA,758
 tunacode/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/utils/bm25.py,sha256=yq7KFWP3g_zIsjUV7l2hFPXYCzXyNQUInLU7u4qsc_4,1909
@@ -77,9 +79,9 @@ tunacode/utils/system.py,sha256=FSoibTIH0eybs4oNzbYyufIiV6gb77QaeY2yGqW39AY,1138
 tunacode/utils/text_utils.py,sha256=IiRviMqz5uoAbid8emkRXxgvQz6KE27ZeQom-qh9ymI,2984
 tunacode/utils/token_counter.py,sha256=nGCWwrHHFbKywqeDCEuJnADCkfJuzysWiB6cCltJOKI,648
 tunacode/utils/user_configuration.py,sha256=Ilz8dpGVJDBE2iLWHAPT0xR8D51VRKV3kIbsAz8Bboc,3275
-tunacode_cli-0.0.36.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-tunacode_cli-0.0.36.dist-info/METADATA,sha256=tEeGgHlHzd2exCxoGz8VPTmefH9kvGhNsOYWeJyjKic,4943
-tunacode_cli-0.0.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tunacode_cli-0.0.36.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
-tunacode_cli-0.0.36.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
-tunacode_cli-0.0.36.dist-info/RECORD,,
+tunacode_cli-0.0.37.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+tunacode_cli-0.0.37.dist-info/METADATA,sha256=1DdlPYbydBr_Wcjnzr6lpCUxSRCE5R7qatJVSqJjj1w,5064
+tunacode_cli-0.0.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tunacode_cli-0.0.37.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
+tunacode_cli-0.0.37.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
+tunacode_cli-0.0.37.dist-info/RECORD,,