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

agentpool_toolsets/__init__.py

@@ -3,13 +3,11 @@
 from agentpool_toolsets.config_creation import ConfigCreationTools
 from agentpool_toolsets.fsspec_toolset import FSSpecTools
 from agentpool_toolsets.notifications import NotificationsTools
-from agentpool_toolsets.semantic_memory_toolset import SemanticMemoryTools
 from agentpool_toolsets.vfs_toolset import VFSTools
 
 __all__ = [
     "ConfigCreationTools",
     "FSSpecTools",
     "NotificationsTools",
-    "SemanticMemoryTools",
     "VFSTools",
 ]

agentpool_toolsets/builtin/__init__.py

@@ -4,30 +4,20 @@ from __future__ import annotations
 
 
 # Import provider classes
-from agentpool_toolsets.builtin.agent_management import AgentManagementTools
 from agentpool_toolsets.builtin.code import CodeTools
 from agentpool_toolsets.builtin.debug import DebugTools
-from agentpool_toolsets.builtin.execution_environment import ExecutionEnvironmentTools
-from agentpool_toolsets.builtin.history import HistoryTools
-from agentpool_toolsets.builtin.integration import IntegrationTools
+from agentpool_toolsets.builtin.execution_environment import ProcessManagementTools
 from agentpool_toolsets.builtin.skills import SkillsTools
 from agentpool_toolsets.builtin.subagent_tools import SubagentTools
-from agentpool_toolsets.builtin.tool_management import ToolManagementTools
-from agentpool_toolsets.builtin.user_interaction import UserInteractionTools
 from agentpool_toolsets.builtin.workers import WorkersTools
 
 
 __all__ = [
     # Provider classes
-    "AgentManagementTools",
     "CodeTools",
     "DebugTools",
-    "ExecutionEnvironmentTools",
-    "HistoryTools",
-    "IntegrationTools",
+    "ProcessManagementTools",
     "SkillsTools",
     "SubagentTools",
-    "ToolManagementTools",
-    "UserInteractionTools",
     "WorkersTools",
 ]

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 collections.abc import Sequence
+
     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,51 +93,63 @@ 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
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get code analysis tools."""
         if self._tools is not None:
             return self._tools
@@ -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

@@ -4,15 +4,23 @@ from __future__ import annotations
 
 from collections import deque
 from dataclasses import dataclass, field
+from datetime import UTC, datetime
+import json
 import logging
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
+from fsspec.implementations.asyn_wrapper import AsyncFileSystemWrapper
+from fsspec.implementations.memory import MemoryFileSystem
 from pydantic_ai import RunContext  # noqa: TC002
 
 from agentpool.agents.context import AgentContext  # noqa: TC001
 from agentpool.resource_providers import StaticResourceProvider
 
 
+if TYPE_CHECKING:
+    from fsspec.asyn import AsyncFileSystem
+
+
 LogLevel = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
 
 
@@ -131,6 +139,8 @@ Available in namespace:
 - ctx: AgentContext (ctx.agent, ctx.pool, ctx.config, ctx.definition, etc.)
 - run_ctx: pydantic-ai RunContext (current run state)
 - me: Shortcut for ctx.agent (your Agent instance)
+- save(key, value): Save an object to persist between calls
+- state: Dict of saved objects from previous calls
 
 You can inspect yourself, the pool, other agents, your tools, and more.
 Write an async main() function that returns the result.
@@ -138,8 +148,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:
@@ -159,30 +169,6 @@ async def main():
 """
 
 
-async def execute_introspection(ctx: AgentContext, run_ctx: RunContext[Any], code: str) -> str:  # noqa: D417
-    """Execute Python code with access to your own runtime context.
-
-    This is a debugging/development tool that gives you full access to
-    inspect and interact with your runtime environment.
-
-    Args:
-        code: Python code with async main() function to execute
-
-    Returns:
-        Result of execution or error message
-    """
-    # Build namespace with runtime context
-    namespace: dict[str, Any] = {"ctx": ctx, "run_ctx": run_ctx, "me": ctx.agent}
-    try:
-        exec(code, namespace)
-        if "main" not in namespace:
-            return "Error: Code must define an async main() function"
-        result = await namespace["main"]()
-        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}"
-
-
 # =============================================================================
 # Log Tools
 # =============================================================================
@@ -216,18 +202,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
 # =============================================================================
@@ -268,24 +242,120 @@ class DebugTools(StaticResourceProvider):
     - Self-introspection via code execution with runtime context access
     - Log inspection and management
     - Platform path discovery
+    - Stateful namespace for persisting objects between introspection calls
     """
 
-    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)
+        self._namespace_storage: dict[str, Any] = {}  # Stateful storage for introspection
+        # Wrap MemoryFileSystem for async support
+        self._memory_fs = MemoryFileSystem()
+        self._fs = AsyncFileSystemWrapper(self._memory_fs)
 
-        if install_log_handler:
-            install_memory_handler()
-
-        desc = (execute_introspection.__doc__ or "") + "\n\n" + INTROSPECTION_USAGE
+        desc = (self.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(
+                self.execute_introspection, category="other", description_override=desc
+            ),
             self.create_tool(get_platform_paths, category="other", read_only=True, idempotent=True),
         ]
+
+    def get_fs(self) -> AsyncFileSystem:
+        """Get filesystem view of script history and state.
+
+        Returns:
+            AsyncFileSystem containing:
+            - scripts/{timestamp}_{title}.py - Executed scripts
+            - scripts/{timestamp}_{title}.json - Execution metadata
+        """
+        return self._fs
+
+    async def execute_introspection(  # noqa: D417
+        self, ctx: AgentContext, run_ctx: RunContext[Any], code: str, title: str
+    ) -> str:
+        """Execute Python code with access to your own runtime context.
+
+        This is a debugging/development tool that gives you full access to
+        inspect and interact with your runtime environment.
+
+        Args:
+            code: Python code with async main() function to execute
+            title: Short descriptive title for this script (3-4 words)
+
+        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 and stateful storage
+        def save(key: str, value: Any) -> None:
+            """Save a value to persist between introspection calls."""
+            self._namespace_storage[key] = value
+
+        state = self._namespace_storage.copy()
+
+        namespace: dict[str, Any] = {
+            "ctx": ctx,
+            "run_ctx": run_ctx,
+            "me": ctx.agent,
+            "save": save,
+            "state": state,
+        }
+        start_time = datetime.now(UTC)
+        exit_code = 0
+        error_msg = None
+        result_str = None
+
+        try:
+            exec(code, namespace)
+            if "main" not in namespace:
+                return "Error: Code must define an async main() function"
+            result = await namespace["main"]()
+            result_str = (
+                str(result)
+                if result is not None
+                else "Code executed successfully (no return value)"
+            )
+
+            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_str}\n```"],
+            )
+        except Exception as e:  # noqa: BLE001
+            exit_code = 1
+            error_msg = f"{type(e).__name__}: {e}"
+            result_str = error_msg
+        finally:
+            # Save to filesystem
+            end_time = datetime.now(UTC)
+            duration = (end_time - start_time).total_seconds()
+            timestamp = start_time.strftime("%Y%m%d_%H%M%S")
+
+            # Write script file
+            script_path = f"scripts/{timestamp}_{title}.py"
+            self._memory_fs.pipe(script_path, code.encode("utf-8"))
+
+            # Write metadata file
+            metadata = {
+                "title": title,
+                "timestamp": start_time.isoformat(),
+                "exit_code": exit_code,
+                "duration": duration,
+                "result": result_str,
+                "error": error_msg,
+            }
+            metadata_path = f"scripts/{timestamp}_{title}.json"
+            self._memory_fs.pipe(metadata_path, json.dumps(metadata, indent=2).encode("utf-8"))
+
+        return result_str