agentpool 2.2.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool_toolsets/fsspec_toolset/toolset.py

@@ -14,11 +14,13 @@ import anyio
 from exxec.base import ExecutionEnvironment
 from pydantic_ai import (
     BinaryContent,
+    ModelResponse,
     PartDeltaEvent,
     PartStartEvent,
     RunContext,  # noqa: TC002
     TextPart,
     TextPartDelta,
+    ToolCallPart,
 )
 from upathtools import is_directory
 
@@ -26,6 +28,12 @@ from agentpool.agents.context import AgentContext  # noqa: TC001
 from agentpool.log import get_logger
 from agentpool.mime_utils import guess_type, is_binary_content, is_binary_mime
 from agentpool.resource_providers import ResourceProvider
+from agentpool.tool_impls.delete_path import create_delete_path_tool
+from agentpool.tool_impls.download_file import create_download_file_tool
+from agentpool.tool_impls.grep import create_grep_tool
+from agentpool.tool_impls.list_directory import create_list_directory_tool
+from agentpool.tool_impls.read import create_read_tool
+from agentpool.tools.base import ToolResult  # noqa: TC001
 from agentpool_toolsets.builtin.file_edit import replace_content
 from agentpool_toolsets.builtin.file_edit.fuzzy_matcher import StreamingFuzzyMatcher
 from agentpool_toolsets.fsspec_toolset.diagnostics import (
@@ -47,9 +55,11 @@ from agentpool_toolsets.fsspec_toolset.streaming_diff_parser import (
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     import fsspec
     from fsspec.asyn import AsyncFileSystem
-    from pydantic_ai.messages import ModelRequest, ModelResponse
+    from pydantic_ai import ModelRequest
 
     from agentpool.agents.base_agent import BaseAgent
     from agentpool.common_types import ModelType
@@ -141,7 +151,7 @@ class FSSpecTools(ResourceProvider):
         self._max_image_size = max_image_size
         self._max_image_bytes = max_image_bytes
 
-    def get_fs(self, agent_ctx: AgentContext) -> AsyncFileSystem:
+    def _get_fs(self, agent_ctx: AgentContext) -> AsyncFileSystem:
         """Get filesystem, falling back to agent's env if not set.
 
         Args:
@@ -197,7 +207,7 @@ class FSSpecTools(ResourceProvider):
         # Lazy init repomap - use file's directory as root
         if self._repomap is None:
             root = str(Path(path).parent)
-            fs = self.get_fs(agent_ctx)
+            fs = self._get_fs(agent_ctx)
             self._repomap = RepoMap(fs, root, max_tokens=self._map_max_tokens)
 
         return await self._repomap.get_file_map(path, max_tokens=self._map_max_tokens)
@@ -222,18 +232,52 @@ class FSSpecTools(ResourceProvider):
             return str(Path(cwd) / path)
         return path
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get filesystem tools."""
         if self._tools is not None:
             return self._tools
 
+        # Create standalone tools with toolset's configuration
+        list_dir_tool = create_list_directory_tool(
+            env=self.execution_env,
+            cwd=self.cwd,
+        )
+
+        read_tool = create_read_tool(
+            env=self.execution_env,
+            converter=self.converter,  # Pass converter for automatic markdown conversion
+            cwd=self.cwd,
+            max_file_size_kb=self.max_file_size // 1024,
+            max_image_size=self._max_image_size,
+            max_image_bytes=self._max_image_bytes,
+            large_file_tokens=self._large_file_tokens,
+            map_max_tokens=self._map_max_tokens,
+        )
+
+        grep_tool = create_grep_tool(
+            env=self.execution_env,
+            cwd=self.cwd,
+            max_output_kb=self.max_grep_output // 1024,
+            use_subprocess_grep=self.use_subprocess_grep,
+        )
+
+        delete_tool = create_delete_path_tool(
+            env=self.execution_env,
+            cwd=self.cwd,
+        )
+
+        download_tool = create_download_file_tool(
+            env=self.execution_env,
+            cwd=self.cwd,
+        )
+
         self._tools = [
-            self.create_tool(self.list_directory, category="read", read_only=True, idempotent=True),
-            self.create_tool(self.read, category="read", read_only=True, idempotent=True),
-            self.create_tool(self.grep, category="search", read_only=True, idempotent=True),
+            list_dir_tool,
+            read_tool,
+            grep_tool,
             self.create_tool(self.write, category="edit"),
-            self.create_tool(self.delete_path, category="delete", destructive=True),
-            self.create_tool(self.download_file, category="read", open_world=True),
+            delete_tool,
+            download_tool,
         ]
 
         # Add edit tool based on config - mutually exclusive
@@ -246,15 +290,8 @@ class FSSpecTools(ResourceProvider):
         else:  # simple
             self._tools.append(self.create_tool(self.edit, category="edit"))
 
-        if self.converter:  # Only add read_as_markdown if converter is available
-            self._tools.append(
-                self.create_tool(
-                    self.read_as_markdown,
-                    category="read",
-                    read_only=True,
-                    idempotent=True,
-                )
-            )
+        # Add regex line editing tool
+        self._tools.append(self.create_tool(self.regex_replace_lines, category="edit"))
 
         return self._tools
 
@@ -286,7 +323,7 @@ class FSSpecTools(ResourceProvider):
         await agent_ctx.events.tool_call_start(title=msg, kind="read", locations=[path])
 
         try:
-            fs = self.get_fs(agent_ctx)
+            fs = self._get_fs(agent_ctx)
             # Check if path exists
             if not await fs._exists(path):
                 error_msg = f"Path does not exist: {path}"
@@ -381,15 +418,18 @@ class FSSpecTools(ResourceProvider):
         msg = f"Reading file: {path}"
         from agentpool.agents.events import LocationContentItem
 
+        # Emit progress - use 0 for line if negative (can't resolve until we read file)
+        # LocationContentItem/ToolCallLocation require line >= 0 per ACP spec
+        display_line = line if (line is not None and line > 0) else 0
         await agent_ctx.events.tool_call_progress(
             title=msg,
-            items=[LocationContentItem(path=path)],
+            items=[LocationContentItem(path=path, line=display_line)],
         )
         try:
             mime_type = guess_type(path)
             # Fast path: known binary MIME types (images, audio, video, etc.)
             if is_binary_mime(mime_type):
-                data = await self.get_fs(agent_ctx)._cat_file(path)
+                data = await self._get_fs(agent_ctx)._cat_file(path)
                 await agent_ctx.events.file_operation("read", path=path, success=True)
                 mime = mime_type or "application/octet-stream"
                 # Resize images if needed
@@ -406,7 +446,7 @@ class FSSpecTools(ResourceProvider):
                         return [note, BinaryContent(data=data, media_type=mime, identifier=path)]
                 return BinaryContent(data=data, media_type=mime, identifier=path)
             # Read content and probe for binary (git-style null byte detection)
-            data = await self.get_fs(agent_ctx)._cat_file(path)
+            data = await self._get_fs(agent_ctx)._cat_file(path)
             if is_binary_content(data):
                 # Binary file - return as BinaryContent for native model handling
                 await agent_ctx.events.file_operation("read", path=path, success=True)
@@ -447,7 +487,11 @@ class FSSpecTools(ResourceProvider):
                     lines, offset, limit, self.max_file_size
                 )
                 content = "\n".join(result_lines)
-                await agent_ctx.events.file_operation("read", path=path, success=True)
+                # Don't pass negative line numbers to events (ACP requires >= 0)
+                display_line = line if (line and line > 0) else 0
+                await agent_ctx.events.file_operation(
+                    "read", path=path, success=True, line=display_line
+                )
                 if was_truncated:
                     content += f"\n\n[Content truncated at {self.max_file_size} bytes]"
 
@@ -458,9 +502,11 @@ class FSSpecTools(ResourceProvider):
             # Emit file content for UI display (formatted at ACP layer)
             from agentpool.agents.events import FileContentItem
 
+            # Use non-negative line for display (negative lines are internal Python convention)
+            display_start_line = max(1, line) if line and line > 0 else None
             await agent_ctx.events.tool_call_progress(
                 title=f"Read: {path}",
-                items=[FileContentItem(content=content, path=path)],
+                items=[FileContentItem(content=content, path=path, start_line=display_start_line)],
                 replace_content=True,
             )
             # Return raw content for agent
@@ -504,7 +550,7 @@ class FSSpecTools(ResourceProvider):
         content: str,
         mode: str = "w",
         overwrite: bool = False,
-    ) -> dict[str, Any]:
+    ) -> str | ToolResult:
         """Write content to a file.
 
         Args:
@@ -514,8 +560,11 @@ class FSSpecTools(ResourceProvider):
             overwrite: Must be True to overwrite existing files (safety check)
 
         Returns:
-            Dictionary with success info or error details
+            Success message or ToolResult with metadata
         """
+        from agentpool.agents.events import DiffContentItem
+        from agentpool.tools.base import ToolResult
+
         path = self._resolve_path(path, agent_ctx)
         msg = f"Writing file: {path}"
         await agent_ctx.events.tool_call_start(title=msg, kind="edit", locations=[path])
@@ -526,7 +575,7 @@ class FSSpecTools(ResourceProvider):
             if mode not in ("w", "a"):
                 msg = f"Invalid mode '{mode}'. Use 'w' (write) or 'a' (append)"
                 await agent_ctx.events.file_operation("write", path=path, success=False, error=msg)
-                return {"error": msg}
+                return f"Error: {msg}"
 
             # Check size limit
             if content_bytes > self.max_file_size:
@@ -535,10 +584,10 @@ class FSSpecTools(ResourceProvider):
                     f"({self.max_file_size} bytes)"
                 )
                 await agent_ctx.events.file_operation("write", path=path, success=False, error=msg)
-                return {"error": msg}
+                return f"Error: {msg}"
 
             # Check if file exists and overwrite protection
-            fs = self.get_fs(agent_ctx)
+            fs = self._get_fs(agent_ctx)
             file_exists = await fs._exists(path)
 
             if file_exists and mode == "w" and not overwrite:
@@ -547,7 +596,7 @@ class FSSpecTools(ResourceProvider):
                     f"This is a safety measure to prevent accidental data loss."
                 )
                 await agent_ctx.events.file_operation("write", path=path, success=False, error=msg)
-                return {"error": msg}
+                return f"Error: {msg}"
 
             # Handle append mode: read existing content and prepend it
             if mode == "a" and file_exists:
@@ -560,23 +609,6 @@ class FSSpecTools(ResourceProvider):
                     pass  # If we can't read, just write new content
 
             await self._write(agent_ctx, path, content)
-
-            try:
-                info = await fs._info(path)
-                size = info.get("size", content_bytes)
-            except (OSError, KeyError):
-                size = content_bytes
-
-            result: dict[str, Any] = {
-                "path": path,
-                "size": size,
-                "mode": mode,
-                "file_existed": file_exists,
-                "bytes_written": content_bytes,
-            }
-            # Emit file operation with content for UI display
-            from agentpool.agents.events import DiffContentItem
-
             await agent_ctx.events.tool_call_progress(
                 title=f"Wrote: {path}",
                 items=[
@@ -584,14 +616,40 @@ class FSSpecTools(ResourceProvider):
                 ],
             )
 
-            # Run diagnostics if enabled
+            # Run diagnostics if enabled (include in message for agent)
+            diagnostics_msg = ""
             if diagnostics_output := await self._run_diagnostics(agent_ctx, path):
-                result["diagnostics"] = diagnostics_output
+                diagnostics_msg = f"\n\nDiagnostics:\n{diagnostics_output}"
+
+            action = "Appended to" if mode == "a" and file_exists else "Wrote"
+            success_msg = f"{action} {path} ({content_bytes} bytes){diagnostics_msg}"
+
+            # TODO: Include diagnostics in metadata for UI display
+            # Expected metadata shape:
+            # {
+            #   "diagnostics": {
+            #     "<file_path>": [
+            #       {
+            #         "range": {"start": {"line": 0, "character": 0}, "end": {...}},
+            #         "message": "...",
+            #         "severity": 1  # 1=error, 2=warning, 3=info, 4=hint
+            #       }
+            #     ]
+            #   }
+            # }
+
+            return ToolResult(
+                content=success_msg,  # Agent sees this (includes diagnostics text)
+                metadata={
+                    # Include file content for UI display (used by OpenCode TUI)
+                    "filePath": str(Path(path).absolute()),
+                    "content": content,
+                    # TODO: Add structured diagnostics here for UI
+                },
+            )
         except Exception as e:  # noqa: BLE001
             await agent_ctx.events.file_operation("write", path=path, success=False, error=str(e))
-            return {"error": f"Failed to write file {path}: {e}"}
-        else:
-            return result
+            return f"Error: Failed to write file {path}: {e}"
 
     async def delete_path(  # noqa: D417
         self, agent_ctx: AgentContext, path: str, recursive: bool = False
@@ -610,7 +668,7 @@ class FSSpecTools(ResourceProvider):
         await agent_ctx.events.tool_call_start(title=msg, kind="delete", locations=[path])
         try:
             # Check if path exists and get its type
-            fs = self.get_fs(agent_ctx)
+            fs = self._get_fs(agent_ctx)
             try:
                 info = await fs._info(path)
                 path_type = info.get("type", "unknown")
@@ -668,7 +726,7 @@ class FSSpecTools(ResourceProvider):
         description: str,
         replace_all: bool = False,
         line_hint: int | None = None,
-    ) -> str:
+    ) -> str | ToolResult:
         r"""Edit a file by replacing specific content with smart matching.
 
         Uses sophisticated matching strategies to handle whitespace, indentation,
@@ -704,7 +762,7 @@ class FSSpecTools(ResourceProvider):
         description: str,
         replace_all: bool = False,
         line_hint: int | None = None,
-    ) -> str:
+    ) -> str | ToolResult:
         r"""Edit a file by applying multiple replacements in one operation.
 
         Uses sophisticated matching strategies to handle whitespace, indentation,
@@ -718,6 +776,9 @@ class FSSpecTools(ResourceProvider):
         Args:
             path: File path (absolute or relative to session cwd)
             replacements: List of (old_string, new_string) tuples to apply sequentially.
+                IMPORTANT: Must be a list of pairs, like:
+                  [("old text", "new text"), ("another old", "another new")]
+
                 Each old_string should include enough context to uniquely identify
                 the target location. For multi-line edits, include the full block.
             description: Human-readable description of what the edit accomplishes
@@ -746,9 +807,6 @@ class FSSpecTools(ResourceProvider):
             if old_str == new_str:
                 return f"Error: old_string and new_string must be different: {old_str!r}"
 
-        # Send initial pending notification
-        await agent_ctx.events.file_operation("edit", path=path, success=True)
-
         try:  # Read current file content
             original_content = await self._read(agent_ctx, path)
             if isinstance(original_content, bytes):
@@ -790,9 +848,238 @@ class FSSpecTools(ResourceProvider):
             error_msg = f"Error editing file: {e}"
             await agent_ctx.events.file_operation("edit", path=path, success=False, error=error_msg)
             return error_msg
+        else:
+            # Generate unified diff for OpenCode UI
+            from difflib import unified_diff
+
+            from agentpool.tools.base import ToolResult
+
+            # Ensure content ends with newline for proper diff formatting
+            original_for_diff = (
+                original_content if original_content.endswith("\n") else original_content + "\n"
+            )
+            new_for_diff = new_content if new_content.endswith("\n") else new_content + "\n"
+
+            diff_lines = unified_diff(
+                original_for_diff.splitlines(keepends=True),
+                new_for_diff.splitlines(keepends=True),
+                fromfile=f"a/{Path(path).name}",
+                tofile=f"b/{Path(path).name}",
+            )
+            diff = "".join(diff_lines)
+
+            # Count additions and deletions
+            original_lines = set(original_content.splitlines())
+            new_lines = set(new_content.splitlines())
+            additions = len(new_lines - original_lines)
+            deletions = len(original_lines - new_lines)
+
+            return ToolResult(
+                content=success_msg,
+                metadata={
+                    "diff": diff,
+                    "filediff": {
+                        "file": str(Path(path).absolute()),
+                        "before": original_content,
+                        "after": new_content,
+                        "additions": additions,
+                        "deletions": deletions,
+                    },
+                },
+            )
+
+    async def regex_replace_lines(  # noqa: PLR0915
+        self,
+        agent_ctx: AgentContext,
+        path: str,
+        start: int | str,
+        end: int | str,
+        pattern: str,
+        replacement: str,
+        *,
+        count: int = 0,
+    ) -> str:
+        r"""Apply regex replacement to a line range specified by line numbers or text markers.
+
+        Useful for systematic edits:
+        - Remove/add indentation
+        - Comment/uncomment blocks
+        - Rename variables within scope
+        - Delete line ranges
+
+        Args:
+            agent_ctx: Agent execution context
+            path: File path to edit
+            start: Start of range - int (1-based line number) or str (unique text marker)
+            end: End of range - int (1-based line number) or str (first occurrence after start)
+            pattern: Regex pattern to search for within the range
+            replacement: Replacement string (supports \1, \2 capture groups; empty removes)
+            count: Max replacements per line (0 = unlimited)
+
+        Returns:
+            Success message with statistics
+
+        Examples:
+            # Remove a function
+            regex_replace_lines(ctx, "file.py", "def old_func(", "    return", r".*\n", "")
+
+            # Indent by line numbers
+            regex_replace_lines(ctx, "file.py", 10, 20, r"^", "    ")
+
+            # Uncomment a section
+            regex_replace_lines(ctx, "file.py", "# START", "# END", r"^# ", "")
+        """
+        import re
+
+        path = self._resolve_path(path, agent_ctx)
+        msg = f"Regex editing file: {path}"
+        await agent_ctx.events.tool_call_start(title=msg, kind="edit", locations=[path])
+
+        try:
+            # Read original content
+            original_content = await self._read(agent_ctx, path)
+            if isinstance(original_content, bytes):
+                original_content = original_content.decode("utf-8")
+
+            lines = original_content.splitlines(keepends=True)
+            total_lines = len(lines)
+
+            # Resolve start position
+            if isinstance(start, int):
+                if start < 1:
+                    msg = f"start line must be >= 1, got {start}"
+                    raise ValueError(msg)  # noqa: TRY301
+                start_line = start
+            else:
+                # Find unique occurrence of start string (raises ValueError if not found/unique)
+                start_line = self._find_unique_line(lines, start, "start")
+
+            # Resolve end position
+            if isinstance(end, int):
+                if end < start_line:
+                    msg = f"end line {end} must be >= start line {start_line}"
+                    raise ValueError(msg)  # noqa: TRY301
+                end_line = end
+            else:
+                # Find first occurrence of end string after start (raises ValueError if not found)
+                end_line = self._find_first_after(lines, end, start_line, "end")
+
+            # Validate range
+            if end_line > total_lines:
+                msg = f"end_line {end_line} exceeds file length {total_lines}"
+                raise ValueError(msg)  # noqa: TRY301
+
+            # Convert to 0-based indexing for array access
+            start_idx = start_line - 1
+            end_idx = end_line  # end_line is inclusive, but list slice is exclusive
+
+            # Compile regex pattern
+            regex = re.compile(pattern)
+
+            # Apply replacements to the specified line range
+            modified_count = 0
+            replacement_count = 0
+
+            for i in range(start_idx, end_idx):
+                original = lines[i]
+                modified, num_subs = regex.subn(replacement, original, count=count)
+                if num_subs > 0:
+                    lines[i] = modified
+                    modified_count += 1
+                    replacement_count += num_subs
+
+            # Build new content
+            new_content = "".join(lines)
+
+            # Write back
+            await self._write(agent_ctx, path, new_content)
+
+            # Build success message
+            success_msg = (
+                f"Successfully applied regex to lines {start_line}-{end_line} in {Path(path).name}"
+            )
+            if modified_count > 0:
+                success_msg += (
+                    f" ({modified_count} lines modified, {replacement_count} replacements)"
+                )
+
+            # Emit file edit event for diff display
+            await agent_ctx.events.file_edit_progress(
+                path=path,
+                old_text=original_content,
+                new_text=new_content,
+                status="completed",
+            )
+
+            # Run diagnostics if enabled
+            if diagnostics_output := await self._run_diagnostics(agent_ctx, path):
+                success_msg += f"\n\nDiagnostics:\n{diagnostics_output}"
+        except Exception as e:  # noqa: BLE001
+            error_msg = f"Error applying regex to file: {e}"
+            await agent_ctx.events.file_operation("edit", path=path, success=False, error=error_msg)
+            return error_msg
         else:
             return success_msg
 
+    @staticmethod
+    def _find_unique_line(lines: list[str], search_text: str, param_name: str) -> int:
+        """Find unique occurrence of text in lines.
+
+        Args:
+            lines: File lines
+            search_text: Text to search for
+            param_name: Parameter name for error messages
+
+        Returns:
+            Line number (1-based)
+
+        Raises:
+            ValueError: If text not found or matches multiple lines
+        """
+        matches = []
+        for i, line in enumerate(lines, start=1):
+            if search_text in line:
+                matches.append(i)
+
+        if not matches:
+            msg = f"{param_name} text not found: {search_text!r}"
+            raise ValueError(msg)
+        if len(matches) > 1:
+            match_lines = ", ".join(str(m) for m in matches[:5])
+            more = f" and {len(matches) - 5} more" if len(matches) > 5 else ""  # noqa: PLR2004
+            msg = (
+                f"{param_name} text matches multiple lines ({match_lines}{more}). "
+                f"Include more context to make it unique."
+            )
+            raise ValueError(msg)
+
+        return matches[0]
+
+    @staticmethod
+    def _find_first_after(
+        lines: list[str], search_text: str, after_line: int, param_name: str
+    ) -> int:
+        """Find first occurrence of text after a given line.
+
+        Args:
+            lines: File lines
+            search_text: Text to search for
+            after_line: Line number to search after (1-based)
+            param_name: Parameter name for error messages
+
+        Returns:
+            Line number (1-based)
+
+        Raises:
+            ValueError: If text not found after the specified line
+        """
+        for i in range(after_line - 1, len(lines)):
+            if search_text in lines[i]:
+                return i + 1
+
+        msg = f"{param_name} text not found after line {after_line}: {search_text!r}"
+        raise ValueError(msg)
+
     async def grep(  # noqa: D417
         self,
         agent_ctx: AgentContext,
@@ -855,7 +1142,7 @@ class FSSpecTools(ResourceProvider):
 
             # Fallback to fsspec grep if subprocess didn't work
             if result is None or "error" in result:
-                fs = self.get_fs(agent_ctx)
+                fs = self._get_fs(agent_ctx)
                 result = await grep_with_fsspec(
                     fs=fs,
                     pattern=pattern,
@@ -898,12 +1185,12 @@ class FSSpecTools(ResourceProvider):
     async def _read(self, agent_ctx: AgentContext, path: str, encoding: str = "utf-8") -> str:
         # with self.fs.open(path, "r", encoding="utf-8") as f:
         #     return f.read()
-        return await self.get_fs(agent_ctx)._cat(path)  # type: ignore[no-any-return]
+        return await self._get_fs(agent_ctx)._cat(path)  # type: ignore[no-any-return]
 
     async def _write(self, agent_ctx: AgentContext, path: str, content: str | bytes) -> None:
         if isinstance(content, str):
             content = content.encode()
-        await self.get_fs(agent_ctx)._pipe_file(path, content)
+        await self._get_fs(agent_ctx)._pipe_file(path, content)
 
     async def download_file(  # noqa: D417
         self,
@@ -937,7 +1224,7 @@ class FSSpecTools(ResourceProvider):
         full_path = f"{target_dir.rstrip('/')}/{filename}"
 
         try:
-            fs = self.get_fs(agent_ctx)
+            fs = self._get_fs(agent_ctx)
             # Ensure target directory exists
             await fs._makedirs(target_dir, exist_ok=True)
 
@@ -1000,7 +1287,7 @@ class FSSpecTools(ResourceProvider):
             await agent_ctx.events.file_operation("read", path=url, success=False, error=error_msg)
             return {"error": error_msg}
 
-    async def agentic_edit(  # noqa: D417, PLR0915
+    async def agentic_edit(  # noqa: D417
         self,
         run_ctx: RunContext,
         agent_ctx: AgentContext,
@@ -1063,10 +1350,8 @@ class FSSpecTools(ResourceProvider):
             # 1. Stored history (previous runs) from agent.conversation
             # 2. Current run messages from run_ctx.messages (not yet stored)
             stored_history = agent.conversation.get_history()
-
             # Build complete message list
             all_messages: list[ModelRequest | ModelResponse] = []
-
             # Add stored history from previous runs
             for chat_msg in stored_history:
                 all_messages.extend(chat_msg.to_pydantic_ai())
@@ -1074,7 +1359,6 @@ class FSSpecTools(ResourceProvider):
             # Add current run's messages (not yet in stored history)
             # But exclude the last message if it contains the current agentic_edit tool call
             # to avoid the sub-agent seeing "I'm calling agentic_edit" in its context
-            from pydantic_ai.messages import ModelResponse, ToolCallPart
 
             for msg in run_ctx.messages:
                 if isinstance(msg, ModelResponse):