agentpool 2.1.9__py3-none-any.whl

agentpool/agents/acp_agent/acp_converters.py

@@ -0,0 +1,294 @@
+"""ACP to native event converters.
+
+This module provides conversion from ACP session updates to native agentpool
+streaming events, enabling ACPAgent to yield the same event types as native agents.
+
+This is the reverse of the conversion done in acp_server/session.py handle_event().
+"""
+
+from __future__ import annotations
+
+import base64
+from typing import TYPE_CHECKING, Any, overload
+
+from pydantic_ai import (
+    AudioUrl,
+    BinaryContent,
+    BinaryImage,
+    DocumentUrl,
+    ImageUrl,
+    PartDeltaEvent,
+    TextPartDelta,
+    ThinkingPartDelta,
+    VideoUrl,
+)
+
+from acp.schema import (
+    AgentMessageChunk,
+    AgentPlanUpdate,
+    AgentThoughtChunk,
+    AudioContentBlock,
+    BlobResourceContents,
+    ContentToolCallContent,
+    EmbeddedResourceContentBlock,
+    FileEditToolCallContent,
+    ImageContentBlock,
+    ResourceContentBlock,
+    TerminalToolCallContent,
+    TextContentBlock,
+    ToolCallProgress,
+    ToolCallStart,
+    UserMessageChunk,
+)
+from agentpool.agents.events import (
+    DiffContentItem,
+    LocationContentItem,
+    PlanUpdateEvent,
+    TerminalContentItem,
+    ToolCallProgressEvent,
+    ToolCallStartEvent,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from pydantic_ai import UserContent
+
+    from acp.schema import ContentBlock, SessionUpdate
+    from acp.schema.mcp import HttpMcpServer, McpServer, SseMcpServer, StdioMcpServer
+    from acp.schema.tool_call import ToolCallContent, ToolCallLocation
+    from agentpool.agents.events import RichAgentStreamEvent, ToolCallContentItem
+    from agentpool_config.mcp_server import (
+        MCPServerConfig,
+        SSEMCPServerConfig,
+        StdioMCPServerConfig,
+        StreamableHTTPMCPServerConfig,
+    )
+
+
+def convert_acp_locations(
+    locations: list[ToolCallLocation] | None,
+) -> list[LocationContentItem]:
+    """Convert ACP ToolCallLocation list to native LocationContentItem list."""
+    return [LocationContentItem(path=loc.path, line=loc.line) for loc in locations or []]
+
+
+def convert_acp_content(content: list[ToolCallContent] | None) -> list[ToolCallContentItem]:
+    """Convert ACP ToolCallContent list to native ToolCallContentItem list."""
+    if not content:
+        return []
+
+    result: list[ToolCallContentItem] = []
+    for item in content:
+        match item:
+            case TerminalToolCallContent(terminal_id=terminal_id):
+                result.append(TerminalContentItem(terminal_id=terminal_id))
+            case FileEditToolCallContent(path=path, old_text=old_text, new_text=new_text):
+                result.append(DiffContentItem(path=path, old_text=old_text, new_text=new_text))
+            case ContentToolCallContent(content=TextContentBlock(text=text)):
+                from agentpool.agents.events import TextContentItem
+
+                result.append(TextContentItem(text=text))
+    return result
+
+
+def convert_to_acp_content(prompts: Sequence[UserContent]) -> list[ContentBlock]:
+    """Convert pydantic-ai UserContent to ACP ContentBlock format.
+
+    Handles text, images, audio, video, and document content types.
+
+    Args:
+        prompts: pydantic-ai UserContent items
+
+    Returns:
+        List of ACP ContentBlock items
+    """
+    content_blocks: list[ContentBlock] = []
+
+    for item in prompts:
+        match item:
+            case str(text):
+                content_blocks.append(TextContentBlock(text=text))
+
+            case BinaryImage(data=data, media_type=media_type):
+                encoded = base64.b64encode(data).decode("utf-8")
+                content_blocks.append(ImageContentBlock(data=encoded, mime_type=media_type))
+
+            case BinaryContent(data=data, media_type=media_type):
+                encoded = base64.b64encode(data).decode("utf-8")
+                # Handle different media types
+                if media_type and media_type.startswith("image/"):
+                    content_blocks.append(ImageContentBlock(data=encoded, mime_type=media_type))
+                elif media_type and media_type.startswith("audio/"):
+                    content_blocks.append(AudioContentBlock(data=encoded, mime_type=media_type))
+                elif media_type == "application/pdf":
+                    blob_resource = BlobResourceContents(
+                        blob=encoded,
+                        mime_type="application/pdf",
+                        uri=f"data:application/pdf;base64,{encoded[:50]}...",
+                    )
+                    content_blocks.append(EmbeddedResourceContentBlock(resource=blob_resource))
+                else:
+                    # Generic binary as embedded resource
+                    blob_resource = BlobResourceContents(
+                        blob=encoded,
+                        mime_type=media_type or "application/octet-stream",
+                        uri=f"data:{media_type or 'application/octet-stream'};base64,...",
+                    )
+                    content_blocks.append(EmbeddedResourceContentBlock(resource=blob_resource))
+
+            case ImageUrl(url=url, media_type=typ):
+                content_blocks.append(
+                    ResourceContentBlock(uri=url, name="Image", mime_type=typ or "image/jpeg")
+                )
+
+            case AudioUrl(url=url, media_type=media_type):
+                content_blocks.append(
+                    ResourceContentBlock(
+                        uri=url,
+                        name="Audio",
+                        mime_type=media_type or "audio/wav",
+                        description="Audio content",
+                    )
+                )
+
+            case DocumentUrl(url=url, media_type=media_type):
+                content_blocks.append(
+                    ResourceContentBlock(
+                        uri=url,
+                        name="Document",
+                        mime_type=media_type or "application/pdf",
+                        description="Document",
+                    )
+                )
+
+            case VideoUrl(url=url, media_type=media_type):
+                content_blocks.append(
+                    ResourceContentBlock(
+                        uri=url,
+                        name="Video",
+                        mime_type=media_type or "video/mp4",
+                        description="Video content",
+                    )
+                )
+
+    return content_blocks
+
+
+def acp_to_native_event(update: SessionUpdate) -> RichAgentStreamEvent[Any] | None:  # noqa: PLR0911
+    """Convert ACP session update to native streaming event.
+
+    Args:
+        update: ACP SessionUpdate from session/update notification
+
+    Returns:
+        Corresponding native event, or None if no mapping exists
+    """
+    match update:
+        # Text message chunks -> PartDeltaEvent with TextPartDelta
+        case AgentMessageChunk(content=TextContentBlock(text=text)):
+            return PartDeltaEvent(index=0, delta=TextPartDelta(content_delta=text))
+        # Thought chunks -> PartDeltaEvent with ThinkingPartDelta
+        case AgentThoughtChunk(content=TextContentBlock(text=text)):
+            return PartDeltaEvent(index=0, delta=ThinkingPartDelta(content_delta=text))
+        # User message echo - could emit as PartStartEvent if needed
+        case UserMessageChunk():
+            return None  # Usually ignored
+        # Tool call start -> ToolCallStartEvent
+        case ToolCallStart() as tc:
+            return ToolCallStartEvent(
+                tool_call_id=tc.tool_call_id,
+                tool_name=tc.title,  # ACP uses title, not separate tool_name
+                title=tc.title,
+                kind=tc.kind or "other",
+                content=convert_acp_content(list(tc.content) if tc.content else None),
+                locations=convert_acp_locations(list(tc.locations) if tc.locations else None),
+                raw_input=tc.raw_input or {},
+            )
+
+        # Tool call progress -> ToolCallProgressEvent
+        case ToolCallProgress() as tc:
+            items = convert_acp_content(list(tc.content) if tc.content else None)
+            return ToolCallProgressEvent(
+                tool_call_id=tc.tool_call_id,
+                status=tc.status or "in_progress",
+                title=tc.title,
+                items=items,
+                message=str(tc.raw_output) if tc.raw_output else None,
+            )
+
+        # Plan update -> PlanUpdateEvent
+        case AgentPlanUpdate(entries=acp_entries):
+            from agentpool.resource_providers.plan_provider import PlanEntry
+
+            native_entries = [
+                PlanEntry(content=e.content, priority=e.priority, status=e.status)
+                for e in acp_entries
+            ]
+            return PlanUpdateEvent(entries=native_entries)
+
+        case _:
+            return None
+
+
+@overload
+def mcp_config_to_acp(config: StdioMCPServerConfig) -> StdioMcpServer | None: ...
+
+
+@overload
+def mcp_config_to_acp(config: SSEMCPServerConfig) -> SseMcpServer | None: ...
+
+
+@overload
+def mcp_config_to_acp(config: StreamableHTTPMCPServerConfig) -> HttpMcpServer | None: ...
+
+
+@overload
+def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None: ...
+
+
+def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None:
+    """Convert native MCPServerConfig to ACP McpServer format.
+
+    Args:
+        config: agentpool MCP server configuration
+
+    Returns:
+        ACP-compatible McpServer instance, or None if conversion not possible
+    """
+    from acp.schema.common import EnvVariable
+    from acp.schema.mcp import HttpMcpServer, SseMcpServer, StdioMcpServer
+    from agentpool_config.mcp_server import (
+        SSEMCPServerConfig,
+        StdioMCPServerConfig,
+        StreamableHTTPMCPServerConfig,
+    )
+
+    match config:
+        case StdioMCPServerConfig(command=command, args=args):
+            env_vars = config.get_env_vars() if hasattr(config, "get_env_vars") else {}
+            return StdioMcpServer(
+                name=config.name or command,
+                command=command,
+                args=list(args) if args else [],
+                env=[EnvVariable(name=k, value=v) for k, v in env_vars.items()],
+            )
+        case SSEMCPServerConfig(url=url):
+            return SseMcpServer(name=config.name or str(url), url=url, headers=[])
+        case StreamableHTTPMCPServerConfig(url=url):
+            return HttpMcpServer(name=config.name or str(url), url=url, headers=[])
+        case _:
+            return None
+
+
+def mcp_configs_to_acp(configs: Sequence[MCPServerConfig]) -> list[McpServer]:
+    """Convert a sequence of MCPServerConfig to ACP McpServer list.
+
+    Args:
+        configs: Sequence of agentpool MCP server configurations
+
+    Returns:
+        List of ACP-compatible McpServer instances (skips unconvertible configs)
+    """
+    return [converted for config in configs if (converted := mcp_config_to_acp(config)) is not None]

agentpool/agents/acp_agent/client_handler.py

@@ -0,0 +1,317 @@
+"""ACP Agent - MessageNode wrapping an external ACP subprocess."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+import uuid
+
+import anyio
+
+from acp.client.protocol import Client
+from acp.schema import (
+    CreateTerminalResponse,
+    KillTerminalCommandResponse,
+    ReadTextFileResponse,
+    ReleaseTerminalResponse,
+    RequestPermissionResponse,
+    TerminalOutputResponse,
+    WaitForTerminalExitResponse,
+    WriteTextFileResponse,
+)
+from agentpool.log import get_logger
+from agentpool.tools.base import Tool
+
+
+if TYPE_CHECKING:
+    from exxec import ExecutionEnvironment
+
+    from acp.schema import (
+        CreateTerminalRequest,
+        KillTerminalCommandRequest,
+        ReadTextFileRequest,
+        ReleaseTerminalRequest,
+        RequestPermissionRequest,
+        SessionNotification,
+        TerminalOutputRequest,
+        WaitForTerminalExitRequest,
+        WriteTextFileRequest,
+    )
+    from agentpool.agents.acp_agent import ACPAgent
+    from agentpool.agents.acp_agent.session_state import ACPSessionState
+    from agentpool.ui.base import InputProvider
+    from agentpool_config.nodes import ToolConfirmationMode
+
+logger = get_logger(__name__)
+
+
+class ACPClientHandler(Client):
+    """Client handler that collects session updates and handles agent requests.
+
+    This implements the full ACP Client protocol including:
+    - Session update collection (text chunks, thoughts, tool calls)
+    - Filesystem operations (read/write files) via ExecutionEnvironment
+    - Terminal operations (create, output, kill, release) via ProcessManager
+    - Permission request handling via InputProvider
+
+    The handler accumulates session updates in an ACPSessionState instance,
+    allowing the ACPAgent to build the final response from streamed chunks.
+
+    Uses ExecutionEnvironment for all file and process operations, enabling
+    swappable backends (local, Docker, E2B, SSH, etc.).
+
+    The handler holds a reference to the parent ACPAgent, delegating env access
+    to ensure the env stays in sync when reassigned externally.
+    """
+
+    def __init__(
+        self,
+        agent: ACPAgent[Any],
+        state: ACPSessionState,
+        input_provider: InputProvider | None = None,
+    ) -> None:
+        self._agent = agent
+        self.state = state
+        self._input_provider = input_provider
+        self._update_event = asyncio.Event()
+        # Map ACP terminal IDs to process manager IDs
+        self._terminal_to_process: dict[str, str] = {}
+        # Copy tool confirmation mode from agent (can be updated via set_tool_confirmation_mode)
+        self.tool_confirmation_mode: ToolConfirmationMode = agent.tool_confirmation_mode
+
+    @property
+    def env(self) -> ExecutionEnvironment:
+        """Get execution environment for subprocess requests.
+
+        Uses the agent's client_env which handles subprocess file/terminal
+        operations. Falls back to agent's main env if not explicitly configured.
+        """
+        return self._agent.client_env
+
+    @property
+    def allow_file_operations(self) -> bool:
+        return self._agent.config.allow_file_operations
+
+    @property
+    def allow_terminal(self) -> bool:
+        return self._agent.config.allow_terminal
+
+    async def session_update(self, params: SessionNotification[Any]) -> None:
+        """Handle session update notifications from the agent."""
+        from agentpool.agents.acp_agent.acp_converters import acp_to_native_event
+
+        update = params.update
+        # Convert to native event and queue it
+        if native_event := acp_to_native_event(update):
+            self.state.events.append(native_event)
+        self._update_event.set()
+
+    async def request_permission(  # noqa: PLR0911
+        self, params: RequestPermissionRequest
+    ) -> RequestPermissionResponse:
+        """Handle permission requests via InputProvider."""
+        name = params.tool_call.title or "operation"
+        logger.info("Permission requested", tool_name=name)
+
+        # Check tool_confirmation_mode FIRST, before any forwarding
+        # This ensures "bypass permissions" mode works even for nested ACP agents
+        if self.tool_confirmation_mode == "never" and params.options:
+            option_id = params.options[0].option_id
+            logger.debug("Auto-granting permission (tool_confirmation_mode=never)", tool_name=name)
+            return RequestPermissionResponse.allowed(option_id)
+
+        # Try callback second (forwards to parent session for nested ACP agents)
+        if self._agent.acp_permission_callback:
+            # return RequestPermissionResponse.allowed(option_id=params.options[0].option_id) # "acceptEdits"  # noqa: E501
+            try:
+                logger.debug("Forwarding permission via callback", tool_name=name)
+                response = await self._agent.acp_permission_callback(params)
+                logger.debug(
+                    "Permission response received", tool_name=name, outcome=response.outcome.outcome
+                )
+            except Exception:
+                logger.exception("Failed to forward permission via callback")
+                # Fall through to old logic
+            else:
+                return response
+
+        if self._input_provider:
+            ctx = self._agent.get_context()  # Use the agent's NodeContext
+            # Create a dummy tool representation from ACP params
+            tool = Tool(callable=lambda: None, name=params.tool_call.tool_call_id, description=name)
+            # Extract arguments - ACP doesn't expose them in ToolCall
+            try:
+                result = await self._input_provider.get_tool_confirmation(ctx, tool=tool, args={})
+                # Map confirmation result to ACP response
+                if result == "allow":
+                    option_id = params.options[0].option_id if params.options else "allow"
+                    return RequestPermissionResponse.allowed(option_id)
+                if result == "skip":
+                    return RequestPermissionResponse.denied()
+                return RequestPermissionResponse.denied()  # abort_run
+
+            except Exception:
+                logger.exception("Failed to get permission via input provider")
+                return RequestPermissionResponse.denied()
+
+        logger.debug("Denying permission (no input provider)", tool_name=name)
+        return RequestPermissionResponse.denied()
+
+    async def read_text_file(self, params: ReadTextFileRequest) -> ReadTextFileResponse:
+        """Read text from file via ExecutionEnvironment filesystem."""
+        if not self.allow_file_operations:
+            raise RuntimeError("File operations not allowed")
+
+        fs = self.env.get_fs()
+        try:
+            content_bytes = await fs._cat_file(params.path)
+            content = content_bytes.decode("utf-8")
+            # Apply line filtering if requested
+            if params.line is not None or params.limit is not None:
+                lines = content.splitlines(keepends=True)
+                start_line = (params.line - 1) if params.line else 0
+                end_line = start_line + params.limit if params.limit else len(lines)
+                content = "".join(lines[start_line:end_line])
+
+            logger.debug("Read file", path=params.path, num_chars=len(content))
+            return ReadTextFileResponse(content=content)
+
+        except FileNotFoundError:
+            logger.exception("File not found", path=params.path)
+            raise
+        except Exception:
+            logger.exception("Failed to read file", path=params.path)
+            raise
+
+    async def write_text_file(self, params: WriteTextFileRequest) -> WriteTextFileResponse:
+        """Write text to file via ExecutionEnvironment filesystem."""
+        if not self.allow_file_operations:
+            raise RuntimeError("File operations not allowed")
+        fs = self.env.get_fs()
+        content_bytes = params.content.encode("utf-8")
+        parent = str(Path(params.path).parent)
+        try:
+            if parent and parent != ".":  # Ensure parent directory exists
+                await fs._makedirs(parent, exist_ok=True)
+            await fs._pipe_file(params.path, content_bytes)
+            logger.debug("Wrote file", path=params.path, num_chars=len(params.content))
+            return WriteTextFileResponse()
+        except Exception:
+            logger.exception("Failed to write file", path=params.path)
+            raise
+
+    async def create_terminal(self, params: CreateTerminalRequest) -> CreateTerminalResponse:
+        """Create a new terminal session via ProcessManager."""
+        if not self.allow_terminal:
+            raise RuntimeError("Terminal operations not allowed")
+        try:
+            process_id = await self.env.process_manager.start_process(
+                command=params.command,
+                args=list(params.args) if params.args else None,
+                cwd=params.cwd,
+                env={var.name: var.value for var in params.env or []},
+            )
+        except Exception:
+            logger.exception("Failed to create terminal", command=params.command)
+            raise
+        else:
+            terminal_id = f"term_{uuid.uuid4().hex[:8]}"
+            self._terminal_to_process[terminal_id] = process_id
+            msg = "Created terminal"
+            logger.info(msg, terminal_id=terminal_id, process_id=process_id, cmd=params.command)
+            return CreateTerminalResponse(terminal_id=terminal_id)
+
+    async def terminal_output(self, params: TerminalOutputRequest) -> TerminalOutputResponse:
+        """Get output from terminal via ProcessManager."""
+        if not self.allow_terminal:
+            raise RuntimeError("Terminal operations not allowed")
+
+        terminal_id = params.terminal_id
+        if terminal_id not in self._terminal_to_process:
+            raise ValueError(f"Terminal {terminal_id} not found")
+
+        process_id = self._terminal_to_process[terminal_id]
+        proc_output = await self.env.process_manager.get_output(process_id)
+        output = proc_output.combined or proc_output.stdout or ""
+        return TerminalOutputResponse(output=output, truncated=proc_output.truncated)
+
+    async def wait_for_terminal_exit(
+        self, params: WaitForTerminalExitRequest
+    ) -> WaitForTerminalExitResponse:
+        """Wait for terminal process to exit via ProcessManager."""
+        if not self.allow_terminal:
+            raise RuntimeError("Terminal operations not allowed")
+
+        terminal_id = params.terminal_id
+        if terminal_id not in self._terminal_to_process:
+            raise ValueError(f"Terminal {terminal_id} not found")
+
+        process_id = self._terminal_to_process[terminal_id]
+        exit_code = await self.env.process_manager.wait_for_exit(process_id)
+        logger.debug("Terminal exited", terminal_id=terminal_id, exit_code=exit_code)
+        return WaitForTerminalExitResponse(exit_code=exit_code)
+
+    async def kill_terminal(
+        self, params: KillTerminalCommandRequest
+    ) -> KillTerminalCommandResponse:
+        """Kill terminal process via ProcessManager."""
+        if not self.allow_terminal:
+            raise RuntimeError("Terminal operations not allowed")
+
+        terminal_id = params.terminal_id
+        if terminal_id not in self._terminal_to_process:
+            raise ValueError(f"Terminal {terminal_id} not found")
+
+        process_id = self._terminal_to_process[terminal_id]
+        await self.env.process_manager.kill_process(process_id)
+        logger.info("Killed terminal", terminal_id=terminal_id)
+        return KillTerminalCommandResponse()
+
+    async def release_terminal(self, params: ReleaseTerminalRequest) -> ReleaseTerminalResponse:
+        """Release terminal resources via ProcessManager."""
+        if not self.allow_terminal:
+            raise RuntimeError("Terminal operations not allowed")
+
+        terminal_id = params.terminal_id
+        if terminal_id not in self._terminal_to_process:
+            raise ValueError(f"Terminal {terminal_id} not found")
+        process_id = self._terminal_to_process[terminal_id]
+        await self.env.process_manager.release_process(process_id)
+        del self._terminal_to_process[terminal_id]
+        logger.info("Released terminal", terminal_id=terminal_id)
+        return ReleaseTerminalResponse()
+
+    async def cleanup(self) -> None:
+        """Clean up all resources."""
+        for terminal_id, process_id in list(self._terminal_to_process.items()):
+            try:
+                await self.env.process_manager.release_process(process_id)
+            except Exception:
+                logger.exception("Error cleaning up terminal", terminal_id=terminal_id)
+
+        self._terminal_to_process.clear()
+
+    async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        """Handle extension methods."""
+        logger.debug("Extension method called", method=method)
+        return {"ok": True, "method": method}
+
+    async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
+        """Handle extension notifications."""
+        logger.debug("Extension notification", method=method)
+
+
+if __name__ == "__main__":
+    from agentpool.agents.acp_agent import ACPAgent
+
+    async def main() -> None:
+        """Demo: Basic call to an ACP agent."""
+        args = ["run", "agentpool", "serve-acp", "--model-provider", "openai"]
+        cwd = str(Path.cwd())
+        async with ACPAgent(command="uv", args=args, cwd=cwd, event_handlers=["detailed"]) as agent:
+            print("Response (streaming): ", end="", flush=True)
+            async for chunk in agent.run_stream("Say hello briefly."):
+                print(chunk, end="", flush=True)
+
+    anyio.run(main)

agentpool/agents/acp_agent/session_state.py

@@ -0,0 +1,44 @@
+"""ACP Agent - MessageNode wrapping an external ACP subprocess."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field as dataclass_field
+from typing import TYPE_CHECKING, Any
+
+from agentpool.log import get_logger
+
+
+if TYPE_CHECKING:
+    from acp.schema import SessionModelState, SessionModeState
+    from agentpool.agents.events import RichAgentStreamEvent
+
+logger = get_logger(__name__)
+
+PROTOCOL_VERSION = 1
+
+
+@dataclass
+class ACPSessionState:
+    """Tracks state of an ACP session."""
+
+    session_id: str
+    """The session ID from the ACP server."""
+
+    events: list[RichAgentStreamEvent[Any]] = dataclass_field(default_factory=list)
+    """Queue of native events converted from ACP updates."""
+
+    current_model_id: str | None = None
+    """Current model ID from session state."""
+
+    models: SessionModelState | None = None
+    """Full model state including available models from nested ACP agent."""
+
+    modes: SessionModeState | None = None
+    """Full mode state including available modes from nested ACP agent."""
+
+    current_mode_id: str | None = None
+    """Current mode ID."""
+
+    def clear(self) -> None:
+        self.events.clear()
+        # Note: Don't clear current_model_id or models - those persist across prompts