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

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
@@ -23,8 +39,18 @@ from tunacode.tools.read_file import read_file
 from tunacode.tools.run_command import run_command
 from tunacode.tools.update_file import update_file
 from tunacode.tools.write_file import write_file
-from tunacode.types import (AgentRun, ErrorMessage, FallbackResponse, ModelName, PydanticAgent,
-                            ResponseState, SimpleResult, ToolCallback, ToolCallId, ToolName)
+from tunacode.types import (
+    AgentRun,
+    ErrorMessage,
+    FallbackResponse,
+    ModelName,
+    PydanticAgent,
+    ResponseState,
+    SimpleResult,
+    ToolCallback,
+    ToolCallId,
+    ToolName,
+)
 
 
 class ToolBuffer:
@@ -187,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
@@ -206,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
@@ -673,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()
@@ -713,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

@@ -8,8 +8,15 @@ import uuid
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
-from tunacode.types import (DeviceId, InputSessions, MessageHistory, ModelName, SessionId, ToolName,
-                            UserConfig)
+from tunacode.types import (
+    DeviceId,
+    InputSessions,
+    MessageHistory,
+    ModelName,
+    SessionId,
+    ToolName,
+    UserConfig,
+)
 
 
 @dataclass
@@ -35,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/setup.py

@@ -7,8 +7,13 @@ Provides high-level setup functions for initializing the application and its age
 
 from typing import Any, Optional
 
-from tunacode.core.setup import (AgentSetup, ConfigSetup, EnvironmentSetup, GitSafetySetup,
-                                 SetupCoordinator)
+from tunacode.core.setup import (
+    AgentSetup,
+    ConfigSetup,
+    EnvironmentSetup,
+    GitSafetySetup,
+    SetupCoordinator,
+)
 from tunacode.core.state import StateManager
 
 

tunacode/tools/read_file.py

@@ -8,8 +8,14 @@ Provides safe file reading with size limits and proper error handling.
 import asyncio
 import os
 
-from tunacode.constants import (ERROR_FILE_DECODE, ERROR_FILE_DECODE_DETAILS, ERROR_FILE_NOT_FOUND,
-                                ERROR_FILE_TOO_LARGE, MAX_FILE_SIZE, MSG_FILE_SIZE_LIMIT)
+from tunacode.constants import (
+    ERROR_FILE_DECODE,
+    ERROR_FILE_DECODE_DETAILS,
+    ERROR_FILE_NOT_FOUND,
+    ERROR_FILE_TOO_LARGE,
+    MAX_FILE_SIZE,
+    MSG_FILE_SIZE_LIMIT,
+)
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import FileBasedTool
 from tunacode.types import ToolResult

tunacode/tools/read_file_async_poc.py

@@ -11,8 +11,14 @@ import sys
 from concurrent.futures import ThreadPoolExecutor
 from typing import Optional
 
-from tunacode.constants import (ERROR_FILE_DECODE, ERROR_FILE_DECODE_DETAILS, ERROR_FILE_NOT_FOUND,
-                                ERROR_FILE_TOO_LARGE, MAX_FILE_SIZE, MSG_FILE_SIZE_LIMIT)
+from tunacode.constants import (
+    ERROR_FILE_DECODE,
+    ERROR_FILE_DECODE_DETAILS,
+    ERROR_FILE_NOT_FOUND,
+    ERROR_FILE_TOO_LARGE,
+    MAX_FILE_SIZE,
+    MSG_FILE_SIZE_LIMIT,
+)
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import FileBasedTool
 from tunacode.types import ToolResult
@@ -150,17 +156,18 @@ async def read_file_async(filepath: str) -> str:
 # Benchmarking utilities for testing
 async def benchmark_read_performance():
     """Benchmark the performance difference between sync and async reads."""
+    import contextlib
+    import tempfile
     import time
 
     from tunacode.tools.read_file import read_file as read_file_sync
 
-    # Create some test files
+    # Create some test files using tempfile for secure temporary file creation
     test_files = []
-    for i in range(10):
-        filepath = f"/tmp/test_file_{i}.txt"
-        with open(filepath, "w") as f:
-            f.write("x" * 10000)  # 10KB file
-        test_files.append(filepath)
+    for _ in range(10):
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as temp_file:
+            temp_file.write("x" * 10000)  # 10KB file
+            test_files.append(temp_file.name)
 
     # Test synchronous reads (sequential)
     start_time = time.time()
@@ -174,9 +181,10 @@ async def benchmark_read_performance():
     await asyncio.gather(*tasks)
     async_time = time.time() - start_time
 
-    # Cleanup
+    # Cleanup using safe file removal
     for filepath in test_files:
-        os.unlink(filepath)
+        with contextlib.suppress(OSError):
+            os.unlink(filepath)
 
     print(f"Synchronous reads: {sync_time:.3f}s")
     print(f"Async reads: {async_time:.3f}s")

tunacode/tools/run_command.py

@@ -7,10 +7,17 @@ Provides controlled shell command execution with output capture and truncation.
 
 import subprocess
 
-from tunacode.constants import (CMD_OUTPUT_FORMAT, CMD_OUTPUT_NO_ERRORS, CMD_OUTPUT_NO_OUTPUT,
-                                CMD_OUTPUT_TRUNCATED, COMMAND_OUTPUT_END_SIZE,
-                                COMMAND_OUTPUT_START_INDEX, COMMAND_OUTPUT_THRESHOLD,
-                                ERROR_COMMAND_EXECUTION, MAX_COMMAND_OUTPUT)
+from tunacode.constants import (
+    CMD_OUTPUT_FORMAT,
+    CMD_OUTPUT_NO_ERRORS,
+    CMD_OUTPUT_NO_OUTPUT,
+    CMD_OUTPUT_TRUNCATED,
+    COMMAND_OUTPUT_END_SIZE,
+    COMMAND_OUTPUT_START_INDEX,
+    COMMAND_OUTPUT_THRESHOLD,
+    ERROR_COMMAND_EXECUTION,
+    MAX_COMMAND_OUTPUT,
+)
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import BaseTool
 from tunacode.types import ToolResult

tunacode/ui/console.py

@@ -9,11 +9,36 @@ from rich.markdown import Markdown
 # Import and re-export all functions from specialized modules
 from .input import formatted_text, input, multiline_input
 from .keybindings import create_key_bindings
-from .output import (banner, clear, info, line, muted, print, spinner, success, sync_print,
-                     update_available, usage, version, warning)
+from .output import (
+    banner,
+    clear,
+    info,
+    line,
+    muted,
+    print,
+    spinner,
+    success,
+    sync_print,
+    update_available,
+    usage,
+    version,
+    warning,
+)
+
 # Patch banner to use sync fast version
-from .panels import (agent, dump_messages, error, help, models, panel, sync_panel,
-                     sync_tool_confirm, tool_confirm)
+from .panels import (
+    StreamingAgentPanel,
+    agent,
+    agent_streaming,
+    dump_messages,
+    error,
+    help,
+    models,
+    panel,
+    sync_panel,
+    sync_tool_confirm,
+    tool_confirm,
+)
 from .prompt_manager import PromptConfig, PromptManager
 from .validators import ModelValidator
 
@@ -56,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/output.py

@@ -5,8 +5,13 @@ from rich.console import Console
 from rich.padding import Padding
 
 from tunacode.configuration.settings import ApplicationSettings
-from tunacode.constants import (MSG_UPDATE_AVAILABLE, MSG_UPDATE_INSTRUCTION, MSG_VERSION_DISPLAY,
-                                UI_COLORS, UI_THINKING_MESSAGE)
+from tunacode.constants import (
+    MSG_UPDATE_AVAILABLE,
+    MSG_UPDATE_INSTRUCTION,
+    MSG_VERSION_DISPLAY,
+    UI_COLORS,
+    UI_THINKING_MESSAGE,
+)
 from tunacode.core.state import StateManager
 from tunacode.utils.file_utils import DotDict