agentpool 2.1.9__py3-none-any.whl

agentpool/resource_providers/__init__.py

@@ -0,0 +1,17 @@
+"""Resource provider implementations."""
+
+from agentpool.resource_providers.base import ResourceProvider
+from agentpool.resource_providers.static import StaticResourceProvider
+from agentpool.resource_providers.filtering import FilteringResourceProvider
+from agentpool.resource_providers.aggregating import AggregatingResourceProvider
+from agentpool.resource_providers.mcp_provider import MCPResourceProvider
+from agentpool.resource_providers.plan_provider import PlanProvider
+
+__all__ = [
+    "AggregatingResourceProvider",
+    "FilteringResourceProvider",
+    "MCPResourceProvider",
+    "PlanProvider",
+    "ResourceProvider",
+    "StaticResourceProvider",
+]

agentpool/resource_providers/aggregating.py

@@ -0,0 +1,54 @@
+"""Aggregating resource provider."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from agentpool.resource_providers import ResourceProvider
+
+
+if TYPE_CHECKING:
+    from pydantic_ai import ModelRequestPart
+
+    from agentpool.prompts.prompts import BasePrompt
+    from agentpool.tools.base import Tool
+    from agentpool_config.resources import ResourceInfo
+
+
+class AggregatingResourceProvider(ResourceProvider):
+    """Provider that combines resources from multiple providers."""
+
+    def __init__(self, providers: list[ResourceProvider], name: str = "aggregating") -> None:
+        """Initialize provider with list of providers to aggregate.
+
+        Args:
+            providers: Resource providers to aggregate (stores reference to list)
+            name: Name for this provider
+        """
+        super().__init__(name=name)
+        # Store reference to the providers list for dynamic updates
+        self.providers = providers
+
+    async def get_tools(self) -> list[Tool]:
+        """Get tools from all providers."""
+        return [t for provider in self.providers for t in await provider.get_tools()]
+
+    async def get_prompts(self) -> list[BasePrompt]:
+        """Get prompts from all providers."""
+        return [p for provider in self.providers for p in await provider.get_prompts()]
+
+    async def get_resources(self) -> list[ResourceInfo]:
+        """Get resources from all providers."""
+        return [r for provider in self.providers for r in await provider.get_resources()]
+
+    async def get_request_parts(
+        self, name: str, arguments: dict[str, str] | None = None
+    ) -> list[ModelRequestPart]:
+        """Try to get prompt from first provider that has it."""
+        for provider in self.providers:
+            try:
+                return await provider.get_request_parts(name, arguments)
+            except KeyError:
+                continue
+        msg = f"Prompt {name!r} not found in any provider"
+        raise KeyError(msg)

agentpool/resource_providers/base.py

@@ -0,0 +1,172 @@
+"""Base resource provider interface."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Self
+
+from agentpool.log import get_logger
+from agentpool.tools.base import Tool
+from agentpool_config.tools import ToolHints
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import TracebackType
+
+    from pydantic_ai import ModelRequestPart
+    from schemez import OpenAIFunctionDefinition
+
+    from agentpool.prompts.prompts import BasePrompt
+    from agentpool.skills.skill import Skill
+    from agentpool.tools.base import ToolKind
+    from agentpool_config.resources import ResourceInfo
+
+
+logger = get_logger(__name__)
+
+
+class ResourceProvider:
+    """Base class for resource providers.
+
+    Provides tools, prompts, and other resources to agents.
+    Default implementations return empty lists - override as needed.
+    """
+
+    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)
+
+    async def __aenter__(self) -> Self:
+        """Async context entry if required."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Async context cleanup if required."""
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name!r})"
+
+    async def get_tools(self) -> list[Tool]:
+        """Get available tools. Override to provide tools."""
+        return []
+
+    async def get_tool(self, tool_name: str) -> Tool:
+        """Get specific tool."""
+        tools = await self.get_tools()
+        for tool in tools:
+            if tool.name == tool_name:
+                return tool
+        msg = f"Tool {tool_name!r} not found"
+        raise ValueError(msg)
+
+    async def get_prompts(self) -> list[BasePrompt]:
+        """Get available prompts. Override to provide prompts."""
+        return []
+
+    async def get_resources(self) -> list[ResourceInfo]:
+        """Get available resources. Override to provide resources."""
+        return []
+
+    async def get_skills(self) -> list[Skill]:
+        """Get available skills. Override to provide skills."""
+        return []
+
+    async def get_skill_instructions(self, skill_name: str) -> str:
+        """Get full instructions for a specific skill.
+
+        Args:
+            skill_name: Name of the skill to get instructions for
+
+        Returns:
+            The full skill instructions for execution
+
+        Raises:
+            KeyError: If skill not found
+        """
+        msg = f"Skill {skill_name!r} not found"
+        raise KeyError(msg)
+
+    async def get_request_parts(
+        self, name: str, arguments: dict[str, str] | None = None
+    ) -> list[ModelRequestPart]:
+        """Get a prompt formatted with arguments.
+
+        Args:
+            name: Name of the prompt to format
+            arguments: Optional arguments for prompt formatting
+
+        Returns:
+            Single chat message with merged content
+
+        Raises:
+            KeyError: If prompt not found
+            ValueError: If formatting fails
+        """
+        prompts = await self.get_prompts()
+        prompt = next((p for p in prompts if p.name == name), None)
+        if not prompt:
+            msg = f"Prompt {name!r} not found"
+            raise KeyError(msg)
+
+        messages = await prompt.format(arguments or {})
+        if not messages:
+            msg = f"Prompt {name!r} produced no messages"
+            raise ValueError(msg)
+
+        return [p for prompt_msg in messages for p in prompt_msg.to_pydantic_parts()]
+
+    def create_tool(
+        self,
+        fn: Callable[..., Any],
+        read_only: bool | None = None,
+        destructive: bool | None = None,
+        idempotent: bool | None = None,
+        open_world: bool | None = None,
+        requires_confirmation: bool = False,
+        metadata: dict[str, Any] | None = None,
+        category: ToolKind | None = None,
+        name_override: str | None = None,
+        description_override: str | None = None,
+        schema_override: OpenAIFunctionDefinition | None = None,
+    ) -> Tool:
+        """Create a tool from a function.
+
+        Args:
+            fn: Function to create a tool from
+            read_only: Whether the tool is read-only
+            destructive: Whether the tool is destructive
+            idempotent: Whether the tool is idempotent
+            open_world: Whether the tool is open-world
+            requires_confirmation: Whether the tool requires confirmation
+            metadata: Metadata for the tool
+            category: Category of the tool
+            name_override: Override the name of the tool
+            description_override: Override the description of the tool
+            schema_override: Override the schema of the tool
+
+        Returns:
+            Tool created from the function
+        """
+        return Tool.from_callable(
+            fn=fn,
+            category=category,
+            source=self.name,
+            requires_confirmation=requires_confirmation,
+            metadata=metadata,
+            name_override=name_override,
+            description_override=description_override,
+            schema_override=schema_override,
+            hints=ToolHints(
+                read_only=read_only,
+                destructive=destructive,
+                idempotent=idempotent,
+                open_world=open_world,
+            ),
+        )

agentpool/resource_providers/codemode/__init__.py

@@ -0,0 +1,9 @@
+"""Meta-resource provider that exposes tools through Python execution."""
+
+from agentpool.resource_providers.codemode.provider import CodeModeResourceProvider
+from agentpool.resource_providers.codemode.remote_provider import (
+    RemoteCodeModeResourceProvider,
+)
+
+
+__all__ = ["CodeModeResourceProvider", "RemoteCodeModeResourceProvider"]

agentpool/resource_providers/codemode/code_executor.py

@@ -0,0 +1,215 @@
+"""Code execution provider with secure tool isolation via FastAPI server."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Self
+
+import anyio
+
+from agentpool.log import get_logger
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    import socket
+    from types import TracebackType
+
+    from exxec.base import ExecutionEnvironment
+    from exxec.configs import ExecutionEnvironmentConfig
+    from exxec.models import ServerInfo
+    from fastapi import FastAPI
+    from schemez import ToolsetCodeGenerator
+    import uvicorn
+
+    from agentpool.tools.base import Tool
+
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class RemoteCodeExecutor:
+    """Provides secure code execution with tool access via FastAPI server.
+
+    Architecture:
+    - FastAPI server runs in HOST environment with tool routes
+    - User code runs in SANDBOX environment (Docker, E2B, etc.)
+    - Sandbox makes HTTP calls to server for tool execution
+    """
+
+    toolset_generator: ToolsetCodeGenerator
+    """Code generator for tools."""
+
+    execution_env: ExecutionEnvironment
+    """Execution environment for running code."""
+
+    @classmethod
+    def from_tools(
+        cls,
+        tools: Sequence[Tool],
+        env_config: ExecutionEnvironmentConfig,
+        server_host: str = "localhost",
+        server_port: int = 8000,
+        include_docstrings: bool = True,
+    ) -> RemoteCodeExecutor:
+        """Create provider from tools and environment configuration.
+
+        Args:
+            tools: Tools to make available for code execution
+            env_config: Execution environment configuration
+            server_host: Host for FastAPI server
+            server_port: Port for FastAPI server
+            include_docstrings: Include function docstrings in documentation
+
+        Returns:
+            RemoteCodeExecutor instance
+        """
+        from agentpool.resource_providers.codemode.helpers import tools_to_codegen
+
+        toolset_gen = tools_to_codegen(tools, include_docstrings)
+        server_handler = ToolServerLifecycleHandler(toolset_gen, server_host, server_port)
+        execution_env = env_config.get_provider(server_handler)
+        return cls(toolset_gen, execution_env)
+
+    def get_tool_description(self) -> str:
+        """Get comprehensive description of available tools."""
+        return self.toolset_generator.generate_tool_description()
+
+    async def execute_code(self, code: str) -> Any:
+        """Execute code with tools available via HTTP API.
+
+        Args:
+            code: Python code to execute
+
+        Returns:
+            Execution result from the environment
+        """
+        return await self.execution_env.execute(code)
+
+    async def __aenter__(self) -> Self:
+        """Async context manager entry."""
+        await self.execution_env.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Async context manager exit."""
+        return await self.execution_env.__aexit__(exc_type, exc_val, exc_tb)
+
+
+class ToolServerLifecycleHandler:
+    """Manages FastAPI server lifecycle for tool access."""
+
+    def __init__(
+        self,
+        toolset_generator: ToolsetCodeGenerator,
+        host: str = "localhost",
+        port: int = 8000,
+    ) -> None:
+        self.toolset_generator = toolset_generator
+        self.host = host
+        self.port = port  # Will be set when socket is created
+        self.app: FastAPI | None = None
+        self.server: uvicorn.Server | None = None
+        self._server_task: asyncio.Task[None] | None = None
+        self._socket: socket.socket | None = None
+
+    async def __aenter__(self) -> ServerInfo:
+        """Start FastAPI server with tool routes."""
+        from exxec.models import ServerInfo
+        from fastapi import FastAPI
+
+        from agentpool.utils.network import _create_socket
+
+        if self.server is not None:
+            return ServerInfo(url=f"http://{self.host}:{self.port}", port=self.port)
+        # Create socket and get actual port
+        self._socket, self.port = _create_socket(self.port)
+        # Create FastAPI app
+        self.app = FastAPI(title="Tool Server", description="Generated tool endpoints")
+
+        # Add tool routes
+        self.toolset_generator.add_all_routes(self.app, "/tools")
+
+        import uvicorn
+
+        config = uvicorn.Config(
+            self.app,
+            log_level="error",  # Reduce log noise
+            access_log=False,
+            host=self.host,
+            port=self.port,
+            ws="websockets-sansio",
+        )
+        self.server = uvicorn.Server(config)
+
+        # Start server in background with our socket
+        self._server_task = asyncio.create_task(self.server.serve([self._socket]))
+        logger.info("Started tool server", host=self.host, port=self.port)
+        await anyio.sleep(0.1)  # Wait for server to start properly
+        # Verify server is running
+        max_retries = 10
+        for _ in range(max_retries):
+            if self.server.started:
+                break
+            await anyio.sleep(0.1)
+
+        return ServerInfo(url=f"http://{self.host}:{self.port}", port=self.port)
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Stop FastAPI server."""
+        # Stop server gracefully
+        if self.server:
+            with contextlib.suppress(Exception):
+                self.server.should_exit = True
+                if hasattr(self.server, "force_exit"):
+                    self.server.force_exit = True
+
+        # Cancel server task
+        if self._server_task and not self._server_task.done():
+            self._server_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await asyncio.wait_for(self._server_task, timeout=1.0)
+
+        # Close socket
+        if self._socket:
+            with contextlib.suppress(Exception):
+                self._socket.close()
+
+        # Reset state
+        self.server = None
+        self._server_task = None
+        self._socket = None
+        self.app = None
+
+
+if __name__ == "__main__":
+    from exxec.configs import LocalExecutionEnvironmentConfig
+
+    from agentpool.tools.base import Tool
+
+    def add_numbers(x: int, y: int) -> int:
+        """Add two numbers."""
+        return x + y
+
+    async def main() -> None:
+        tools = [Tool.from_callable(add_numbers)]
+        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)")
+            print(f"Result: {result.result}")
+
+    anyio.run(main)

agentpool/resource_providers/codemode/default_prompt.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+
+USAGE = """
+A tool to execute python code.
+You can (and should) use the provided stubs as async function calls
+if you need to.
+Write an async main function which returns the result if neccessary.
+DONT write placeholders. DONT run the function yourself. just write the function.
+
+Example:
+async def main():
+    result_1 = await provided_function()
+    result_2 = await provided_function_2("some_arg")
+    return result_1 + result_2
+
+You may also use loops, conditionals etc. if neccessary.
+
+"""

agentpool/resource_providers/codemode/helpers.py

@@ -0,0 +1,83 @@
+"""Prepare LLM output to be in proper shape and executable."""
+
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+from agentpool.log import get_logger
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from schemez import ToolsetCodeGenerator
+
+    from agentpool.tools import Tool
+
+logger = get_logger(__name__)
+
+
+def validate_code(python_code: str) -> None:
+    """Validate code structure and raise ModelRetry for fixable issues."""
+    from pydantic_ai import ModelRetry
+
+    code = python_code.strip()
+    try:
+        ast.parse(code)
+    except SyntaxError as e:
+        msg = f"Invalid code syntax: {e}"
+        logger.info("Invalid code", code=code)
+        raise ModelRetry(msg) from None
+    else:
+        if "async def main(" not in code:
+            logger.info("Code not in async def main()", code=code)
+            msg = (
+                "Code must be wrapped in 'async def main():' function. "
+                "Please rewrite your code like:\n"
+                "async def main():\n"
+                "    # your code here\n"
+                "    return result"
+            )
+            raise ModelRetry(msg)
+
+        # Check if code contains a return statement
+        if "return " not in code:
+            logger.info("Code does not contain a return statement", code=code)
+            msg = "The main() function should return a value."
+            raise ModelRetry(msg)
+
+
+def tools_to_codegen(
+    tools: Sequence[Tool],
+    include_docstrings: bool = True,
+) -> ToolsetCodeGenerator:
+    """Create a ToolsetCodeGenerator from a sequence of Tools.
+
+    Args:
+        tools: Tools to generate code for
+        include_docstrings: Include function docstrings in documentation
+
+    Returns:
+        ToolsetCodeGenerator instance
+    """
+    from pydantic_ai import RunContext
+    from schemez import ToolCodeGenerator, ToolsetCodeGenerator, create_schema
+
+    from agentpool.agents.context import AgentContext
+
+    generators = [
+        ToolCodeGenerator(
+            schema=create_schema(
+                t.callable,
+                name_override=t.name,
+                description_override=t.description,
+                mode="openai",
+                exclude_types=[AgentContext, RunContext],
+            ),
+            callable=t.callable,
+            name_override=t.name,
+        )
+        for t in tools
+    ]
+    return ToolsetCodeGenerator(generators, include_docstrings)