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

agentpool_toolsets/fsspec_toolset/grep.py

@@ -85,6 +85,66 @@ async def detect_grep_backend(env: ExecutionEnvironment) -> GrepBackend:
     return GrepBackend.PYTHON
 
 
+def _is_path_inside_ignored_dir(path: str) -> bool:
+    """Check if path is explicitly inside a commonly ignored directory.
+
+    Args:
+        path: The search path
+
+    Returns:
+        True if path is inside a directory that would typically be gitignored
+    """
+    # Common ignored directory patterns (without trailing slash)
+    ignored_dirs = [
+        ".venv",
+        "venv",
+        ".env",
+        "env",
+        "node_modules",
+        ".git",
+        "__pycache__",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".tox",
+        ".nox",
+    ]
+    for ignored in ignored_dirs:
+        if (
+            path.startswith((f"{ignored}/", f"./{ignored}/"))
+            or f"/{ignored}/" in path
+            or path == ignored
+        ):
+            return True
+    return False
+
+
+def _filter_exclude_patterns(path: str, exclude_patterns: list[str]) -> list[str]:
+    """Filter out exclude patterns that the search path is explicitly inside.
+
+    If user explicitly searches inside an excluded directory (e.g., .venv/),
+    don't exclude that directory from results.
+
+    Args:
+        path: The search path
+        exclude_patterns: List of patterns to potentially exclude
+
+    Returns:
+        Filtered list of exclude patterns
+    """
+    filtered = []
+    for pattern in exclude_patterns:
+        # Normalize pattern (remove trailing slash for comparison)
+        pattern_normalized = pattern.rstrip("/")
+        # Check if the search path starts with or contains this excluded dir
+        # e.g., path=".venv/lib/python" should not exclude ".venv/"
+        if not (
+            path.startswith((pattern_normalized, f"./{pattern_normalized}"))
+            or f"/{pattern_normalized}/" in path
+        ):
+            filtered.append(pattern)
+    return filtered
+
+
 async def grep_with_subprocess(
     env: ExecutionEnvironment,
     pattern: str,
@@ -124,11 +184,23 @@ async def grep_with_subprocess(
         msg = "Subprocess grep requested but no grep/ripgrep found"
         raise ValueError(msg)
 
-    exclude = exclude_patterns or DEFAULT_EXCLUDE_PATTERNS
+    base_exclude = exclude_patterns or DEFAULT_EXCLUDE_PATTERNS
+    # Filter out patterns that the user is explicitly searching inside
+    exclude = _filter_exclude_patterns(path, base_exclude)
+
+    # Disable gitignore if explicitly searching inside an ignored directory
+    # (e.g., searching .venv/ when .venv is in .gitignore)
+    effective_use_gitignore = use_gitignore and not _is_path_inside_ignored_dir(path)
 
     if backend == GrepBackend.RIPGREP:
         cmd_list = _build_ripgrep_command(
-            pattern, path, case_sensitive, max_matches, exclude, use_gitignore, context_lines
+            pattern,
+            path,
+            case_sensitive,
+            max_matches,
+            exclude,
+            effective_use_gitignore,
+            context_lines,
         )
     else:
         cmd_list = _build_gnu_grep_command(

agentpool_toolsets/fsspec_toolset/image_utils.py

@@ -0,0 +1,161 @@
+"""Image processing utilities for the fsspec toolset."""
+
+from __future__ import annotations
+
+from io import BytesIO
+
+
+# 4.5MB - provides headroom below Anthropic's 5MB limit
+DEFAULT_MAX_BYTES = int(4.5 * 1024 * 1024)
+
+# Minimum dimension for resized images
+MIN_DIMENSION = 100
+
+
+def _pick_smaller(
+    a: tuple[bytes, str],
+    b: tuple[bytes, str],
+) -> tuple[bytes, str]:
+    """Pick the smaller of two image buffers."""
+    return a if len(a[0]) <= len(b[0]) else b
+
+
+def _make_resize_note(
+    original_width: int,
+    original_height: int,
+    final_width: int,
+    final_height: int,
+    suffix: str = "",
+) -> str:
+    """Create a resize note string."""
+    scale = original_width / final_width if final_width > 0 else 1.0
+    base = f"[Image resized: {original_width}x{original_height} → {final_width}x{final_height}"
+    return f"{base}, scale={scale:.2f}x{suffix}]"
+
+
+def resize_image_if_needed(
+    data: bytes,
+    media_type: str,
+    max_size: int,
+    max_bytes: int | None = None,
+    jpeg_quality: int = 80,
+) -> tuple[bytes, str, str | None]:
+    """Resize image if it exceeds limits, preserving aspect ratio.
+
+    Returns the original image if it already fits within all limits.
+
+    Strategy for staying under max_bytes:
+    1. First resize to max_size dimensions
+    2. Try both PNG and JPEG formats, pick the smaller one
+    3. If still too large, try JPEG with decreasing quality
+    4. If still too large, progressively reduce dimensions
+
+    Args:
+        data: Raw image bytes
+        media_type: MIME type of the image
+        max_size: Maximum width/height in pixels
+        max_bytes: Maximum file size in bytes (default: 4.5MB)
+        jpeg_quality: Initial quality for JPEG output (1-100)
+
+    Returns:
+        Tuple of (image_data, media_type, dimension_note).
+        dimension_note is None if no resizing was needed, otherwise contains
+        a message about the resize for the model to map coordinates.
+    """
+    from PIL import Image
+
+    max_bytes = max_bytes if max_bytes is not None else DEFAULT_MAX_BYTES
+
+    img = Image.open(BytesIO(data))
+    original_width, original_height = img.size
+
+    # Check if already within all limits (dimensions AND size)
+    original_size = len(data)
+    if original_width <= max_size and original_height <= max_size and original_size <= max_bytes:
+        return data, media_type, None
+
+    # Calculate initial dimensions respecting max limits
+    target_width = original_width
+    target_height = original_height
+
+    if target_width > max_size:
+        target_height = round(target_height * max_size / target_width)
+        target_width = max_size
+    if target_height > max_size:
+        target_width = round(target_width * max_size / target_height)
+        target_height = max_size
+
+    def try_both_formats(
+        img: Image.Image,
+        width: int,
+        height: int,
+        quality: int,
+    ) -> tuple[bytes, str]:
+        """Resize and encode in both formats, returning the smaller one."""
+        resized = img.resize((width, height), Image.Resampling.LANCZOS)
+
+        # Convert to RGB for JPEG if needed (handles RGBA, P mode, etc.)
+        if resized.mode in ("RGBA", "LA", "P"):
+            rgb_img = Image.new("RGB", resized.size, (255, 255, 255))
+            if resized.mode == "P":
+                resized = resized.convert("RGBA")
+            rgb_img.paste(resized, mask=resized.split()[-1] if resized.mode == "RGBA" else None)
+            jpeg_source = rgb_img
+        else:
+            jpeg_source = resized.convert("RGB") if resized.mode != "RGB" else resized
+
+        # Try PNG
+        png_buf = BytesIO()
+        resized.save(png_buf, format="PNG", optimize=True)
+        png_data = png_buf.getvalue()
+
+        # Try JPEG
+        jpeg_buf = BytesIO()
+        jpeg_source.save(jpeg_buf, format="JPEG", quality=quality, optimize=True)
+        jpeg_data = jpeg_buf.getvalue()
+
+        return _pick_smaller((png_data, "image/png"), (jpeg_data, "image/jpeg"))
+
+    # Quality and scale steps for progressive reduction
+    quality_steps = [85, 70, 55, 40]
+    scale_steps = [1.0, 0.75, 0.5, 0.35, 0.25]
+
+    final_width = target_width
+    final_height = target_height
+
+    # First attempt: resize to target dimensions, try both formats
+    best_data, best_type = try_both_formats(img, target_width, target_height, jpeg_quality)
+
+    if len(best_data) <= max_bytes:
+        note = _make_resize_note(original_width, original_height, final_width, final_height)
+        return best_data, best_type, note
+
+    # Still too large - try with decreasing quality
+    for quality in quality_steps:
+        best_data, best_type = try_both_formats(img, target_width, target_height, quality)
+
+        if len(best_data) <= max_bytes:
+            note = _make_resize_note(original_width, original_height, final_width, final_height)
+            return best_data, best_type, note
+
+    # Still too large - reduce dimensions progressively
+    for scale_factor in scale_steps:
+        final_width = round(target_width * scale_factor)
+        final_height = round(target_height * scale_factor)
+
+        # Skip if dimensions are too small
+        if final_width < MIN_DIMENSION or final_height < MIN_DIMENSION:
+            break
+
+        for quality in quality_steps:
+            best_data, best_type = try_both_formats(img, final_width, final_height, quality)
+
+            if len(best_data) <= max_bytes:
+                note = _make_resize_note(original_width, original_height, final_width, final_height)
+                return best_data, best_type, note
+
+    # Last resort: return smallest version we produced even if over limit
+    note = _make_resize_note(
+        original_width, original_height, final_width, final_height, " (may exceed size limit)"
+    )
+    return best_data, best_type, note

agentpool_toolsets/fsspec_toolset/toolset.py

@@ -7,7 +7,7 @@ from fnmatch import fnmatch
 import os
 from pathlib import Path
 import time
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 from urllib.parse import urlparse
 
 import anyio
@@ -28,7 +28,11 @@ from agentpool.mime_utils import guess_type, is_binary_content, is_binary_mime
 from agentpool.resource_providers import ResourceProvider
 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 DiagnosticsManager
+from agentpool_toolsets.fsspec_toolset.diagnostics import (
+    DiagnosticsConfig,
+    DiagnosticsManager,
+    format_diagnostics_table,
+)
 from agentpool_toolsets.fsspec_toolset.grep import GrepBackend
 from agentpool_toolsets.fsspec_toolset.helpers import (
     format_directory_listing,
@@ -45,7 +49,7 @@ from agentpool_toolsets.fsspec_toolset.streaming_diff_parser import (
 if TYPE_CHECKING:
     import fsspec
     from fsspec.asyn import AsyncFileSystem
-    from pydantic_ai.messages import ModelResponse
+    from pydantic_ai.messages import ModelRequest, ModelResponse
 
     from agentpool.agents.base_agent import BaseAgent
     from agentpool.common_types import ModelType
@@ -78,6 +82,9 @@ class FSSpecTools(ResourceProvider):
         enable_diagnostics: bool = False,
         large_file_tokens: int = 12_000,
         map_max_tokens: int = 2048,
+        edit_tool: Literal["simple", "batch", "agentic"] = "simple",
+        max_image_size: int | None = 2000,
+        max_image_bytes: int | None = None,
     ) -> None:
         """Initialize with an fsspec filesystem or execution environment.
 
@@ -94,6 +101,12 @@ class FSSpecTools(ResourceProvider):
             enable_diagnostics: Run LSP CLI diagnostics after file writes (default: False)
             large_file_tokens: Token threshold for switching to structure map (default: 12000)
             map_max_tokens: Maximum tokens for structure map output (default: 2048)
+            edit_tool: Which edit variant to expose ("simple" or "batch")
+            max_image_size: Max width/height for images in pixels. Larger images are
+                auto-resized for better model compatibility. Set to None to disable.
+            max_image_bytes: Max file size for images in bytes. Images exceeding this
+                are compressed using progressive quality/dimension reduction.
+                Default: 4.5MB (below Anthropic's 5MB limit).
         """
         from fsspec.asyn import AsyncFileSystem
         from fsspec.implementations.asyn_wrapper import AsyncFileSystemWrapper
@@ -124,6 +137,9 @@ class FSSpecTools(ResourceProvider):
         self._large_file_tokens = large_file_tokens
         self._map_max_tokens = map_max_tokens
         self._repomap: RepoMap | None = None
+        self._edit_tool = edit_tool
+        self._max_image_size = max_image_size
+        self._max_image_bytes = max_image_bytes
 
     def get_fs(self, agent_ctx: AgentContext) -> AsyncFileSystem:
         """Get filesystem, falling back to agent's env if not set.
@@ -139,11 +155,15 @@ class FSSpecTools(ResourceProvider):
         fs = agent_ctx.agent.env.get_fs()
         return fs if isinstance(fs, AsyncFileSystem) else AsyncFileSystemWrapper(fs)
 
-    def _get_diagnostics_manager(self, agent_ctx: AgentContext) -> DiagnosticsManager:
+    def _get_diagnostics_manager(self, agent_ctx: AgentContext) -> DiagnosticsManager | None:
         """Get or create the diagnostics manager."""
+        if not self._enable_diagnostics:
+            return None
         if self._diagnostics is None:
             env = self.execution_env or agent_ctx.agent.env
-            self._diagnostics = DiagnosticsManager(env if self._enable_diagnostics else None)
+            # Default to rust-only for fast feedback after edits
+            config = DiagnosticsConfig(rust_only=True, max_servers_per_language=1)
+            self._diagnostics = DiagnosticsManager(env, config=config)
         return self._diagnostics
 
     async def _run_diagnostics(self, agent_ctx: AgentContext, path: str) -> str | None:
@@ -151,12 +171,12 @@ class FSSpecTools(ResourceProvider):
 
         Returns formatted diagnostics string if issues found, None otherwise.
         """
-        if not self._enable_diagnostics:
-            return None
         mgr = self._get_diagnostics_manager(agent_ctx)
-        diagnostics = await mgr.run_for_file(path)
-        if diagnostics:
-            return mgr.format_diagnostics(diagnostics)
+        if mgr is None:
+            return None
+        result = await mgr.run_for_file(path)
+        if result.diagnostics:
+            return format_diagnostics_table(result.diagnostics)
         return None
 
     async def _get_file_map(self, path: str, agent_ctx: AgentContext) -> str | None:
@@ -209,15 +229,23 @@ class FSSpecTools(ResourceProvider):
 
         self._tools = [
             self.create_tool(self.list_directory, category="read", read_only=True, idempotent=True),
-            self.create_tool(self.read_file, 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),
-            self.create_tool(self.write_file, category="edit"),
+            self.create_tool(self.write, category="edit"),
             self.create_tool(self.delete_path, category="delete", destructive=True),
-            self.create_tool(self.edit_file, category="edit"),
-            self.create_tool(self.agentic_edit, category="edit"),
             self.create_tool(self.download_file, category="read", open_world=True),
         ]
 
+        # Add edit tool based on config - mutually exclusive
+        if self._edit_tool == "agentic":
+            self._tools.append(self.create_tool(self.agentic_edit, category="edit"))
+        elif self._edit_tool == "batch":
+            self._tools.append(
+                self.create_tool(self.edit_batch, category="edit", name_override="edit")
+            )
+        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(
@@ -329,14 +357,14 @@ class FSSpecTools(ResourceProvider):
         else:
             return result
 
-    async def read_file(  # noqa: D417
+    async def read(  # noqa: D417
         self,
         agent_ctx: AgentContext,
         path: str,
         encoding: str = "utf-8",
         line: int | None = None,
         limit: int | None = None,
-    ) -> str | BinaryContent:
+    ) -> str | BinaryContent | list[str | BinaryContent]:
         """Read the context of a text file, or use vision capabilites to read images or documents.
 
         Args:
@@ -346,7 +374,8 @@ class FSSpecTools(ResourceProvider):
             limit: Optional maximum number of lines to read (text files only)
 
         Returns:
-            Text content for text files, BinaryContent for binary files, or dict with error
+            Text content for text files, BinaryContent for binary files (with optional
+            dimension note as list when image was resized), or dict with error
         """
         path = self._resolve_path(path, agent_ctx)
         msg = f"Reading file: {path}"
@@ -363,6 +392,18 @@ class FSSpecTools(ResourceProvider):
                 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
+                if self._max_image_size and mime.startswith("image/"):
+                    from agentpool_toolsets.fsspec_toolset.image_utils import (
+                        resize_image_if_needed,
+                    )
+
+                    data, mime, note = resize_image_if_needed(
+                        data, mime, self._max_image_size, self._max_image_bytes
+                    )
+                    if note:
+                        # Return resized image with dimension note for coordinate mapping
+                        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)
@@ -370,6 +411,17 @@ class FSSpecTools(ResourceProvider):
                 # Binary file - return as BinaryContent for native model handling
                 await agent_ctx.events.file_operation("read", path=path, success=True)
                 mime = mime_type or "application/octet-stream"
+                # Resize images if needed
+                if self._max_image_size and mime.startswith("image/"):
+                    from agentpool_toolsets.fsspec_toolset.image_utils import (
+                        resize_image_if_needed,
+                    )
+
+                    data, mime, note = resize_image_if_needed(
+                        data, mime, self._max_image_size, self._max_image_bytes
+                    )
+                    if note:
+                        return [note, BinaryContent(data=data, media_type=mime, identifier=path)]
                 return BinaryContent(data=data, media_type=mime, identifier=path)
             content = data.decode(encoding)
 
@@ -445,7 +497,7 @@ class FSSpecTools(ResourceProvider):
         else:
             return content
 
-    async def write_file(  # noqa: D417
+    async def write(  # noqa: D417
         self,
         agent_ctx: AgentContext,
         path: str,
@@ -522,7 +574,15 @@ class FSSpecTools(ResourceProvider):
                 "file_existed": file_exists,
                 "bytes_written": content_bytes,
             }
-            await agent_ctx.events.file_operation("write", path=path, success=True)
+            # 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=[
+                    DiffContentItem(path=path, old_text="", new_text=content),
+                ],
+            )
 
             # Run diagnostics if enabled
             if diagnostics_output := await self._run_diagnostics(agent_ctx, path):
@@ -599,7 +659,7 @@ class FSSpecTools(ResourceProvider):
             await agent_ctx.events.file_operation("delete", path=path, success=True)
             return result
 
-    async def edit_file(  # noqa: D417
+    async def edit(  # noqa: D417
         self,
         agent_ctx: AgentContext,
         path: str,
@@ -607,6 +667,7 @@ class FSSpecTools(ResourceProvider):
         new_string: str,
         description: str,
         replace_all: bool = False,
+        line_hint: int | None = None,
     ) -> str:
         r"""Edit a file by replacing specific content with smart matching.
 
@@ -619,15 +680,71 @@ class FSSpecTools(ResourceProvider):
             new_string: Text content to replace it with
             description: Human-readable description of what the edit accomplishes
             replace_all: Whether to replace all occurrences (default: False)
+            line_hint: Line number hint to disambiguate when multiple matches exist.
+                If the pattern matches multiple locations, the match closest to this
+                line will be used. Useful after getting a "multiple matches" error.
+
+        Returns:
+            Success message with edit summary
+        """
+        return await self.edit_batch(
+            agent_ctx,
+            path,
+            replacements=[(old_string, new_string)],
+            description=description,
+            replace_all=replace_all,
+            line_hint=line_hint,
+        )
+
+    async def edit_batch(  # noqa: D417
+        self,
+        agent_ctx: AgentContext,
+        path: str,
+        replacements: list[tuple[str, str]],
+        description: str,
+        replace_all: bool = False,
+        line_hint: int | None = None,
+    ) -> str:
+        r"""Edit a file by applying multiple replacements in one operation.
+
+        Uses sophisticated matching strategies to handle whitespace, indentation,
+        and other variations. Shows the changes as a diff in the UI.
+
+        Replacements are applied sequentially, so later replacements see the result
+        of earlier ones. Each old_string must uniquely match one location (unless
+        replace_all=True). If a pattern matches multiple locations, include more
+        surrounding context to disambiguate.
+
+        Args:
+            path: File path (absolute or relative to session cwd)
+            replacements: List of (old_string, new_string) tuples to apply sequentially.
+                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
+            replace_all: Whether to replace all occurrences of each pattern (default: False)
+            line_hint: Line number hint to disambiguate when multiple matches exist.
+                Only applies when there is a single replacement. If the pattern matches
+                multiple locations, the match closest to this line will be used.
 
         Returns:
             Success message with edit summary
+
+        Example:
+            replacements=[
+                ("def old_name(", "def new_name("),
+                ("old_name()", "new_name()"),  # Update call sites
+            ]
         """
         path = self._resolve_path(path, agent_ctx)
         msg = f"Editing file: {path}"
         await agent_ctx.events.tool_call_start(title=msg, kind="edit", locations=[path])
-        if old_string == new_string:
-            return "Error: old_string and new_string must be different"
+
+        if not replacements:
+            return "Error: replacements list cannot be empty"
+
+        for old_str, new_str in replacements:
+            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)
@@ -637,14 +754,21 @@ class FSSpecTools(ResourceProvider):
             if isinstance(original_content, bytes):
                 original_content = original_content.decode("utf-8")
 
-            try:  # Apply smart content replacement
-                new_content = replace_content(original_content, old_string, new_string, replace_all)
-            except ValueError as e:
-                error_msg = f"Edit failed: {e}"
-                await agent_ctx.events.file_operation(
-                    "edit", path=path, success=False, error=error_msg
-                )
-                return error_msg
+            # Apply all replacements sequentially
+            new_content = original_content
+            # line_hint only makes sense for single replacements
+            hint = line_hint if len(replacements) == 1 else None
+            for old_str, new_str in replacements:
+                try:
+                    new_content = replace_content(
+                        new_content, old_str, new_str, replace_all, line_hint=hint
+                    )
+                except ValueError as e:
+                    error_msg = f"Edit failed on replacement {old_str!r}: {e}"
+                    await agent_ctx.events.file_operation(
+                        "edit", path=path, success=False, error=error_msg
+                    )
+                    return error_msg
 
             await self._write(agent_ctx, path, new_content)
             success_msg = f"Successfully edited {Path(path).name}: {description}"
@@ -906,8 +1030,6 @@ class FSSpecTools(ResourceProvider):
         Returns:
             Success message with edit summary
         """
-        from pydantic_ai.messages import CachePoint, ModelRequest
-
         from agentpool.messaging import ChatMessage, MessageHistory
 
         path = self._resolve_path(path, agent_ctx)
@@ -967,17 +1089,16 @@ class FSSpecTools(ResourceProvider):
                 else:
                     all_messages.append(msg)
 
-            # Inject CachePoint to cache everything up to this point
-            if all_messages:
-                cache_request: ModelRequest = ModelRequest(parts=[CachePoint()])  # type: ignore[list-item]
-                all_messages.append(cache_request)
+                # Inject CachePoint to cache everything up to this point
+                # if all_messages:
+                #     cache_request: ModelRequest = ModelRequest(parts=[CachePoint()])
+                #     all_messages.append(cache_request)
 
                 # Wrap in a single ChatMessage for the forked history
                 fork_history = MessageHistory(
                     messages=[ChatMessage(messages=all_messages, role="user", content="")]
                 )
-            else:
-                fork_history = MessageHistory()
+            fork_history = MessageHistory()
 
             # Stream the edit using the same agent but with forked history
             if mode == "edit" and matcher == "zed":

agentpool_toolsets/mcp_discovery/__init__.py

@@ -0,0 +1,5 @@
+"""MCP Discovery Toolset - dynamic MCP server exploration and tool execution."""
+
+from agentpool_toolsets.mcp_discovery.toolset import MCPDiscoveryToolset
+
+__all__ = ["MCPDiscoveryToolset"]