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

agentpool/resource_providers/aggregating.py

@@ -8,11 +8,13 @@ from agentpool.resource_providers.base import ResourceChangeEvent, ResourceProvi
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from pydantic_ai import ModelRequestPart
 
     from agentpool.prompts.prompts import BasePrompt
+    from agentpool.resource_providers.resource_info import ResourceInfo
     from agentpool.tools.base import Tool
-    from agentpool_config.resources import ResourceInfo
 
 _ = ResourceChangeEvent  # Used at runtime in method signatures
 
@@ -78,7 +80,7 @@ class AggregatingResourceProvider(ResourceProvider):
         """Forward skills_changed signal from child provider."""
         await self.skills_changed.emit(event)
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get tools from all providers."""
         return [t for provider in self.providers for t in await provider.get_tools()]
 

agentpool/resource_providers/base.py

@@ -13,16 +13,17 @@ 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__)
@@ -109,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 []
 
@@ -134,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

agentpool/resource_providers/mcp_provider.py

@@ -8,17 +8,19 @@ from typing import TYPE_CHECKING, Any, Self
 
 from agentpool.log import get_logger
 from agentpool.resource_providers import ResourceProvider
+from agentpool.resource_providers.resource_info import ResourceInfo
 from agentpool_config.mcp_server import BaseMCPServerConfig
-from agentpool_config.resources import ResourceInfo
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from typing import Literal
 
     from fastmcp.client.sampling import SamplingHandler
+    from mcp.types import ResourceTemplate
 
     from agentpool.prompts.prompts import MCPClientPrompt
-    from agentpool.tools.base import Tool
+    from agentpool.tools.base import FunctionTool, Tool
     from agentpool_config.mcp_server import MCPServerConfig
 
 
@@ -45,19 +47,14 @@ class MCPResourceProvider(ResourceProvider):
         self.server = BaseMCPServerConfig.from_string(server) if isinstance(server, str) else server
         self.source = source
         self.exit_stack = AsyncExitStack()
+
         self._accessible_roots = accessible_roots
         self._sampling_callback = sampling_callback
 
-        # Tool caching
-        self._tools_cache: list[Tool] | None = None
         self._saved_enabled_states: dict[str, bool] = {}
-
-        # Prompt caching
+        self._tools_cache: list[FunctionTool] | None = None
         self._prompts_cache: list[MCPClientPrompt] | None = None
-
-        # Resource caching
         self._resources_cache: list[ResourceInfo] | None = None
-
         self.client = MCPClient(
             config=self.server,
             sampling_callback=self._sampling_callback,
@@ -128,7 +125,7 @@ class MCPResourceProvider(ResourceProvider):
         try:
             # Get fresh tools from client
             mcp_tools = await self.client.list_tools()
-            all_tools: list[Tool] = []
+            all_tools: list[FunctionTool] = []
 
             for tool in mcp_tools:
                 try:
@@ -149,7 +146,7 @@ class MCPResourceProvider(ResourceProvider):
             logger.exception("Failed to refresh MCP tools cache")
             self._tools_cache = []
 
-    async def get_tools(self) -> list[Tool]:
+    async def get_tools(self) -> Sequence[Tool]:
         """Get cached tools, refreshing if necessary."""
         if self._tools_cache is None:
             await self.refresh_tools_cache()
@@ -193,7 +190,11 @@ class MCPResourceProvider(ResourceProvider):
 
             for resource in result:
                 try:
-                    converted = await ResourceInfo.from_mcp_resource(resource)
+                    converted = await ResourceInfo.from_mcp_resource(
+                        resource,
+                        client_name=self.name,
+                        reader=self.read_resource,
+                    )
                     all_resources.append(converted)
                 except Exception:
                     logger.exception("Failed to convert resource", name=resource.name)
@@ -212,6 +213,59 @@ class MCPResourceProvider(ResourceProvider):
 
         return self._resources_cache or []
 
+    async def read_resource(self, uri: str) -> list[str]:
+        """Read resource content by URI.
+
+        Args:
+            uri: URI of the resource to read
+
+        Returns:
+            List of text contents from the resource
+
+        Raises:
+            RuntimeError: If resource cannot be read
+        """
+        contents = await self.client.read_resource(uri)
+        result: list[str] = []
+        for content in contents:
+            if hasattr(content, "text") and content.text is not None:
+                result.append(str(content.text))
+            elif hasattr(content, "blob") and content.blob is not None:
+                # Binary content - return placeholder or base64
+                import base64
+
+                blob_data = content.blob
+                if isinstance(blob_data, str):
+                    result.append(f"[Binary data: {len(blob_data)} bytes]")
+                elif isinstance(blob_data, bytes):
+                    encoded = base64.b64encode(blob_data).decode("utf-8")
+                    result.append(encoded)
+                else:
+                    result.append("[Binary data: unknown format]")
+        return result
+
+    async def list_resource_templates(self) -> list[ResourceTemplate]:
+        """Get available resource templates from the MCP server.
+
+        Resource templates define URI patterns with placeholders that can be
+        expanded into concrete resource URIs. For example:
+        - Template: "file:///{path}" with path="config.json"
+        - Expands to: "file:///config.json"
+
+        TODO: Decide on integration strategy:
+        - Option 1: Templates as separate concept with expand() -> ResourceInfo
+        - Option 2: Unified ResourceInfo with is_template flag and read(**kwargs)
+        - Option 3: ResourceTemplateInfo class that produces ResourceInfo
+
+        Returns:
+            List of ResourceTemplate objects from the server
+        """
+        try:
+            return await self.client.list_resource_templates()
+        except Exception:
+            logger.exception("Failed to list resource templates")
+            return []
+
     def get_status(self) -> dict[str, str]:
         """Get connection status for this MCP server.