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

agentpool/resource_providers/base.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Self
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal, Self
+
+from anyenv.signals import Signal
 
 from agentpool.log import get_logger
 from agentpool.tools.base import Tool
@@ -10,34 +13,88 @@ from agentpool_config.tools import ToolHints
 
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Sequence
     from types import TracebackType
 
+    from fsspec.asyn import AsyncFileSystem
     from pydantic_ai import ModelRequestPart
     from schemez import OpenAIFunctionDefinition
 
     from agentpool.prompts.prompts import BasePrompt
+    from agentpool.resource_providers.resource_info import ResourceInfo
     from agentpool.skills.skill import Skill
     from agentpool.tools.base import ToolKind
-    from agentpool_config.resources import ResourceInfo
 
 
 logger = get_logger(__name__)
 
 
+ResourceType = Literal["tools", "prompts", "resources", "skills"]
+ProviderKind = Literal[
+    "base", "mcp", "mcp_run", "tools", "prompts", "skills", "aggregating", "custom"
+]
+
+
+@dataclass(frozen=True, slots=True)
+class ResourceChangeEvent:
+    """Event emitted when resources change in a provider.
+
+    Attributes:
+        provider_name: Name of the provider instance
+        provider_kind: Kind/type of the provider (e.g., "mcp", "tools")
+        resource_type: Type of resource that changed
+        owner: Optional owner of the provider (e.g., agent name)
+    """
+
+    provider_name: str
+    provider_kind: ProviderKind
+    resource_type: ResourceType
+    owner: str | None = None
+
+
 class ResourceProvider:
     """Base class for resource providers.
 
     Provides tools, prompts, and other resources to agents.
     Default implementations return empty lists - override as needed.
+
+    Class Attributes:
+        kind: Short slug identifying the provider type (e.g., "mcp", "tools")
+
+    Change signals (using anyenv.signals.Signal):
+        - tools_changed: Emitted when tools change
+        - prompts_changed: Emitted when prompts change
+        - resources_changed: Emitted when resources change
+        - skills_changed: Emitted when skills change
+
+    Example:
+        provider.tools_changed.connect(my_handler)
+        await provider.tools_changed.emit(provider.create_change_event("tools"))
     """
 
+    kind: ProviderKind = "base"
+
+    # Change signals - emit ResourceChangeEvent when resources change
+    tools_changed: Signal[ResourceChangeEvent] = Signal()
+    prompts_changed: Signal[ResourceChangeEvent] = Signal()
+    resources_changed: Signal[ResourceChangeEvent] = Signal()
+    skills_changed: Signal[ResourceChangeEvent] = Signal()
+
     def __init__(self, name: str, owner: str | None = None) -> None:
         """Initialize the resource provider."""
         self.name = name
         self.owner = owner
         self.log = logger.bind(name=self.name, owner=self.owner)
 
+    def create_change_event(self, resource_type: ResourceType) -> ResourceChangeEvent:
+        """Create a ResourceChangeEvent for this provider."""
+        return ResourceChangeEvent(
+            provider_name=self.name,
+            provider_kind=self.kind,
+            resource_type=resource_type,
+            owner=self.owner,
+        )
+
     async def __aenter__(self) -> Self:
         """Async context entry if required."""
         return self
@@ -53,7 +110,7 @@ class ResourceProvider:
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(name={self.name!r})"
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get available tools. Override to provide tools."""
         return []
 
@@ -78,6 +135,15 @@ class ResourceProvider:
         """Get available skills. Override to provide skills."""
         return []
 
+    def get_fs(self) -> AsyncFileSystem | None:
+        """Get filesystem view of provider state/history.
+
+        Returns:
+            AsyncFileSystem or None if not supported.
+            Override to expose provider state through filesystem interface.
+        """
+        return None
+
     async def get_skill_instructions(self, skill_name: str) -> str:
         """Get full instructions for a specific skill.
 

agentpool/resource_providers/codemode/code_executor.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import asyncio
 import contextlib
 from dataclasses import dataclass
+from datetime import UTC, datetime
+import json
 from typing import TYPE_CHECKING, Any, Self
 
 import anyio
@@ -18,9 +20,10 @@ if TYPE_CHECKING:
     from types import TracebackType
 
     from exxec.base import ExecutionEnvironment
-    from exxec.configs import ExecutionEnvironmentConfig
     from exxec.models import ServerInfo
+    from exxec_config import ExecutionEnvironmentConfig
     from fastapi import FastAPI
+    from fsspec.asyn import AsyncFileSystem
     from schemez import ToolsetCodeGenerator
     import uvicorn
 
@@ -46,6 +49,14 @@ class RemoteCodeExecutor:
     execution_env: ExecutionEnvironment
     """Execution environment for running code."""
 
+    def __post_init__(self) -> None:
+        """Initialize filesystem for script history after dataclass init."""
+        from fsspec.implementations.asyn_wrapper import AsyncFileSystemWrapper
+        from fsspec.implementations.memory import MemoryFileSystem
+
+        self._memory_fs = MemoryFileSystem()
+        self._fs = AsyncFileSystemWrapper(self._memory_fs)
+
     @classmethod
     def from_tools(
         cls,
@@ -78,16 +89,70 @@ class RemoteCodeExecutor:
         """Get comprehensive description of available tools."""
         return self.toolset_generator.generate_tool_description()
 
-    async def execute_code(self, code: str) -> Any:
+    def get_fs(self) -> AsyncFileSystem:
+        """Get filesystem view of script history.
+
+        Returns:
+            AsyncFileSystem containing:
+            - scripts/{timestamp}_{title}.py - Executed scripts
+            - scripts/{timestamp}_{title}.json - Execution metadata
+        """
+        return self._fs
+
+    async def execute_code(self, code: str, title: str) -> Any:
         """Execute code with tools available via HTTP API.
 
         Args:
             code: Python code to execute
+            title: Short descriptive title for this script (3-4 words)
 
         Returns:
             Execution result from the environment
         """
-        return await self.execution_env.execute(code)
+        start_time = datetime.now(UTC)
+        exit_code = 0
+        error_msg: str | None = None
+        exec_result = None
+        result_str = ""
+
+        try:
+            exec_result = await self.execution_env.execute(code)
+            result_str = str(exec_result)
+            # Check if execution failed
+            if (
+                hasattr(exec_result, "exit_code")
+                and exec_result.exit_code is not None
+                and exec_result.exit_code != 0
+            ):
+                exit_code = exec_result.exit_code
+                error_msg = getattr(exec_result, "error", None)
+        except Exception as e:  # noqa: BLE001
+            exit_code = 1
+            error_msg = str(e)
+            result_str = f"Error executing code: {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 exec_result
 
     async def __aenter__(self) -> Self:
         """Async context manager entry."""
@@ -196,7 +261,7 @@ class ToolServerLifecycleHandler:
 
 
 if __name__ == "__main__":
-    from exxec.configs import LocalExecutionEnvironmentConfig
+    from exxec_config import LocalExecutionEnvironmentConfig
 
     from agentpool.tools.base import Tool
 
@@ -209,7 +274,9 @@ if __name__ == "__main__":
         config = LocalExecutionEnvironmentConfig()
         provider = RemoteCodeExecutor.from_tools(tools, config, server_port=9876)
         async with provider:
-            result = await provider.execute_code("_result = await add_numbers(5, 3)")
+            result = await provider.execute_code(
+                "_result = await add_numbers(5, 3)", title="test_addition"
+            )
             print(f"Result: {result.result}")
 
     anyio.run(main)

agentpool/resource_providers/codemode/helpers.py

@@ -69,13 +69,13 @@ def tools_to_codegen(
     generators = [
         ToolCodeGenerator(
             schema=create_schema(
-                t.callable,
+                t.get_callable(),
                 name_override=t.name,
                 description_override=t.description,
                 mode="openai",
                 exclude_types=[AgentContext, RunContext],
             ),
-            callable=t.callable,
+            callable=t.get_callable(),
             name_override=t.name,
         )
         for t in tools

agentpool/resource_providers/codemode/provider.py

@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+from datetime import UTC, datetime
 from functools import partial
 import inspect
+import json
 from typing import TYPE_CHECKING, Any
 
 from agentpool.agents.context import AgentContext  # noqa: TC001
@@ -17,6 +19,9 @@ from agentpool_toolsets.fsspec_toolset.toolset import FSSpecTools
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from fsspec.asyn import AsyncFileSystem
     from schemez import ToolsetCodeGenerator
 
     from agentpool.resource_providers import ResourceProvider
@@ -46,7 +51,14 @@ class CodeModeResourceProvider(AggregatingResourceProvider):
         self._cached_tool: Tool | None = None
         self.usage_notes = usage_notes
 
-    async def get_tools(self) -> list[Tool]:
+        # Filesystem for script history
+        from fsspec.implementations.asyn_wrapper import AsyncFileSystemWrapper
+        from fsspec.implementations.memory import MemoryFileSystem
+
+        self._memory_fs = MemoryFileSystem()
+        self._fs = AsyncFileSystemWrapper(self._memory_fs)
+
+    async def get_tools(self) -> Sequence[Tool]:
         """Return single meta-tool for Python execution with available tools."""
         # Always generate fresh toolset to reflect current tools
         toolset_generator = await self._get_code_generator()
@@ -55,9 +67,9 @@ class CodeModeResourceProvider(AggregatingResourceProvider):
 
         if self._cached_tool is None:
             # Create a closure that captures self but isn't a bound method
-            async def execute_tool(ctx: AgentContext, python_code: str) -> Any:
+            async def execute_tool(ctx: AgentContext, python_code: str, title: str) -> Any:
                 """These docstings are overriden by description_override."""
-                return await self.execute(ctx, python_code)
+                return await self.execute(ctx, python_code, title)
 
             self._cached_tool = self.create_tool(execute_tool, description_override=desc)
         else:
@@ -66,11 +78,12 @@ class CodeModeResourceProvider(AggregatingResourceProvider):
 
         return [self._cached_tool]
 
-    async def execute(self, ctx: AgentContext, python_code: str) -> Any:  # noqa: D417
+    async def execute(self, ctx: AgentContext, python_code: str, title: str) -> Any:  # noqa: D417
         """Execute Python code with all wrapped tools available as functions.
 
         Args:
             python_code: Python code to execute
+            title: Short descriptive title for this script (3-4 words)
 
         Returns:
             Result of the last expression or explicit return value
@@ -93,18 +106,47 @@ class CodeModeResourceProvider(AggregatingResourceProvider):
         # namespace["report_progress"] = NamespaceCallable(report_progress)
 
         validate_code(python_code)
+        start_time = datetime.now(UTC)
+        exit_code = 0
+        error_msg = None
+        result_value = None
+
         try:
             exec(python_code, namespace)
-            result = await namespace["main"]()
+            result_value = await namespace["main"]()
             # Handle edge cases with coroutines and return values
-            if inspect.iscoroutine(result):
-                result = await result
-            if not result:  # in order to not confuse the model, return a success message.
-                return "Code executed successfully"
+            if inspect.iscoroutine(result_value):
+                result_value = await result_value
+
+            if not result_value:  # in order to not confuse the model, return a success message.
+                result_value = "Code executed successfully"
         except Exception as e:  # noqa: BLE001
-            return f"Error executing code: {e!s}"
-        else:
-            return result
+            exit_code = 1
+            error_msg = f"{e!s}"
+            result_value = f"Error executing code: {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, python_code.encode("utf-8"))
+
+            # Write metadata file
+            metadata = {
+                "title": title,
+                "timestamp": start_time.isoformat(),
+                "exit_code": exit_code,
+                "duration": duration,
+                "result": str(result_value),
+                "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_value
 
     def invalidate_cache(self) -> None:
         """Invalidate cached tool when providers change."""
@@ -116,6 +158,16 @@ class CodeModeResourceProvider(AggregatingResourceProvider):
         tools = await super().get_tools()
         return tools_to_codegen(tools=tools, include_docstrings=self.include_docstrings)
 
+    def get_fs(self) -> AsyncFileSystem:
+        """Get filesystem view of script history.
+
+        Returns:
+            AsyncFileSystem containing:
+            - scripts/{timestamp}_{title}.py - Executed scripts
+            - scripts/{timestamp}_{title}.json - Execution metadata
+        """
+        return self._fs
+
 
 if __name__ == "__main__":
     import anyio

agentpool/resource_providers/codemode/remote_mcp_execution.py

@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from types import TracebackType
 
     from exxec.base import ExecutionEnvironment
-    from exxec.configs import ExecutionEnvironmentConfig
+    from exxec_config import ExecutionEnvironmentConfig
     from schemez import ToolsetCodeGenerator
 
     from agentpool.tools.base import Tool
@@ -103,7 +103,7 @@ class RemoteMCPExecutor:
 
 if __name__ == "__main__":
     import anyio
-    from exxec.configs import LocalExecutionEnvironmentConfig
+    from exxec_config import LocalExecutionEnvironmentConfig
 
     from agentpool.tools.base import Tool
 

agentpool/resource_providers/codemode/remote_provider.py

@@ -6,7 +6,7 @@ import asyncio
 import contextlib
 from typing import TYPE_CHECKING, Any, Self
 
-from exxec.configs import LocalExecutionEnvironmentConfig
+from exxec_config import LocalExecutionEnvironmentConfig
 
 from agentpool.agents.context import AgentContext  # noqa: TC001
 from agentpool.log import get_logger
@@ -26,7 +26,7 @@ logger = get_logger(__name__)
 if TYPE_CHECKING:
     from types import TracebackType
 
-    from exxec.configs import ExecutionEnvironmentConfig
+    from exxec_config import ExecutionEnvironmentConfig
 
     from agentpool.resource_providers import ResourceProvider
 
@@ -75,11 +75,12 @@ class RemoteCodeModeResourceProvider(CodeModeResourceProvider):
         self._code_executor: RemoteCodeExecutor | None = None
         self._provider_lock = asyncio.Lock()
 
-    async def execute(self, ctx: AgentContext, python_code: str) -> Any:  # noqa: D417
+    async def execute(self, ctx: AgentContext, python_code: str, title: str) -> Any:  # noqa: D417
         """Execute Python code in secure environment with tools available via HTTP.
 
         Args:
             python_code: Python code to execute
+            title: Short descriptive title for this script (3-4 words)
 
         Returns:
             Result of the code execution
@@ -90,16 +91,12 @@ class RemoteCodeModeResourceProvider(CodeModeResourceProvider):
         full_code = f"{PROGRESS_HELPER}\n\n{python_code}"
         logger.info("Complete code", code=full_code)
         try:
-            result = await code_provider.execution_env.execute(full_code)
-            if result.success:
-                logger.info("Code executed successfully")
-                if result.result is None:
-                    return "Code executed successfully"
-                return result.result
+            result = await code_provider.execute_code(full_code, title)
         except Exception as e:  # noqa: BLE001
             return f"Error in secure execution: {e!s}"
         else:
-            return f"Error executing code: {result.error}"
+            logger.info("Code executed")
+            return result
 
     async def _get_code_executor(self) -> RemoteCodeExecutor:
         """Get cached code execution provider with thread-safe initialization."""
@@ -139,7 +136,7 @@ if __name__ == "__main__":
     import webbrowser
 
     import anyio
-    from exxec.configs import LocalExecutionEnvironmentConfig
+    from exxec_config import LocalExecutionEnvironmentConfig
 
     from agentpool import Agent, log
     from agentpool.resource_providers import StaticResourceProvider
@@ -153,7 +150,7 @@ if __name__ == "__main__":
     async def main() -> None:
         tools = [Tool.from_callable(open_browser)]
         static_provider = StaticResourceProvider(tools=tools)
-        config = LocalExecutionEnvironmentConfig(timeout=30.0)
+        config = LocalExecutionEnvironmentConfig(default_command_timeout=30.0)
         provider = RemoteCodeModeResourceProvider(
             providers=[static_provider],
             execution_config=config,

agentpool/resource_providers/filtering.py

@@ -8,6 +8,8 @@ from agentpool.resource_providers import ResourceProvider
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from agentpool.tools.base import Tool
 
 
@@ -32,7 +34,7 @@ class FilteringResourceProvider(ResourceProvider):
         """Delegate attribute access to wrapped provider."""
         return getattr(self._provider, name)
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get filtered tools from wrapped provider.
 
         Returns only tools where the filter value is True. Tools not in the filter