agentpool 2.1.9__py3-none-any.whl

agentpool/agents/agui_agent/helpers.py

@@ -0,0 +1,192 @@
+"""AG-UI agent helpers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+from pydantic import TypeAdapter
+
+from agentpool.log import get_logger
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from ag_ui.core import Event, ToolMessage
+    import httpx
+
+    from agentpool.agents.context import ConfirmationResult
+    from agentpool.messaging.context import NodeContext
+    from agentpool.tools import Tool
+    from agentpool.ui.base import InputProvider
+    from agentpool_config.nodes import ToolConfirmationMode
+
+
+logger = get_logger(__name__)
+
+
+async def _should_confirm_tool(
+    tool: Tool,
+    confirmation_mode: ToolConfirmationMode,
+) -> bool:
+    """Determine if a tool requires confirmation based on mode.
+
+    Args:
+        tool: The tool to check
+        confirmation_mode: Current confirmation mode
+
+    Returns:
+        True if confirmation is required
+    """
+    if confirmation_mode == "never":
+        return False
+    if confirmation_mode == "always":
+        return True
+    # "per_tool" mode - check tool's requires_confirmation attribute
+    return tool.requires_confirmation
+
+
+async def _get_tool_confirmation(
+    tool: Tool,
+    args: dict[str, Any],
+    input_provider: InputProvider,
+    context: NodeContext[Any],
+) -> ConfirmationResult:
+    """Get confirmation for tool execution.
+
+    Args:
+        tool: Tool to confirm
+        args: Tool arguments
+        input_provider: Provider for confirmation UI
+        context: Node context
+
+    Returns:
+        Confirmation result
+    """
+    return await input_provider.get_tool_confirmation(
+        context=context,
+        tool=tool,
+        args=args,
+        message_history=None,
+    )
+
+
+async def execute_tool_calls(
+    tool_calls: list[tuple[str, str, dict[str, Any]]],
+    tools_by_name: dict[str, Tool],
+    *,
+    confirmation_mode: ToolConfirmationMode = "never",
+    input_provider: InputProvider | None = None,
+    context: NodeContext[Any] | None = None,
+) -> list[ToolMessage]:
+    """Execute tool calls locally and return results.
+
+    Args:
+        tool_calls: List of (tool_call_id, tool_name, args) tuples
+        tools_by_name: Dictionary mapping tool names to Tool instances
+        confirmation_mode: Tool confirmation mode
+        input_provider: Optional input provider for confirmation requests
+        context: Optional node context for confirmation
+
+    Returns:
+        List of ToolMessage with execution results
+    """
+    from ag_ui.core import ToolMessage as AGUIToolMessage
+
+    results: list[AGUIToolMessage] = []
+    for tc_id, tool_name, args in tool_calls:
+        if tool_name not in tools_by_name:
+            # Tool not registered locally - this is a server-side tool, skip it
+            logger.debug("Skipping server-side tool", tool=tool_name)
+            continue
+
+        tool = tools_by_name[tool_name]
+
+        # Check if confirmation is required
+        if await _should_confirm_tool(tool, confirmation_mode):
+            if input_provider is None or context is None:
+                logger.warning(
+                    "Tool requires confirmation but no input provider available",
+                    tool=tool_name,
+                )
+                result_msg = AGUIToolMessage(
+                    id=str(uuid4()),
+                    tool_call_id=tc_id,
+                    content="Error: Tool requires confirmation but no provider available",
+                    error="No input provider for confirmation",
+                )
+                results.append(result_msg)
+                continue
+
+            confirmation = await _get_tool_confirmation(tool, args, input_provider, context)
+            if confirmation == "skip":
+                logger.info("Tool execution skipped by user", tool=tool_name)
+                result_msg = AGUIToolMessage(
+                    id=str(uuid4()),
+                    tool_call_id=tc_id,
+                    content="Tool execution was skipped by user",
+                    error=None,
+                )
+                results.append(result_msg)
+                continue
+            if confirmation in ("abort_run", "abort_chain"):
+                logger.info("Tool execution aborted by user", tool=tool_name, action=confirmation)
+                result_msg = AGUIToolMessage(
+                    id=str(uuid4()),
+                    tool_call_id=tc_id,
+                    content="Tool execution was aborted by user",
+                    error="Execution aborted",
+                )
+                results.append(result_msg)
+                # Could raise an exception here to abort the entire run
+                continue
+
+        # Execute the tool
+        logger.info("Executing tool", tool=tool_name, args=args)
+        try:
+            result = await tool.execute(**args)
+            result_str = str(result) if not isinstance(result, str) else result
+            id_ = str(uuid4())
+            result_msg = AGUIToolMessage(id=id_, tool_call_id=tc_id, content=result_str)
+            logger.debug("Tool executed", tool=tool_name, result=result_str[:100])
+        except Exception as e:
+            logger.exception("Tool execution failed", tool=tool_name)
+            result_msg = AGUIToolMessage(
+                id=str(uuid4()),
+                tool_call_id=tc_id,
+                content=f"Error executing tool: {e}",
+                error=str(e),
+            )
+        results.append(result_msg)
+    return results
+
+
+async def parse_sse_stream(response: httpx.Response) -> AsyncIterator[Event]:
+    """Parse Server-Sent Events stream.
+
+    Args:
+        response: HTTP response with SSE stream
+
+    Yields:
+        Parsed AG-UI events
+    """
+    from ag_ui.core import Event
+
+    event_adapter: TypeAdapter[Event] = TypeAdapter(Event)
+    buffer = ""
+    async for chunk in response.aiter_text():
+        buffer += chunk
+        # Process complete SSE events
+        while "\n\n" in buffer:
+            event_text, buffer = buffer.split("\n\n", 1)
+            # Parse SSE format: "data: {json}\n"
+            for line in event_text.split("\n"):
+                if not line.startswith("data: "):
+                    continue
+                json_str = line[6:]  # Remove "data: " prefix
+                try:
+                    event = event_adapter.validate_json(json_str)
+                    yield event
+                except (ValueError, TypeError) as e:
+                    logger.warning("Failed to parse AG-UI event", json=json_str[:100], error=str(e))

agentpool/agents/architect.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import pathlib
+
+import anyio
+from schemez import YAMLCode
+from upathtools import read_folder_as_text, read_path
+
+from agentpool import Agent, models
+import agentpool_config
+
+
+SYS_PROMPT = """
+You are an expert at creating AgentPool manifests.
+Generate complete, valid YAML that CAN include:
+- Agent configurations with appropriate tools and capabilities
+- Team definitions with proper member relationships
+- Connection setups for message routing
+Follow the provided JSON schema exactly.
+Only add stuff asked for by the user. Be tense. Less is more.
+DONT try to guess tools.
+Add response schemas and storage providers and environment section only when asked for.
+"""
+
+
+CONFIG_PATH = pathlib.Path(agentpool_config.__file__).parent
+CORE_CONFIG_PATH = pathlib.Path(models.__file__).parent
+README_URL = "https://raw.githubusercontent.com/phil65/agentpool/main/README.md"
+
+
+async def create_architect_agent(
+    name: str = "config_generator",
+    model: str = "openrouter:gpt-5-nano",
+) -> Agent[None, YAMLCode]:
+    code = await read_folder_as_text(CONFIG_PATH, pattern="**/*.py")
+    core_code = await read_folder_as_text(CORE_CONFIG_PATH, pattern="**/*.py")
+    readme = await read_path(README_URL)
+    context = f"Code:\n{core_code}\n{code}\nReadme:\n{readme}"
+    agent = Agent(
+        name,
+        model=model,
+        system_prompt=SYS_PROMPT,
+        output_type=YAMLCode,
+    )
+    agent.conversation.add_context_message(context)
+    return agent
+
+
+async def create_architect_agent_2(
+    name: str = "config_generator",
+    model: str = "openai:gpt-5-nano",
+) -> Agent[None, YAMLCode]:
+    from agentpool import AgentsManifest
+
+    code = AgentsManifest.to_python_code()
+    return Agent(
+        name,
+        model=model,
+        system_prompt=SYS_PROMPT + f"<config>{code}</config>",
+        output_type=YAMLCode,
+    )
+
+
+if __name__ == "__main__":
+
+    async def main() -> None:
+        agent = await create_architect_agent_2()
+        cfg = await agent.run("write an AgentManifest with a GIT expert")
+        print(cfg.content.code)
+
+    print(anyio.run(main))

agentpool/agents/base_agent.py

@@ -0,0 +1,177 @@
+"""Base class for all agent types."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+import asyncio
+from typing import TYPE_CHECKING, Any, Literal
+
+from anyenv import MultiEventHandler
+from exxec import LocalExecutionEnvironment
+
+from agentpool.agents.events import resolve_event_handlers
+from agentpool.log import get_logger
+from agentpool.messaging import MessageHistory, MessageNode
+from agentpool.tools.manager import ToolManager
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Sequence
+
+    from evented.configs import EventConfig
+    from exxec import ExecutionEnvironment
+
+    from agentpool.agents.context import AgentContext
+    from agentpool.agents.events import RichAgentStreamEvent
+    from agentpool.common_types import BuiltinEventHandlerType, IndividualEventHandler
+    from agentpool.delegation import AgentPool
+    from agentpool.ui.base import InputProvider
+    from agentpool_config.mcp_server import MCPServerConfig
+
+
+logger = get_logger(__name__)
+
+ToolConfirmationMode = Literal["always", "never", "per_tool"]
+
+
+class BaseAgent[TDeps = None, TResult = str](MessageNode[TDeps, TResult]):
+    """Base class for Agent, ACPAgent, AGUIAgent, and ClaudeCodeAgent.
+
+    Provides shared infrastructure:
+    - tools: ToolManager for tool registration and execution
+    - conversation: MessageHistory for conversation state
+    - event_handler: MultiEventHandler for event distribution
+    - _event_queue: Queue for streaming events
+    - tool_confirmation_mode: Tool confirmation behavior
+    - _input_provider: Provider for user input/confirmations
+    - env: ExecutionEnvironment for running code/commands
+    - context property: Returns NodeContext for the agent
+    """
+
+    def __init__(
+        self,
+        *,
+        name: str = "agent",
+        description: str | None = None,
+        display_name: str | None = None,
+        mcp_servers: Sequence[str | MCPServerConfig] | None = None,
+        agent_pool: AgentPool[Any] | None = None,
+        enable_logging: bool = True,
+        event_configs: Sequence[EventConfig] | None = None,
+        # New shared parameters
+        env: ExecutionEnvironment | None = None,
+        input_provider: InputProvider | None = None,
+        output_type: type[TResult] = str,  # type: ignore[assignment]
+        tool_confirmation_mode: ToolConfirmationMode = "per_tool",
+        event_handlers: Sequence[IndividualEventHandler | BuiltinEventHandlerType] | None = None,
+    ) -> None:
+        """Initialize base agent with shared infrastructure.
+
+        Args:
+            name: Agent name
+            description: Agent description
+            display_name: Human-readable display name
+            mcp_servers: MCP server configurations
+            agent_pool: Agent pool for coordination
+            enable_logging: Whether to enable database logging
+            event_configs: Event trigger configurations
+            env: Execution environment for running code/commands
+            input_provider: Provider for user input and confirmations
+            output_type: Output type for this agent
+            tool_confirmation_mode: How tool execution confirmation is handled
+            event_handlers: Event handlers for this agent
+        """
+        super().__init__(
+            name=name,
+            description=description,
+            display_name=display_name,
+            mcp_servers=mcp_servers,
+            agent_pool=agent_pool,
+            enable_logging=enable_logging,
+            event_configs=event_configs,
+        )
+
+        # Shared infrastructure - previously duplicated in all 4 agents
+        self._event_queue: asyncio.Queue[RichAgentStreamEvent[Any]] = asyncio.Queue()
+        self.conversation = MessageHistory()
+        self.env = env or LocalExecutionEnvironment()
+        self._input_provider = input_provider
+        self._output_type: type[TResult] = output_type
+        self.tool_confirmation_mode: ToolConfirmationMode = tool_confirmation_mode
+        self.tools = ToolManager()
+        resolved_handlers = resolve_event_handlers(event_handlers)
+        self.event_handler: MultiEventHandler[IndividualEventHandler] = MultiEventHandler(
+            resolved_handlers
+        )
+
+        # Cancellation infrastructure
+        self._cancelled = False
+        self._current_stream_task: asyncio.Task[Any] | None = None
+
+    @abstractmethod
+    def get_context(self, data: Any = None) -> AgentContext[Any]:
+        """Create a new context for this agent.
+
+        Args:
+            data: Optional custom data to attach to the context
+
+        Returns:
+            A new AgentContext instance
+        """
+        ...
+
+    @property
+    @abstractmethod
+    def model_name(self) -> str | None:
+        """Get the model name used by this agent."""
+        ...
+
+    @abstractmethod
+    def run_stream(
+        self,
+        *prompt: Any,
+        **kwargs: Any,
+    ) -> AsyncIterator[RichAgentStreamEvent[TResult]]:
+        """Run agent with streaming output.
+
+        Args:
+            *prompt: Input prompts
+            **kwargs: Additional arguments
+
+        Yields:
+            Stream events during execution
+        """
+        ...
+
+    async def set_tool_confirmation_mode(self, mode: ToolConfirmationMode) -> None:
+        """Set tool confirmation mode.
+
+        Args:
+            mode: Confirmation mode - "always", "never", or "per_tool"
+        """
+        self.tool_confirmation_mode = mode
+
+    def is_cancelled(self) -> bool:
+        """Check if the agent has been cancelled.
+
+        Returns:
+            True if cancellation was requested
+        """
+        return self._cancelled
+
+    async def interrupt(self) -> None:
+        """Interrupt the currently running stream.
+
+        This method is called when cancellation is requested. The default
+        implementation sets the cancelled flag and cancels the current stream task.
+
+        Subclasses may override to add protocol-specific cancellation:
+        - ACPAgent: Send CancelNotification to remote server
+        - ClaudeCodeAgent: Call client.interrupt()
+
+        The cancelled flag should be checked in run_stream loops to exit early.
+        """
+        self._cancelled = True
+        if self._current_stream_task and not self._current_stream_task.done():
+            self._current_stream_task.cancel()
+            logger.info("Interrupted agent stream", agent=self.name)

agentpool/agents/claude_code_agent/__init__.py

@@ -0,0 +1,11 @@
+"""Claude Code Agent - Native Claude Agent SDK integration.
+
+This module provides an agent implementation that wraps the Claude Agent SDK's
+ClaudeSDKClient for native integration with agentpool.
+"""
+
+from __future__ import annotations
+
+from agentpool.agents.claude_code_agent.claude_code_agent import ClaudeCodeAgent
+
+__all__ = ["ClaudeCodeAgent"]