tunacode-cli 0.0.47__tar.gz → 0.0.49__tar.gz

{tunacode_cli-0.0.47/src/tunacode_cli.egg-info → tunacode_cli-0.0.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.47
+Version: 0.0.49
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License: MIT
@@ -37,7 +37,7 @@ Requires-Dist: textual-dev; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Dynamic: license-file
 
-# TunaCode
+# TunaCode CLI
 
 <div align="center">
 

{tunacode_cli-0.0.47 → tunacode_cli-0.0.49}/README.md

@@ -1,4 +1,4 @@
-# TunaCode
+# TunaCode CLI
 
 <div align="center">
 

{tunacode_cli-0.0.47 → tunacode_cli-0.0.49}/pyproject.toml

@@ -4,7 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tunacode-cli"
-version = "0.0.47"
+
+version = "0.0.49"
 description = "Your agentic CLI developer."
 keywords = ["cli", "agent", "development", "automation"]
 readme = "README.md"
@@ -77,3 +78,35 @@ exclude = [
     "dist",
     "venv",
 ]
+
+[tool.vulture]
+min_confidence = 80
+paths = ["src", "tests"]
+exclude = ["venv/", "build/", "dist/", ".git/", "__pycache__/", "*.egg-info/"]
+# Whitelist of false positives
+ignore_names = [
+    # TYPE_CHECKING imports
+    "ReadStream",
+    "WriteStream", 
+    "StateManager",
+    "ModelRequest",
+    "CommandRegistry",
+    # Pytest fixtures
+    "caplog",
+    "temp_workspace", 
+    "setup_test_environment",
+    "excinfo",
+    # Common patterns
+    "_complete_event",  # prompt_toolkit API requirement
+    "kw",  # **kw pattern
+    "kwargs",  # **kwargs pattern
+    "message",  # exception handling
+    "response_obj",  # API responses
+    # Test parameters and mock arguments
+    "should_restart",  # test parameter
+    "exc",  # exception handling in __aexit__
+    "exc_type",  # exception handling in __aexit__
+    "tb",  # traceback in __aexit__
+    "style_dict",  # Style.from_dict parameter
+    "style_str",  # get_attrs_for_style_str parameter
+]

tunacode_cli-0.0.49/src/api/auth.py

@@ -0,0 +1,13 @@
+import jwt
+
+
+def authenticate(username, password):
+    # TODO: Add password hashing
+    if username == "admin" and password == "admin":
+        return generate_token(username)
+    return None
+
+
+def generate_token(username):
+    # TODO: Add expiration
+    return jwt.encode({"user": username}, "secret")

tunacode_cli-0.0.49/src/api/users.py

@@ -0,0 +1,8 @@
+from .auth import authenticate
+
+
+class UserManager:
+    def login(self, username, password):
+        token = authenticate(username, password)
+        # TODO: Store session
+        return token

tunacode_cli-0.0.49/src/tunacode/__init__.py

@@ -0,0 +1,4 @@
+# Initialize unified logging system on package import
+from tunacode.core.logging import setup_logging
+
+setup_logging()

{tunacode_cli-0.0.47 → tunacode_cli-0.0.49}/src/tunacode/cli/repl.py

@@ -90,6 +90,12 @@ def _parse_args(args) -> ToolArgs:
 
 async def _tool_handler(part, state_manager: StateManager):
     """Handle tool execution with separated business logic and UI."""
+    # Check for cancellation before tool execution (only if explicitly set to True)
+    operation_cancelled = getattr(state_manager.session, "operation_cancelled", False)
+    if operation_cancelled is True:
+        logger.debug("Tool execution cancelled")
+        raise CancelledError("Operation was cancelled")
+
     tool_handler = ToolHandler(state_manager)
 
     if tool_handler.should_confirm(part.tool_name):
@@ -249,6 +255,12 @@ async def _display_agent_output(res, enable_streaming: bool) -> None:
 async def process_request(text: str, state_manager: StateManager, output: bool = True):
     """Process input using the agent, handling cancellation safely."""
 
+    # Check for cancellation before starting (only if explicitly set to True)
+    operation_cancelled = getattr(state_manager.session, "operation_cancelled", False)
+    if operation_cancelled is True:
+        logger.debug("Operation cancelled before processing started")
+        raise CancelledError("Operation was cancelled")
+
     state_manager.session.spinner = await ui.spinner(
         True, state_manager.session.spinner, state_manager
     )
@@ -275,6 +287,12 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             await ui.error(str(e))
             return
 
+        # Check for cancellation before proceeding with agent call (only if explicitly set to True)
+        operation_cancelled = getattr(state_manager.session, "operation_cancelled", False)
+        if operation_cancelled is True:
+            logger.debug("Operation cancelled before agent processing")
+            raise CancelledError("Operation was cancelled")
+
         enable_streaming = state_manager.session.user_config.get("settings", {}).get(
             "enable_streaming", True
         )
@@ -338,13 +356,13 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             # Always show files in context after agent response
             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"\nFiles in context: {', '.join(filenames)}")
+                await ui.muted(f"Files in context: {', '.join(filenames)}")
 
     # --- ERROR HANDLING ---
     except CancelledError:
         await ui.muted(MSG_REQUEST_CANCELLED)
     except UserAbortError:
-        await ui.muted(MSG_OPERATION_ABORTED_BY_USER)
+        await ui.muted(MSG_OPERATION_ABORTED)
     except UnexpectedModelBehavior as e:
         error_message = str(e)
         await ui.muted(error_message)
@@ -360,6 +378,9 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
     finally:
         await ui.spinner(False, state_manager.session.spinner, state_manager)
         state_manager.session.current_task = None
+        # Reset cancellation flag when task completes (if attribute exists)
+        if hasattr(state_manager.session, "operation_cancelled"):
+            state_manager.session.operation_cancelled = False
 
         if "multiline" in state_manager.session.input_sessions:
             await run_in_terminal(
@@ -460,9 +481,14 @@ async def repl(state_manager: StateManager):
                 await ui.muted(MSG_AGENT_BUSY)
                 continue
 
+            # Reset cancellation flag for new operations (if attribute exists)
+            if hasattr(state_manager.session, "operation_cancelled"):
+                state_manager.session.operation_cancelled = False
+
             state_manager.session.current_task = get_app().create_background_task(
                 process_request(line, state_manager)
             )
+            await state_manager.session.current_task
 
             state_manager.session.update_token_count()
             context_display = get_context_window_display(

{tunacode_cli-0.0.47 → tunacode_cli-0.0.49}/src/tunacode/constants.py

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

{tunacode_cli-0.0.47 → tunacode_cli-0.0.49}/src/tunacode/core/agents/main.py

@@ -6,7 +6,6 @@ Handles agent creation, configuration, and request processing.
 
 import asyncio
 import json
-import logging
 import os
 import re
 from datetime import datetime, timezone
@@ -15,6 +14,8 @@ from typing import Any, Iterator, List, Optional, Tuple
 
 from pydantic_ai import Agent
 
+from tunacode.core.logging.logger import get_logger
+
 # Import streaming types with fallback for older versions
 try:
     from pydantic_ai.messages import (
@@ -30,7 +31,6 @@ except ImportError:
     STREAMING_AVAILABLE = False
 
 from tunacode.constants import READ_ONLY_TOOLS
-from tunacode.core.recursive import RecursiveTaskExecutor
 from tunacode.core.state import StateManager
 from tunacode.core.token_usage.api_response_parser import ApiResponseParser
 from tunacode.core.token_usage.cost_calculator import CostCalculator
@@ -60,7 +60,7 @@ from tunacode.types import (
 )
 
 # Configure logging
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class ToolBuffer:
@@ -528,12 +528,12 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 tunacode_content = tunacode_path.read_text(encoding="utf-8")
                 if tunacode_content.strip():
                     # Log that we found TUNACODE.md
-                    print("📄 TUNACODE.md located: Loading context...")
+                    logger.info("📄 TUNACODE.md located: Loading context...")
 
                     system_prompt += "\n\n# Project Context from TUNACODE.md\n" + tunacode_content
             else:
                 # Log that TUNACODE.md was not found
-                print("📄 TUNACODE.md not found: Using default context")
+                logger.info("📄 TUNACODE.md not found: Using default context")
         except Exception as e:
             # Log errors loading TUNACODE.md at debug level
             logger.debug(f"Error loading TUNACODE.md: {e}")
@@ -547,9 +547,8 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 system_prompt += f'\n\n# Current Todo List\n\nYou have existing todos that need attention:\n\n{current_todos}\n\nRemember to check progress on these todos and update them as you work. Use todo("list") to see current status anytime.'
         except Exception as e:
             # Log error but don't fail agent creation
-            import sys
 
-            print(f"Warning: Failed to load todos: {e}", file=sys.stderr)
+            logger.warning(f"Warning: Failed to load todos: {e}")
 
         state_manager.session.agents[model] = Agent(
             model=model,
@@ -763,55 +762,6 @@ async def process_request(
             "fallback_response", True
         )
 
-        # Check if recursive execution is enabled
-        use_recursive = state_manager.session.user_config.get("settings", {}).get(
-            "use_recursive_execution", True
-        )
-        recursive_threshold = state_manager.session.user_config.get("settings", {}).get(
-            "recursive_complexity_threshold", 0.7
-        )
-
-        # Check if recursive execution should be used
-        if use_recursive and state_manager.session.current_recursion_depth == 0:
-            try:
-                # Initialize recursive executor
-                recursive_executor = RecursiveTaskExecutor(
-                    state_manager=state_manager,
-                    max_depth=state_manager.session.max_recursion_depth,
-                    min_complexity_threshold=recursive_threshold,
-                    default_iteration_budget=max_iterations,
-                )
-
-                # Analyze task complexity
-                complexity_result = await recursive_executor.decomposer.analyze_and_decompose(
-                    message
-                )
-
-                if (
-                    complexity_result.should_decompose
-                    and complexity_result.total_complexity >= recursive_threshold
-                ):
-                    if state_manager.session.show_thoughts:
-                        from tunacode.ui import console as ui
-
-                        await ui.muted(
-                            f"\n🔄 RECURSIVE EXECUTION: Task complexity {complexity_result.total_complexity:.2f} >= {recursive_threshold}"
-                        )
-                        await ui.muted(f"Reasoning: {complexity_result.reasoning}")
-                        await ui.muted(f"Subtasks: {len(complexity_result.subtasks)}")
-
-                    # Execute recursively
-                    success, result, error = await recursive_executor.execute_task(
-                        request=message, parent_task_id=None, depth=0
-                    )
-
-                    # For now, fall back to normal execution
-                    # TODO: Properly integrate recursive execution results
-                    pass
-            except Exception as e:
-                logger.warning(f"Recursive execution failed, falling back to normal: {e}")
-                # Continue with normal execution
-
         from tunacode.configuration.models import ModelRegistry
         from tunacode.core.token_usage.usage_tracker import UsageTracker
 
@@ -910,28 +860,27 @@ async def process_request(
                 buffered_tasks = tool_buffer.flush()
                 start_time = time.time()
 
-                if state_manager.session.show_thoughts:
-                    await ui.muted("\n" + "=" * 60)
-                    await ui.muted(
-                        f"🚀 FINAL BATCH: Executing {len(buffered_tasks)} buffered read-only tools"
-                    )
-                    await ui.muted("=" * 60)
+                await ui.muted("\n" + "=" * 60)
+                await ui.muted(
+                    f"🚀 FINAL BATCH: Executing {len(buffered_tasks)} buffered read-only tools"
+                )
+                await ui.muted("=" * 60)
 
-                    for idx, (part, node) in enumerate(buffered_tasks, 1):
-                        tool_desc = f"  [{idx}] {part.tool_name}"
-                        if hasattr(part, "args") and isinstance(part.args, dict):
-                            if part.tool_name == "read_file" and "file_path" in part.args:
-                                tool_desc += f" → {part.args['file_path']}"
-                            elif part.tool_name == "grep" and "pattern" in part.args:
-                                tool_desc += f" → pattern: '{part.args['pattern']}'"
-                                if "include_files" in part.args:
-                                    tool_desc += f", files: '{part.args['include_files']}'"
-                            elif part.tool_name == "list_dir" and "directory" in part.args:
-                                tool_desc += f" → {part.args['directory']}"
-                            elif part.tool_name == "glob" and "pattern" in part.args:
-                                tool_desc += f" → pattern: '{part.args['pattern']}'"
-                        await ui.muted(tool_desc)
-                    await ui.muted("=" * 60)
+                for idx, (part, node) in enumerate(buffered_tasks, 1):
+                    tool_desc = f"  [{idx}] {part.tool_name}"
+                    if hasattr(part, "args") and isinstance(part.args, dict):
+                        if part.tool_name == "read_file" and "file_path" in part.args:
+                            tool_desc += f" → {part.args['file_path']}"
+                        elif part.tool_name == "grep" and "pattern" in part.args:
+                            tool_desc += f" → pattern: '{part.args['pattern']}'"
+                            if "include_files" in part.args:
+                                tool_desc += f", files: '{part.args['include_files']}'"
+                        elif part.tool_name == "list_dir" and "directory" in part.args:
+                            tool_desc += f" → {part.args['directory']}"
+                        elif part.tool_name == "glob" and "pattern" in part.args:
+                            tool_desc += f" → pattern: '{part.args['pattern']}'"
+                    await ui.muted(tool_desc)
+                await ui.muted("=" * 60)
 
                 await execute_tools_parallel(buffered_tasks, tool_callback)
 
@@ -939,11 +888,10 @@ async def process_request(
                 sequential_estimate = len(buffered_tasks) * 100
                 speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
 
-                if state_manager.session.show_thoughts:
-                    await ui.muted(
-                        f"✅ Final batch completed in {elapsed_time:.0f}ms "
-                        f"(~{speedup:.1f}x faster than sequential)\n"
-                    )
+                await ui.muted(
+                    f"✅ Final batch completed in {elapsed_time:.0f}ms "
+                    f"(~{speedup:.1f}x faster than sequential)\n"
+                )
 
             # If we need to add a fallback response, create a wrapper
             if not response_state.has_user_response and i >= max_iterations and fallback_enabled:
@@ -1089,6 +1037,7 @@ async def process_request(
                             f"'{type(self).__name__}' object has no attribute '{name}'"
                         )
 
-            return AgentRunWithState(agent_run)
+        return AgentRunWithState(agent_run)
     except asyncio.CancelledError:
-        raise UserAbortError("User aborted the request.")
+        # When task is cancelled, raise UserAbortError instead
+        raise UserAbortError("Operation was cancelled by user")

tunacode_cli-0.0.49/src/tunacode/core/logging/__init__.py

@@ -0,0 +1,29 @@
+import logging
+
+# Custom log level: THOUGHT
+THOUGHT = 25
+logging.addLevelName(THOUGHT, "THOUGHT")
+
+
+def thought(self, message, *args, **kwargs):
+    if self.isEnabledFor(THOUGHT):
+        self._log(THOUGHT, message, args, **kwargs)
+
+
+logging.Logger.thought = thought
+
+
+# RichHandler for UI output (stub, real implementation in handlers.py)
+class RichHandler(logging.Handler):
+    def emit(self, record):
+        # Actual implementation in handlers.py
+        pass
+
+
+def setup_logging(config_path=None):
+    """
+    Set up logging configuration from YAML file.
+    """
+    from .config import LogConfig
+
+    LogConfig.load(config_path)

tunacode_cli-0.0.49/src/tunacode/core/logging/config.py

@@ -0,0 +1,28 @@
+import logging
+import logging.config
+import os
+
+import yaml
+
+DEFAULT_CONFIG_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "config", "logging.yaml"
+)
+
+
+class LogConfig:
+    @staticmethod
+    def load(config_path=None):
+        """
+        Load logging configuration from YAML file and apply it.
+        """
+        path = config_path or DEFAULT_CONFIG_PATH
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Logging config file not found: {path}")
+        with open(path, "r") as f:
+            config = yaml.safe_load(f)
+        logging_config = config.get("logging", config)
+        try:
+            logging.config.dictConfig(logging_config)
+        except Exception as e:
+            print(f"Failed to configure logging: {e}")
+            logging.basicConfig(level=logging.INFO)

tunacode_cli-0.0.49/src/tunacode/core/logging/formatters.py

@@ -0,0 +1,48 @@
+import logging
+
+
+class SimpleFormatter(logging.Formatter):
+    """
+    Simple formatter for UI output.
+    """
+
+    def __init__(self):
+        super().__init__("[%(levelname)s] %(message)s")
+
+
+class DetailedFormatter(logging.Formatter):
+    """
+    Detailed formatter for backend text logs.
+    """
+
+    def __init__(self):
+        super().__init__("[%(asctime)s] [%(levelname)s] [%(name)s:%(lineno)d] - %(message)s")
+
+
+try:
+    from pythonjsonlogger import jsonlogger
+
+    class JSONFormatter(jsonlogger.JsonFormatter):
+        """
+        JSON formatter for structured logs.
+        """
+
+        def __init__(self):
+            super().__init__("%(asctime)s %(name)s %(levelname)s %(message)s")
+except ImportError:
+    import json
+
+    class JSONFormatter(logging.Formatter):
+        """
+        Fallback JSON formatter if pythonjsonlogger is not installed.
+        """
+
+        def format(self, record):
+            log_entry = {
+                "timestamp": self.formatTime(record),
+                "level": record.levelname,
+                "name": record.name,
+                "line": record.lineno,
+                "message": record.getMessage(),
+            }
+            return json.dumps(log_entry)

tunacode_cli-0.0.49/src/tunacode/core/logging/handlers.py

@@ -0,0 +1,83 @@
+import json
+import logging
+
+from rich.console import Console
+from rich.text import Text
+
+# Global context for streaming state
+_streaming_context = {"just_finished": False}
+
+
+class RichHandler(logging.Handler):
+    """
+    Handler that outputs logs to the console using rich formatting.
+    """
+
+    level_icons = {
+        "INFO": "",
+        "WARNING": "⚠️",
+        "ERROR": "❌",
+        "CRITICAL": "🚨",
+        "THOUGHT": "🤔",
+        "DEBUG": "",
+    }
+
+    def __init__(self, level=logging.NOTSET):
+        super().__init__(level)
+        self.console = Console()
+
+    def emit(self, record):
+        try:
+            icon = self.level_icons.get(record.levelname, "")
+            timestamp = self.formatTime(record)
+            msg = self.format(record)
+            if icon:
+                output = f"[{timestamp}] {icon} {msg}"
+            else:
+                output = f"[{timestamp}] {msg}"
+
+            # Check if we just finished streaming to avoid extra newlines
+            just_finished_streaming = _streaming_context.get("just_finished", False)
+            if just_finished_streaming:
+                _streaming_context["just_finished"] = False  # Reset after use
+                # Don't add extra newline when transitioning from streaming
+                self.console.print(Text(output), end="\n")
+            else:
+                self.console.print(Text(output))
+        except Exception:
+            self.handleError(record)
+
+    def formatTime(self, record, datefmt=None):
+        from datetime import datetime
+
+        ct = datetime.fromtimestamp(record.created)
+        if datefmt:
+            return ct.strftime(datefmt)
+        return ct.strftime("%Y-%m-%d %H:%M:%S")
+
+
+class StructuredFileHandler(logging.FileHandler):
+    """
+    Handler that outputs logs as structured JSON lines.
+    """
+
+    def emit(self, record):
+        try:
+            log_entry = {
+                "timestamp": self.formatTime(record),
+                "level": record.levelname,
+                "name": record.name,
+                "line": record.lineno,
+                "message": record.getMessage(),
+                "extra_data": getattr(record, "extra", {}),
+            }
+            self.stream.write(json.dumps(log_entry) + "\n")
+            self.flush()
+        except Exception:
+            self.handleError(record)
+
+    def formatTime(self, record, datefmt=None):
+        from datetime import datetime, timezone
+
+        ct = datetime.fromtimestamp(record.created, tz=timezone.utc)
+        return ct.isoformat()

tunacode_cli-0.0.49/src/tunacode/core/logging/logger.py

@@ -0,0 +1,8 @@
+import logging
+
+
+def get_logger(name=None):
+    """
+    Get a logger instance with the given name.
+    """
+    return logging.getLogger(name)

{tunacode_cli-0.0.47 → tunacode_cli-0.0.49}/src/tunacode/core/recursive/hierarchy.py

@@ -332,10 +332,11 @@ class TaskHierarchy:
         """Propagate context from one task to another.
 
         Args:
-            from_task: Source task ID
+            from_task: Source task ID (unused, kept for API consistency)
             to_task: Target task ID
             context_update: Context to propagate
         """
+        _ = from_task  # Unused but kept for API consistency
         if to_task in self._execution_contexts:
             self._execution_contexts[to_task].inherited_context.update(context_update)
 

{tunacode_cli-0.0.47 → tunacode_cli-0.0.49}/src/tunacode/core/state.py

@@ -41,6 +41,10 @@ class SessionState:
     input_sessions: InputSessions = field(default_factory=dict)
     current_task: Optional[Any] = None
     todos: list[TodoItem] = field(default_factory=list)
+    # ESC key tracking for double-press functionality
+    esc_press_count: int = 0
+    last_esc_time: Optional[float] = None
+    operation_cancelled: bool = False
     # Enhanced tracking for thoughts display
     files_in_context: set[str] = field(default_factory=set)
     tool_calls: list[dict[str, Any]] = field(default_factory=list)

{tunacode_cli-0.0.47 → tunacode_cli-0.0.49}/src/tunacode/tools/base.py

@@ -8,6 +8,7 @@ from abc import ABC, abstractmethod
 
 from pydantic_ai.exceptions import ModelRetry
 
+from tunacode.core.logging.logger import get_logger
 from tunacode.exceptions import FileOperationError, ToolExecutionError
 from tunacode.types import FilePath, ToolName, ToolResult, UILogger
 
@@ -22,6 +23,7 @@ class BaseTool(ABC):
             ui_logger: UI logger instance for displaying messages
         """
         self.ui = ui_logger
+        self.logger = get_logger(self.__class__.__name__)
 
     async def execute(self, *args, **kwargs) -> ToolResult:
         """Execute the tool with error handling and logging.
@@ -39,14 +41,17 @@ class BaseTool(ABC):
             ToolExecutionError: Raised for all other errors with structured information
         """
         try:
+            msg = f"{self.tool_name}({self._format_args(*args, **kwargs)})"
             if self.ui:
-                await self.ui.info(f"{self.tool_name}({self._format_args(*args, **kwargs)})")
+                await self.ui.info(msg)
+            self.logger.info(msg)
             result = await self._execute(*args, **kwargs)
             return result
         except ModelRetry as e:
             # Log as warning and re-raise for pydantic-ai
             if self.ui:
                 await self.ui.warning(str(e))
+            self.logger.warning(f"ModelRetry: {e}")
             raise
         except ToolExecutionError:
             # Already properly formatted, just re-raise
@@ -90,6 +95,7 @@ class BaseTool(ABC):
         err_msg = f"Error {self._get_error_context(*args, **kwargs)}: {error}"
         if self.ui:
             await self.ui.error(err_msg)
+        self.logger.error(err_msg)
 
         # Raise proper exception instead of returning string
         raise ToolExecutionError(tool_name=self.tool_name, message=str(error), original_error=error)

{tunacode_cli-0.0.47 → tunacode_cli-0.0.49}/src/tunacode/types.py

@@ -13,7 +13,7 @@ from typing import Any, Awaitable, Callable, Dict, List, Literal, Optional, Prot
 # Try to import pydantic-ai types if available
 try:
     from pydantic_ai import Agent
-    from pydantic_ai.messages import ModelRequest, ModelResponse, ToolReturnPart
+    from pydantic_ai.messages import ModelRequest, ToolReturnPart
 
     PydanticAgent = Agent
     MessagePart = Union[ToolReturnPart, Any]