agentpool 2.1.9__py3-none-any.whl

agentpool/resource_providers/codemode/progress_executor.py

@@ -0,0 +1,212 @@
+"""Statement-by-statement execution with automatic progress tracking."""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+import inspect
+import time
+from typing import TYPE_CHECKING, Any
+
+import anyio
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Callable
+
+
+@dataclass
+class ProgressInfo:
+    """Information about code execution progress."""
+
+    current: float
+    """Current progress value."""
+
+    total: float
+    """Total progress value."""
+
+    message: str
+    """Progress message describing current operation."""
+
+
+def count_statements(code: str) -> int:
+    """Count total statements in the code."""
+    try:
+        tree = ast.parse(code)
+        return len(tree.body)
+    except SyntaxError:
+        return 0
+
+
+class ProgressTrackingExecutor:
+    """Execute Python code statement-by-statement with automatic progress reporting."""
+
+    def __init__(
+        self,
+        progress_callback: Callable[[ProgressInfo], Awaitable[Any]] | None = None,
+        step_delay: float = 0.01,
+    ) -> None:
+        """Initialize executor.
+
+        Args:
+            progress_callback: Optional callback for progress reporting
+            step_delay: Delay between statement executions (for async behavior)
+        """
+        self.globals: dict[str, Any] = {"__builtins__": __builtins__}
+        self.locals: dict[str, Any] = {}
+        self.progress_callback = progress_callback
+        self.step_delay = step_delay
+        self.total_statements = 0
+        self.current_statement = 0
+        self.start_time: float | None = None
+
+    def update_namespace(self, namespace: dict[str, Any]) -> None:
+        """Update the execution namespace with additional globals."""
+        self.globals.update(namespace)
+
+    async def execute_with_progress(self, code: str) -> Any:
+        """Execute code with automatic progress reporting.
+
+        Args:
+            code: Python source code to execute
+
+        Returns:
+            Result of code execution
+        """
+        self.total_statements = count_statements(code)
+        self.current_statement = 0
+        self.start_time = time.time()
+
+        if self.total_statements == 0:
+            return "No statements to execute"
+
+        try:
+            tree = ast.parse(code)
+
+            for i, node in enumerate(tree.body):
+                self.current_statement = i + 1
+
+                # Report progress if callback available
+                if self.progress_callback:
+                    node_type = type(node).__name__
+                    message = f"Executing {node_type.lower()} statement"
+
+                    progress_info = ProgressInfo(
+                        current=float(self.current_statement),
+                        total=float(self.total_statements),
+                        message=message,
+                    )
+                    await self.progress_callback(progress_info)
+
+                # Execute the statement
+                compiled = compile(
+                    ast.Module(body=[node], type_ignores=[]), f"<statement_{i}>", "exec"
+                )
+                exec(compiled, self.globals, self.locals)
+
+                # Small delay for async behavior
+                if self.step_delay > 0:
+                    await anyio.sleep(self.step_delay)
+
+            # Try to get result from main() function or return success
+            if "main" in self.locals and callable(self.locals["main"]):
+                result = self.locals["main"]()
+                if inspect.iscoroutine(result):
+                    result = await result
+                return result
+        except Exception as e:
+            # Report error with current progress
+            if self.progress_callback:
+                progress_info = ProgressInfo(
+                    current=float(self.current_statement),
+                    total=float(self.total_statements),
+                    message=f"Error: {str(e)[:50]}...",
+                )
+                await self.progress_callback(progress_info)
+            raise
+        else:
+            return "Code executed successfully"
+
+    async def execute_statements(self, code: str) -> AsyncIterator[tuple[str, dict[str, Any]]]:
+        """Execute code statement by statement, yielding each executed statement.
+
+        This method is useful for external progress tracking or debugging.
+
+        Yields:
+            (statement_source, metadata) tuples
+        """
+        self.total_statements = count_statements(code)
+        self.current_statement = 0
+        self.start_time = time.time()
+
+        if self.total_statements == 0:
+            return
+
+        tree = ast.parse(code)
+        for i, node in enumerate(tree.body):
+            self.current_statement = i + 1
+            statement_code = ast.unparse(node)
+            # Create metadata
+            elapsed_time = time.time() - (self.start_time or time.time())
+            metadata = {
+                "statement_index": i,
+                "total_statements": self.total_statements,
+                "node_type": type(node).__name__,
+                "elapsed_seconds": elapsed_time,
+                "locals_before": dict(self.locals),
+            }
+
+            # Execute the statement
+            try:
+                compiled = compile(
+                    ast.Module(body=[node], type_ignores=[]), f"<statement_{i}>", "exec"
+                )
+                exec(compiled, self.globals, self.locals)
+                metadata["status"] = "success"
+            except Exception as e:  # noqa: BLE001
+                metadata["status"] = "error"
+                metadata["error"] = str(e)
+
+            metadata["locals_after"] = dict(self.locals)
+            yield statement_code, metadata
+
+            if self.step_delay > 0:
+                await anyio.sleep(self.step_delay)
+
+
+if __name__ == "__main__":
+    from pydantic_ai import RunContext  # noqa: TC002
+
+    from agentpool import log
+    from agentpool.agents import AgentContext  # noqa: TC001
+
+    log.configure_logging()
+    code = """
+x = 10
+y = 20
+z = x + y
+print(f"Result: {z}")
+for i in range(3):
+    print(f"Loop: {i}")
+"""
+
+    async def run_me(run_context: RunContext, ctx: AgentContext) -> str:
+        """Test function using the unified progress system."""
+        executor = ProgressTrackingExecutor(step_delay=0.5)
+        results = []
+        async for x in executor.execute_statements(code):
+            await ctx.events.custom(x)
+            results.append(x[0])
+
+        return f"Code executed successfully. Executed {len(results)} statements."
+
+    async def main() -> None:
+        from agentpool.delegation import AgentPool
+
+        async with AgentPool() as pool:
+            agent = await pool.add_agent("test-agent", model="openai:gpt-5-nano", tools=[run_me])
+            print("🚀 Testing unified progress system...")
+            async for event in agent.run_stream("Run run_me and show progress."):
+                print(f"Event: {event}")
+
+    anyio.run(main)

agentpool/resource_providers/codemode/provider.py

@@ -0,0 +1,150 @@
+"""Meta-resource provider that exposes tools through Python execution."""
+
+from __future__ import annotations
+
+from functools import partial
+import inspect
+from typing import TYPE_CHECKING, Any
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.resource_providers import AggregatingResourceProvider
+from agentpool.resource_providers.codemode.default_prompt import USAGE
+from agentpool.resource_providers.codemode.helpers import (
+    tools_to_codegen,
+    validate_code,
+)
+from agentpool_toolsets.fsspec_toolset.toolset import FSSpecTools
+
+
+if TYPE_CHECKING:
+    from schemez import ToolsetCodeGenerator
+
+    from agentpool.resource_providers import ResourceProvider
+    from agentpool.tools.base import Tool
+
+
+class CodeModeResourceProvider(AggregatingResourceProvider):
+    """Provider that wraps tools into a single Python execution environment."""
+
+    def __init__(
+        self,
+        providers: list[ResourceProvider],
+        name: str = "meta_tools",
+        include_docstrings: bool = True,
+        usage_notes: str = USAGE,
+    ) -> None:
+        """Initialize meta provider.
+
+        Args:
+            providers: Providers whose tools to wrap
+            name: Provider name
+            include_docstrings: Include function docstrings in documentation
+            usage_notes: Usage notes for the codemode tool
+        """
+        super().__init__(providers=providers, name=name)
+        self.include_docstrings = include_docstrings
+        self._cached_tool: Tool | None = None
+        self.usage_notes = usage_notes
+
+    async def get_tools(self) -> list[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()
+        desc = toolset_generator.generate_tool_description()
+        desc += self.usage_notes
+
+        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:
+                """These docstings are overriden by description_override."""
+                return await self.execute(ctx, python_code)
+
+            self._cached_tool = self.create_tool(execute_tool, description_override=desc)
+        else:
+            # Update the description on existing cached tool
+            self._cached_tool.description = desc
+
+        return [self._cached_tool]
+
+    async def execute(self, ctx: AgentContext, python_code: str) -> Any:  # noqa: D417
+        """Execute Python code with all wrapped tools available as functions.
+
+        Args:
+            python_code: Python code to execute
+
+        Returns:
+            Result of the last expression or explicit return value
+        """
+        toolset_generator = await self._get_code_generator()
+        namespace = toolset_generator.generate_execution_namespace()
+
+        # Wrap namespace callables to inject AgentContext
+        for value in namespace.values():
+            if callable(value) and hasattr(value, "callable"):
+                # It's a NamespaceCallable - wrap its underlying callable with ctx
+                original_callable = value.callable
+                if "agent_ctx" in inspect.signature(original_callable).parameters:
+                    value.callable = partial(original_callable, agent_ctx=ctx)
+
+        # async def report_progress(current: int, total: int, message: str = ""):
+        #     """Report progress during code execution."""
+        #     await ctx.report_progress(current, total, message)
+
+        # namespace["report_progress"] = NamespaceCallable(report_progress)
+
+        validate_code(python_code)
+        try:
+            exec(python_code, namespace)
+            result = 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"
+        except Exception as e:  # noqa: BLE001
+            return f"Error executing code: {e!s}"
+        else:
+            return result
+
+    def invalidate_cache(self) -> None:
+        """Invalidate cached tool when providers change."""
+        self._cached_tool = None
+        # Note: We no longer cache the toolset generator, so no need to clear it
+
+    async def _get_code_generator(self) -> ToolsetCodeGenerator:
+        """Get fresh toolset generator with current tools."""
+        tools = await super().get_tools()
+        return tools_to_codegen(tools=tools, include_docstrings=self.include_docstrings)
+
+
+if __name__ == "__main__":
+    import anyio
+
+    from agentpool import Agent
+    from agentpool.delegation.pool import AgentPool
+
+    static_provider = FSSpecTools()
+    provider = CodeModeResourceProvider([static_provider])
+
+    async def main() -> None:
+        print("Available tools:")
+        for tool in await provider.get_tools():
+            print(f"- {tool.name}: {tool.description[:100]}...")
+
+        async with AgentPool() as pool:
+            agent: Agent[None, str] = Agent(
+                model="openai:gpt-5-nano", event_handlers=["simple"], retries=1
+            )
+            pool.register("test_agent", agent)
+            async with agent:
+                agent.tools.add_provider(provider)
+                prompt = (
+                    "Call list_directory with path='.'. "
+                    "Write: async def main(): "
+                    "result = await list_directory(path='.'); "
+                    "return result"
+                )
+                result = await agent.run(prompt)
+                print(f"Result: {result}")
+
+    anyio.run(main)

agentpool/resource_providers/codemode/remote_mcp_execution.py

@@ -0,0 +1,143 @@
+"""Code execution provider with secure tool isolation via FastAPI server."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Self
+
+from agentpool.log import get_logger
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from types import TracebackType
+
+    from exxec.base import ExecutionEnvironment
+    from exxec.configs import ExecutionEnvironmentConfig
+    from schemez import ToolsetCodeGenerator
+
+    from agentpool.tools.base import Tool
+
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class RemoteMCPExecutor:
+    """Provides secure code execution with tool access.
+
+    Code Generation mode (ctx-zip style):
+       - Tool functions are generated as Python files inside sandbox
+       - User code imports tools directly, no HTTP server needed
+       - Better for cloud sandboxes (E2B, etc.) that can't reach localhost
+    """
+
+    toolset_generator: ToolsetCodeGenerator
+    """Code generator for tools."""
+
+    execution_env: ExecutionEnvironment
+    """Execution environment for running code."""
+
+    use_code_generation: bool = False
+    """If True, use code generation approach instead of HTTP server."""
+
+    @classmethod
+    def from_tools(
+        cls,
+        tools: Sequence[Tool],
+        env_config: ExecutionEnvironmentConfig,
+        include_docstrings: bool = True,
+    ) -> RemoteMCPExecutor:
+        """Create provider from tools and environment configuration.
+
+        Args:
+            tools: Tools to make available for code execution
+            env_config: Execution environment configuration
+            include_docstrings: Include function docstrings in documentation
+
+        Returns:
+            RemoteMCPExecutor instance
+        """
+        from agentpool.resource_providers.codemode.helpers import tools_to_codegen
+
+        toolset_gen = tools_to_codegen(tools, include_docstrings)
+        execution_env = env_config.get_provider()
+        return cls(toolset_gen, execution_env)
+
+    def get_tool_description(self) -> str:
+        """Get comprehensive description of available tools."""
+        # For code generation mode, provide import-based usage instructions
+        tool_names = [gen.name for gen in self.toolset_generator.generators]
+        desc = self.toolset_generator.generate_tool_description()
+        desc += "Usage:\n"
+        for name in tool_names:
+            desc += f"  from tools.{name} import {name}\n"
+            desc += f"  result = await {name}(...)\n"
+        return desc
+
+    async def execute_code(self, code: str) -> Any:
+        """Execute code with tools available.
+
+        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)
+
+
+if __name__ == "__main__":
+    import anyio
+    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
+
+    def multiply_numbers(x: int, y: int) -> int:
+        """Multiply two numbers."""
+        return x * y
+
+    async def main() -> None:
+        print("\n=== Code Generation Approach (ctx-zip style) ===")
+        tools = [Tool.from_callable(add_numbers), Tool.from_callable(multiply_numbers)]
+        config = LocalExecutionEnvironmentConfig()  # Could be E2B, etc.
+        provider = RemoteMCPExecutor.from_tools(tools, config)
+        async with provider:
+            print("Tool description:")
+            print(provider.get_tool_description())
+            print("\nExecuting code with direct imports...")
+
+            # Code that imports tools directly (no HTTP calls)
+            code = """
+from tools.add_numbers import add_numbers
+from tools.multiply_numbers import multiply_numbers
+
+# Direct function calls - no HTTP server needed!
+result1 = add_numbers(5, 3)
+result2 = multiply_numbers(4, 7)
+
+_result = {"addition": result1, "multiplication": result2}
+print(f"Addition: {result1}, Multiplication: {result2}")
+"""
+            result = await provider.execute_code(code)
+            print(f"Result: {result.result}")
+
+    anyio.run(main)

agentpool/resource_providers/codemode/remote_provider.py

@@ -0,0 +1,171 @@
+"""Secure code execution provider using isolated execution environments."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from typing import TYPE_CHECKING, Any, Self
+
+from exxec.configs import LocalExecutionEnvironmentConfig
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.log import get_logger
+from agentpool.resource_providers.codemode.code_executor import (
+    RemoteCodeExecutor,
+)
+from agentpool.resource_providers.codemode.default_prompt import USAGE
+from agentpool.resource_providers.codemode.helpers import validate_code
+from agentpool.resource_providers.codemode.provider import (
+    CodeModeResourceProvider,
+)
+from agentpool.tools.base import Tool
+
+
+logger = get_logger(__name__)
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from exxec.configs import ExecutionEnvironmentConfig
+
+    from agentpool.resource_providers import ResourceProvider
+
+
+PROGRESS_HELPER = """
+async def report_progress(current: int, total: int, message: str = "") -> None:
+    '''Report progress during execution'''
+    percentage = (current / total) * 100 if total > 0 else 0
+    print(f"Progress: {percentage:.1f}% ({current}/{total}) {message}")
+"""
+
+
+class RemoteCodeModeResourceProvider(CodeModeResourceProvider):
+    """Provider that executes code in secure isolation with tool access via server."""
+
+    def __init__(
+        self,
+        providers: list[ResourceProvider],
+        execution_config: ExecutionEnvironmentConfig | None = None,
+        name: str = "secure_code_executor",
+        include_docstrings: bool = True,
+        usage_notes: str = USAGE,
+        server_host: str = "localhost",
+        server_port: int = 8000,
+    ) -> None:
+        """Initialize secure code execution provider.
+
+        Args:
+            providers: Providers whose tools to expose
+            execution_config: Execution environment configuration
+            name: Provider name
+            include_docstrings: Include function docstrings in documentation
+            usage_notes: Usage notes for the provider
+            server_host: Host for tool server
+            server_port: Port for tool server
+        """
+        super().__init__(
+            providers=providers,
+            name=name,
+            include_docstrings=include_docstrings,
+            usage_notes=usage_notes,
+        )
+        self.execution_config = execution_config or LocalExecutionEnvironmentConfig()
+        self.server_host = server_host
+        self.server_port = server_port
+        self._code_executor: RemoteCodeExecutor | None = None
+        self._provider_lock = asyncio.Lock()
+
+    async def execute(self, ctx: AgentContext, python_code: str) -> Any:  # noqa: D417
+        """Execute Python code in secure environment with tools available via HTTP.
+
+        Args:
+            python_code: Python code to execute
+
+        Returns:
+            Result of the code execution
+        """
+        code_provider = await self._get_code_executor()
+        logger.info("Validating code", code=python_code)
+        validate_code(python_code)
+        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
+        except Exception as e:  # noqa: BLE001
+            return f"Error in secure execution: {e!s}"
+        else:
+            return f"Error executing code: {result.error}"
+
+    async def _get_code_executor(self) -> RemoteCodeExecutor:
+        """Get cached code execution provider with thread-safe initialization."""
+        async with self._provider_lock:
+            if self._code_executor is None:
+                all_tools = await super().get_tools()
+                self._code_executor = RemoteCodeExecutor.from_tools(
+                    all_tools,
+                    self.execution_config,
+                    server_host=self.server_host,
+                    server_port=self.server_port,
+                    include_docstrings=self.include_docstrings,
+                )
+                # Initialize the provider and start server
+                await self._code_executor.__aenter__()
+
+            return self._code_executor
+
+    async def __aenter__(self) -> Self:
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Async context manager exit."""
+        if self._code_executor is not None:
+            with contextlib.suppress(Exception):
+                await self._code_executor.__aexit__(exc_type, exc_val, exc_tb)
+            self._code_executor = None
+
+
+if __name__ == "__main__":
+    import webbrowser
+
+    import anyio
+    from exxec.configs import LocalExecutionEnvironmentConfig
+
+    from agentpool import Agent, log
+    from agentpool.resource_providers import StaticResourceProvider
+
+    log.configure_logging()
+
+    def open_browser(url: str) -> bool:
+        """Use this to open url in the default browser."""
+        return webbrowser.open(url)
+
+    async def main() -> None:
+        tools = [Tool.from_callable(open_browser)]
+        static_provider = StaticResourceProvider(tools=tools)
+        config = LocalExecutionEnvironmentConfig(timeout=30.0)
+        provider = RemoteCodeModeResourceProvider(
+            providers=[static_provider],
+            execution_config=config,
+            server_port=9999,
+        )
+        print("Available tools:")
+        for tool in await provider.get_tools():
+            print(f"- {tool.name}: {tool.description}")
+
+        async with Agent(model="anthropic:claude-haiku-4-5") as agent:
+            agent.tools.add_provider(provider)
+            result = await agent.run("open google.com in the browser.")
+            print(f"Result: {result}")
+
+    anyio.run(main)