agentpool 2.2.3__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

@@ -6,10 +6,9 @@ from __future__ import annotations
 # Import provider classes
 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.execution_environment import ProcessManagementTools
 from agentpool_toolsets.builtin.skills import SkillsTools
 from agentpool_toolsets.builtin.subagent_tools import SubagentTools
-from agentpool_toolsets.builtin.user_interaction import UserInteractionTools
 from agentpool_toolsets.builtin.workers import WorkersTools
 
 
@@ -17,9 +16,8 @@ __all__ = [
     # Provider classes
     "CodeTools",
     "DebugTools",
-    "ExecutionEnvironmentTools",
+    "ProcessManagementTools",
     "SkillsTools",
     "SubagentTools",
-    "UserInteractionTools",
     "WorkersTools",
 ]

agentpool_toolsets/builtin/code.py

@@ -21,13 +21,13 @@ from agentpool_toolsets.fsspec_toolset.diagnostics import (
 
 
 if TYPE_CHECKING:
+    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,
-    )
+    from agentpool_toolsets.fsspec_toolset.diagnostics import DiagnosticsConfig
 
 logger = get_logger(__name__)
 
@@ -149,7 +149,7 @@ class CodeTools(ResourceProvider):
             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

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.
@@ -159,43 +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
-    """
-    # 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:
-        exec(code, namespace)
-        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}"
-
-
 # =============================================================================
 # Log Tools
 # =============================================================================
@@ -269,6 +242,7 @@ 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") -> None:
@@ -278,9 +252,110 @@ class DebugTools(StaticResourceProvider):
             name: Toolset name/namespace
         """
         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)
 
-        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(
+                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

agentpool_toolsets/builtin/execution_environment.py

@@ -1,11 +1,9 @@
-"""Provider for execution environment tools with event emission."""
+"""Provider for process management tools with event emission."""
 
 from __future__ import annotations
 
+import re
 from typing import TYPE_CHECKING
-import uuid
-
-from exxec.events import OutputEvent, ProcessCompletedEvent, ProcessErrorEvent, ProcessStartedEvent
 
 from agentpool import log
 from agentpool.agents.context import AgentContext  # noqa: TC001
@@ -16,26 +14,29 @@ logger = log.get_logger(__name__)
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from exxec import ExecutionEnvironment
 
     from agentpool.tools.base import Tool
 
 
-class ExecutionEnvironmentTools(ResourceProvider):
-    """Provider for execution environment tools.
+class ProcessManagementTools(ResourceProvider):
+    """Provider for background process management tools.
 
-    Combines code execution and process management capabilities
-    using any ExecutionEnvironment backend. Emits events via AgentContext.
+    Provides tools for starting, monitoring, and controlling background processes.
+    Uses any ExecutionEnvironment backend and emits events via AgentContext.
 
-    NOTE: The ACP execution environment used handles the Terminal events of the protocol,
-    the toolset should deal with the ToolCall events for UI display purposes.
+    For code execution and bash commands, use the standalone tools:
+    - agentpool.tool_impls.bash.BashTool
+    - agentpool.tool_impls.execute_code.ExecuteCodeTool
     """
 
-    def __init__(self, env: ExecutionEnvironment | None = None, name: str = "execution") -> None:
-        """Initialize execution environment toolset.
+    def __init__(self, env: ExecutionEnvironment | None = None, name: str = "process") -> None:
+        """Initialize process management toolset.
 
         Args:
-            env: Execution environment to use (defaults to LocalExecutionEnvironment)
+            env: Execution environment to use (defaults to agent.env)
             name: The name of the toolset
         """
         super().__init__(name=name)
@@ -51,12 +52,8 @@ class ExecutionEnvironmentTools(ResourceProvider):
             return self._env
         return agent_ctx.agent.env
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         return [
-            # Code execution tools
-            self.create_tool(self.execute_code, category="execute"),
-            self.create_tool(self.bash, category="execute", open_world=True),
-            # Process management tools
             self.create_tool(self.start_process, category="execute", open_world=True),
             self.create_tool(
                 self.get_process_output, category="execute", read_only=True, idempotent=True
@@ -71,151 +68,6 @@ class ExecutionEnvironmentTools(ResourceProvider):
             ),
         ]
 
-    async def execute_code(self, agent_ctx: AgentContext, code: str) -> str:  # noqa: D417
-        """Execute Python code and return the result.
-
-        Args:
-            code: Python code to execute
-        """
-        process_id: str | None = None
-        output_parts: list[str] = []
-        exit_code: int | None = None
-        error_msg: str | None = None
-        try:
-            async for event in self.get_env(agent_ctx).stream_code(code):
-                match event:
-                    case ProcessStartedEvent(process_id=pid, command=cmd):
-                        process_id = pid  # save for later on.
-                        await agent_ctx.events.process_started(pid, cmd, success=True)
-                    case OutputEvent(data=data):
-                        output_parts.append(data)
-                        if process_id:
-                            await agent_ctx.events.process_output(process_id, data)
-                    case ProcessCompletedEvent(exit_code=code_):
-                        exit_code = code_
-                        out = "".join(output_parts)
-                        if process_id:
-                            await agent_ctx.events.process_exit(
-                                process_id, exit_code, final_output=out
-                            )
-                    case ProcessErrorEvent(error=err, exit_code=code_):
-                        error_msg = err
-                        exit_code = code_
-                        if process_id:
-                            await agent_ctx.events.process_exit(
-                                process_id, exit_code or 1, final_output=err
-                            )
-
-            combined_output = "".join(output_parts)
-
-            # Format as plain text for LLM
-            if error_msg:
-                return f"{combined_output}\n\nError: {error_msg}\nExit code: {exit_code}"
-
-        except Exception as e:  # noqa: BLE001
-            error_id = process_id or f"code_{uuid.uuid4().hex[:8]}"
-            await agent_ctx.events.process_started(
-                error_id, "execute_code", success=False, error=str(e)
-            )
-            return f"Error executing code: {e}"
-        else:
-            # Return just output if success, add exit code only if non-zero
-            if exit_code and exit_code != 0:
-                return f"{combined_output}\n\nExit code: {exit_code}"
-            return combined_output
-
-    async def bash(  # noqa: PLR0915, D417
-        self,
-        agent_ctx: AgentContext,
-        command: str,
-        output_limit: int | None = None,
-    ) -> str:
-        """Execute a shell command and return the output.
-
-        Args:
-            command: Shell command to execute
-            output_limit: Maximum bytes of output to return
-        """
-        # process_id comes from exxec events (is terminal_id when using ACP)
-        process_id: str | None = None
-        stdout_parts: list[str] = []
-        stderr_parts: list[str] = []
-        exit_code: int | None = None
-        error_msg: str | None = None
-        try:
-            async for event in self.get_env(agent_ctx).stream_command(command):
-                match event:
-                    case ProcessStartedEvent(process_id=pid, command=cmd):
-                        process_id = pid
-                        if pid:
-                            await agent_ctx.events.process_started(pid, cmd, success=True)
-                        else:
-                            logger.warning("ProcessStartedEvent missing process_id", command=cmd)
-                    case OutputEvent(process_id=pid, data=data, stream=stream):
-                        if stream == "stderr":
-                            stderr_parts.append(data)
-                        else:
-                            stdout_parts.append(data)
-                        if pid:
-                            await agent_ctx.events.process_output(pid, data)
-                        else:
-                            logger.warning("OutputEvent missing process_id", stream=stream)
-                    case ProcessCompletedEvent(process_id=pid, exit_code=code_):
-                        exit_code = code_
-                        combined = "".join(stdout_parts) + "".join(stderr_parts)
-                        if pid:
-                            await agent_ctx.events.process_exit(
-                                pid, exit_code, final_output=combined
-                            )
-                        else:
-                            msg = "ProcessCompletedEvent missing process_id,"
-                            logger.warning(msg, exit_code=code_)
-                    case ProcessErrorEvent(process_id=pid, error=err, exit_code=code_):
-                        error_msg = err
-                        exit_code = code_
-
-            stdout = "".join(stdout_parts)
-            stderr = "".join(stderr_parts)
-
-            # Apply output limit if specified
-            truncated = False
-            if output_limit:
-                if len(stdout.encode()) > output_limit:
-                    out = stdout.encode()[-output_limit:].decode(errors="ignore")
-                    stdout = "...[truncated]\n" + out
-                    truncated = True
-                if len(stderr.encode()) > output_limit:
-                    out = stderr.encode()[-output_limit:].decode(errors="ignore")
-                    stderr = "...[truncated]\n" + out
-                    truncated = True
-
-            # Format as plain text for LLM
-            if error_msg:
-                output = stdout + stderr if stdout or stderr else ""
-                return f"{output}\n\nError: {error_msg}\nExit code: {exit_code}"
-
-        except Exception as e:  # noqa: BLE001
-            # Use process_id from events if available, otherwise generate fallback
-            error_id = process_id or f"cmd_{uuid.uuid4().hex[:8]}"
-            await agent_ctx.events.process_started(error_id, command, success=False, error=str(e))
-            return f"Error executing command: {e}"
-        else:
-            # Combine stdout and stderr for output
-            output = stdout
-            if stderr:
-                output = f"{stdout}\n\nSTDERR:\n{stderr}" if stdout else f"STDERR:\n{stderr}"
-
-            # Add metadata only when relevant
-            suffix_parts = []
-            if truncated:
-                suffix_parts.append("[output truncated]")
-            if exit_code and exit_code != 0:
-                suffix_parts.append(f"Exit code: {exit_code}")
-
-            if suffix_parts:
-                return f"{output}\n\n{' | '.join(suffix_parts)}"
-            return output
-
     async def start_process(  # noqa: D417
         self,
         agent_ctx: AgentContext,
@@ -252,11 +104,18 @@ class ExecutionEnvironmentTools(ResourceProvider):
             full_cmd = f"{command} {' '.join(args)}" if args else command
             return f"Started background process {process_id}\nCommand: {full_cmd}"
 
-    async def get_process_output(self, agent_ctx: AgentContext, process_id: str) -> str:  # noqa: D417
+    async def get_process_output(  # noqa: D417
+        self,
+        agent_ctx: AgentContext,
+        process_id: str,
+        filter_lines: str | None = None,
+    ) -> str:
         """Get current output from a background process.
 
         Args:
             process_id: Process identifier from start_process
+            filter_lines: Optional regex pattern to filter output lines
+                          (only matching lines returned)
         """
         manager = self.get_env(agent_ctx).process_manager
         try:
@@ -264,6 +123,18 @@ class ExecutionEnvironmentTools(ResourceProvider):
             await agent_ctx.events.process_output(process_id, output.combined or "")
 
             combined = output.combined or ""
+
+            # Apply regex filter if specified
+            if filter_lines and combined:
+                try:
+                    pattern = re.compile(filter_lines)
+                    filtered_lines = [
+                        line for line in combined.splitlines(keepends=True) if pattern.search(line)
+                    ]
+                    combined = "".join(filtered_lines)
+                except re.error as regex_err:
+                    return f"Invalid filter regex: {regex_err}"
+
             status = "completed" if output.exit_code is not None else "running"
 
             # Format as plain text
@@ -283,11 +154,18 @@ class ExecutionEnvironmentTools(ResourceProvider):
         except Exception as e:  # noqa: BLE001
             return f"Error getting process output: {e}"
 
-    async def wait_for_process(self, agent_ctx: AgentContext, process_id: str) -> str:  # noqa: D417
+    async def wait_for_process(  # noqa: D417
+        self,
+        agent_ctx: AgentContext,
+        process_id: str,
+        filter_lines: str | None = None,
+    ) -> str:
         """Wait for background process to complete and return final output.
 
         Args:
             process_id: Process identifier from start_process
+            filter_lines: Optional regex pattern to filter output lines
+                          (only matching lines returned)
         """
         manager = self.get_env(agent_ctx).process_manager
         try:
@@ -301,6 +179,17 @@ class ExecutionEnvironmentTools(ResourceProvider):
         else:
             combined = output.combined or ""
 
+            # Apply regex filter if specified
+            if filter_lines and combined:
+                try:
+                    pattern = re.compile(filter_lines)
+                    filtered_lines = [
+                        line for line in combined.splitlines(keepends=True) if pattern.search(line)
+                    ]
+                    combined = "".join(filtered_lines)
+                except re.error as regex_err:
+                    return f"Invalid filter regex: {regex_err}"
+
             # Format as plain text
             suffix_parts = []
             if output.truncated:

agentpool_toolsets/builtin/skills.py

@@ -59,77 +59,6 @@ async def list_skills(ctx: AgentContext) -> str:
     return "\n".join(lines)
 
 
-class _StringOutputWriter:
-    """Output writer that captures output to a string buffer."""
-
-    def __init__(self) -> None:
-        from io import StringIO
-
-        self._buffer = StringIO()
-
-    async def print(self, message: str) -> None:
-        """Write a message to the buffer."""
-        self._buffer.write(message)
-        self._buffer.write("\n")
-
-    def getvalue(self) -> str:
-        """Get the captured output."""
-        return self._buffer.getvalue()
-
-
-async def run_command(ctx: AgentContext, command: str) -> str:  # noqa: D417
-    """Execute an internal command.
-
-    This provides access to the agent's internal CLI for management operations.
-
-    IMPORTANT: Before using any command for the first time, call "help <command>" to learn
-    the correct syntax and available options. Commands have specific argument orders and
-    flags that must be followed exactly.
-
-    Discovery commands:
-    - "help" - list all available commands
-    - "help <command>" - get detailed usage for a specific command (ALWAYS do this first!)
-
-    Command categories:
-    - Agent/team management: create-agent, create-team, list-agents
-    - Tool management: list-tools, register-tool, enable-tool, disable-tool
-    - MCP servers: add-mcp-server, add-remote-mcp-server, list-mcp-servers
-    - Connections: connect, disconnect, connections
-    - Workers: add-worker, remove-worker, list-workers
-
-    Args:
-        command: The command to execute. Leading slash is optional.
-
-    Returns:
-        Command output or error message
-    """
-    from slashed import CommandContext
-
-    if not ctx.agent.command_store:
-        return "No command store available"
-
-    # Remove leading slash if present (slashed expects command name without /)
-    cmd = command.lstrip("/")
-
-    # Create output capture
-    output = _StringOutputWriter()
-
-    # Create CommandContext with output capture and AgentContext as data
-    cmd_ctx = CommandContext(
-        output=output,
-        data=ctx,
-        command_store=ctx.agent.command_store,
-    )
-
-    try:
-        await ctx.agent.command_store.execute_command(cmd, cmd_ctx)
-        result = output.getvalue()
-    except Exception as e:  # noqa: BLE001
-        return f"Command failed: {e}"
-    else:
-        return result if result else "Command executed successfully."
-
-
 class SkillsTools(StaticResourceProvider):
     """Provider for skills and commands tools.
 
@@ -150,10 +79,4 @@ class SkillsTools(StaticResourceProvider):
         self._tools = [
             self.create_tool(load_skill, category="read", read_only=True, idempotent=True),
             self.create_tool(list_skills, category="read", read_only=True, idempotent=True),
-            self.create_tool(
-                run_command,
-                category="other",
-                read_only=False,
-                idempotent=False,
-            ),
         ]