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

agentpool_toolsets/builtin/code.py

@@ -13,15 +13,21 @@ from upathtools import is_directory
 from agentpool.agents.context import AgentContext  # noqa: TC001
 from agentpool.log import get_logger
 from agentpool.resource_providers import ResourceProvider
-from agentpool_toolsets.fsspec_toolset.diagnostics import DiagnosticsManager
+from agentpool_toolsets.fsspec_toolset.diagnostics import (
+    DiagnosticsManager,
+    format_diagnostics_table,
+    format_run_summary,
+)
 
 
 if TYPE_CHECKING:
-    from anyenv.lsp_servers import Diagnostic
     from exxec.base import ExecutionEnvironment
+    from fsspec.asyn import AsyncFileSystem
 
     from agentpool.tools.base import Tool
-
+    from agentpool_toolsets.fsspec_toolset.diagnostics import (
+        DiagnosticsConfig,
+    )
 
 logger = get_logger(__name__)
 
@@ -87,46 +93,58 @@ class CodeTools(ResourceProvider):
         env: ExecutionEnvironment | None = None,
         name: str = "code",
         cwd: str | None = None,
+        diagnostics_config: DiagnosticsConfig | None = None,
     ) -> None:
         """Initialize with an optional execution environment.
 
         Args:
             env: Execution environment to operate on. If None, falls back to agent.env
             name: Name for this toolset provider
-            cwd: Optional cwd to resolve relative paths against
+            cwd: Optional cwd to resolve relative paths against (falls back to env.cwd)
+            diagnostics_config: Configuration for diagnostic tools (server selection, etc.)
         """
+        super().__init__(name=name)
+
+        self._explicit_env = env
+        self._explicit_cwd = cwd
+        self._diagnostics_config = diagnostics_config
+        self._tools: list[Tool] | None = None
+
+    def _get_env(self, agent_ctx: AgentContext) -> ExecutionEnvironment | None:
+        """Get execution environment (explicit or from agent)."""
+        return self._explicit_env or agent_ctx.agent.env
+
+    def _get_cwd(self, agent_ctx: AgentContext) -> str | None:
+        """Get working directory (explicit, from env, or from agent.env)."""
+        if self._explicit_cwd:
+            return self._explicit_cwd
+        env = self._get_env(agent_ctx)
+        return env.cwd if env else None
+
+    def _get_fs(self, agent_ctx: AgentContext) -> AsyncFileSystem:
+        """Get filesystem (from env or fallback to local)."""
         from fsspec.asyn import AsyncFileSystem
         from fsspec.implementations.asyn_wrapper import AsyncFileSystemWrapper
         from morefs.asyn_local import AsyncLocalFileSystem
 
-        super().__init__(name=name)
-
-        self.execution_env = env
-        self.cwd = cwd or (env.cwd if env else None)
+        env = self._get_env(agent_ctx)
         fs = env.get_fs() if env else None
         match fs:
             case AsyncFileSystem():
-                self.fs = fs
+                return fs
             case AbstractFileSystem():
-                self.fs = AsyncFileSystemWrapper(fs)
-            case None:
-                self.fs = AsyncLocalFileSystem()
-        self._tools: list[Tool] | None = None
-        self._diagnostics: DiagnosticsManager | None = None
-
-    def _get_env(self, agent_ctx: AgentContext) -> ExecutionEnvironment | None:
-        """Get execution environment (explicit or from agent)."""
-        return self.execution_env or agent_ctx.agent.env
+                return AsyncFileSystemWrapper(fs)
+            case _:
+                return AsyncLocalFileSystem()
 
     def _resolve_path(self, path: str, agent_ctx: AgentContext) -> str:
         """Resolve a potentially relative path to an absolute path.
 
-        Gets cwd from self.cwd, execution_env.cwd, or agent.env.cwd.
+        Gets cwd from explicit cwd, env.cwd, or agent.env.cwd.
         If cwd is set and path is relative, resolves relative to cwd.
         Otherwise returns the path as-is.
         """
-        env = self._get_env(agent_ctx)
-        cwd = self.cwd or (env.cwd if env else None)
+        cwd = self._get_cwd(agent_ctx)
         if cwd and not (path.startswith("/") or (len(path) > 1 and path[1] == ":")):
             return str(Path(cwd) / path)
         return path
@@ -160,8 +178,9 @@ class CodeTools(ResourceProvider):
         from anyenv.language_formatters import FormatterRegistry
 
         resolved = self._resolve_path(path, agent_ctx)
+        fs = self._get_fs(agent_ctx)
         try:
-            content = await self.fs._cat_file(resolved)
+            content = await fs._cat_file(resolved)
             code = content.decode("utf-8") if isinstance(content, bytes) else content
         except FileNotFoundError:
             return f"❌ File not found: {path}"
@@ -189,7 +208,7 @@ class CodeTools(ResourceProvider):
             if result.success:
                 # Write back if formatted
                 if result.format_result.formatted and result.format_result.output:
-                    await self.fs._pipe_file(resolved, result.format_result.output.encode("utf-8"))
+                    await fs._pipe_file(resolved, result.format_result.output.encode("utf-8"))
                     changes = "formatted and saved"
                 else:
                     changes = "no changes needed"
@@ -271,6 +290,7 @@ class CodeTools(ResourceProvider):
         from ast_grep_py import SgRoot
 
         resolved = self._resolve_path(path, agent_ctx)
+        fs = self._get_fs(agent_ctx)
 
         # Detect language from extension
         language = _detect_language(path)
@@ -279,7 +299,7 @@ class CodeTools(ResourceProvider):
 
         # Read file
         try:
-            content = await self.fs._cat_file(resolved)
+            content = await fs._cat_file(resolved)
             code = content.decode("utf-8") if isinstance(content, bytes) else content
         except FileNotFoundError:
             return {"error": f"File not found: {path}"}
@@ -318,7 +338,7 @@ class CodeTools(ResourceProvider):
             result["dry_run"] = dry_run
 
             if not dry_run:
-                await self.fs._pipe_file(resolved, fixed_code.encode("utf-8"))
+                await fs._pipe_file(resolved, fixed_code.encode("utf-8"))
                 result["written"] = True
 
         return result
@@ -343,29 +363,46 @@ class CodeTools(ResourceProvider):
             ones based on file extensions.
         """
         resolved = self._resolve_path(path, agent_ctx)
+        fs = self._get_fs(agent_ctx)
+        env = self._get_env(agent_ctx)
 
-        # Get or create diagnostics manager
-        if self._diagnostics is None:
-            env = self._get_env(agent_ctx)
-            if not env:
-                return "Diagnostics unavailable: no execution environment configured"
-            self._diagnostics = DiagnosticsManager(env)
+        if not env:
+            return "Diagnostics unavailable: no execution environment configured"
+
+        # Create diagnostics manager with config
+        manager = DiagnosticsManager(env, config=self._diagnostics_config)
+
+        # Progress callback that emits tool_call_progress events
+        async def progress_callback(
+            message: str,
+            *,
+            server_id: str | None = None,
+            command: str | None = None,
+            status: str = "running",
+        ) -> None:
+            items = []
+            if command:
+                items.append(f"```bash\n{command}\n```")
+            await agent_ctx.events.tool_call_progress(
+                message,
+                status="in_progress",
+                items=items if items else None,
+            )
 
         # Check if path is directory or file
         try:
-            is_dir = await self.fs._isdir(resolved)
+            is_dir = await fs._isdir(resolved)
         except Exception:  # noqa: BLE001
             is_dir = False
 
         if is_dir:
             # Collect all files in directory
             try:
-                files = await self.fs._find(resolved, detail=True)
-                # Filter to only include files (not directories)
+                files = await fs._find(resolved, detail=True)
                 file_paths = [
-                    path
-                    for path, info in files.items()  # pyright: ignore[reportAttributeAccessIssue]
-                    if not await is_directory(self.fs, path, entry_type=info["type"])
+                    p
+                    for p, info in files.items()  # pyright: ignore[reportAttributeAccessIssue]
+                    if not await is_directory(fs, p, entry_type=info["type"])
                 ]
             except Exception as e:  # noqa: BLE001
                 return f"Error scanning directory: {e}"
@@ -373,26 +410,28 @@ class CodeTools(ResourceProvider):
             if not file_paths:
                 return f"No files found in: {path}"
 
-            all_diagnostics: list[Diagnostic] = []
-            for file_path in file_paths:
-                diagnostics = await self._diagnostics.run_for_file(file_path)
-                all_diagnostics.extend(diagnostics)
+            result = await manager.run_for_files(file_paths, progress=progress_callback)
+        else:
+            # Single file
+            try:
+                result = await manager.run_for_file(resolved, progress=progress_callback)
+            except FileNotFoundError:
+                return f"File not found: {path}"
+            except Exception as e:  # noqa: BLE001
+                return f"Error running diagnostics: {e}"
 
-            if not all_diagnostics:
-                return f"No issues found in {len(file_paths)} files"
+        # Format output
+        if not result.diagnostics:
+            summary = format_run_summary(result)
+            return f"No issues found. {summary}"
 
-            formatted = self._diagnostics.format_diagnostics(all_diagnostics)
-            return f"Found {len(all_diagnostics)} issues:\n{formatted}"
-        # Single file
-        try:
-            diagnostics = await self._diagnostics.run_for_file(resolved)
-        except FileNotFoundError:
-            return f"File not found: {path}"
-        except Exception as e:  # noqa: BLE001
-            return f"Error running diagnostics: {e}"
+        formatted = format_diagnostics_table(result.diagnostics)
+        summary = format_run_summary(result)
 
-        if not diagnostics:
-            return f"No issues found in: {path}"
+        await agent_ctx.events.tool_call_progress(
+            summary,
+            status="in_progress",
+            items=[formatted],
+        )
 
-        formatted = self._diagnostics.format_diagnostics(diagnostics)
-        return f"Found {len(diagnostics)} issues:\n{formatted}"
+        return f"{summary}\n\n{formatted}"

agentpool_toolsets/builtin/debug.py

@@ -138,8 +138,8 @@ Write an async main() function that returns the result.
 Example - inspect your own tools:
 ```python
 async def main():
-    tools = me.tools.list_tools()
-    return [t.name for t in tools]
+    tools = await me.tools.list_tools()
+    return list(tools.keys())
 ```
 
 Example - check pool state:
@@ -171,6 +171,13 @@ async def execute_introspection(ctx: AgentContext, run_ctx: RunContext[Any], cod
     Returns:
         Result of execution or error message
     """
+    # Emit progress with the code being executed
+    await ctx.events.tool_call_progress(
+        title="Executing introspection code",
+        status="in_progress",
+        items=[f"```python\n{code}\n```"],
+    )
+
     # Build namespace with runtime context
     namespace: dict[str, Any] = {"ctx": ctx, "run_ctx": run_ctx, "me": ctx.agent}
     try:
@@ -178,6 +185,12 @@ async def execute_introspection(ctx: AgentContext, run_ctx: RunContext[Any], cod
         if "main" not in namespace:
             return "Error: Code must define an async main() function"
         result = await namespace["main"]()
+        await ctx.events.tool_call_progress(
+            title="Executed introspection code successfully",
+            status="in_progress",
+            items=[f"```python\n{code}\n```\n\n```terminal\n{result}\n```"],
+        )
+
         return str(result) if result is not None else "Code executed successfully (no return value)"
     except Exception as e:  # noqa: BLE001
         return f"Error executing code: {type(e).__name__}: {e}"
@@ -216,18 +229,6 @@ async def get_logs(
     return "\n".join(lines)
 
 
-async def clear_logs() -> str:
-    """Clear all captured log entries from memory.
-
-    Returns:
-        Confirmation message
-    """
-    handler = get_memory_handler()
-    count = len(handler.records)
-    handler.clear()
-    return f"Cleared {count} log entries"
-
-
 # =============================================================================
 # Path Tools
 # =============================================================================
@@ -270,22 +271,16 @@ class DebugTools(StaticResourceProvider):
     - Platform path discovery
     """
 
-    def __init__(self, name: str = "debug", install_log_handler: bool = True) -> None:
+    def __init__(self, name: str = "debug") -> None:
         """Initialize debug tools.
 
         Args:
             name: Toolset name/namespace
-            install_log_handler: Whether to install the memory log handler
         """
         super().__init__(name=name)
 
-        if install_log_handler:
-            install_memory_handler()
-
         desc = (execute_introspection.__doc__ or "") + "\n\n" + INTROSPECTION_USAGE
         self._tools = [
             self.create_tool(execute_introspection, category="other", description_override=desc),
-            self.create_tool(get_logs, category="other", read_only=True, idempotent=True),
-            self.create_tool(clear_logs, category="other"),
             self.create_tool(get_platform_paths, category="other", read_only=True, idempotent=True),
         ]