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

acp/__init__.py

@@ -3,7 +3,6 @@
 from acp.client import DefaultACPClient, HeadlessACPClient, NoOpClient, ClientSideConnection
 from acp.agent import AgentSideConnection
 from acp.bridge import ACPBridge, BridgeSettings
-from acp.filesystem import ACPFileSystem, ACPPath
 from acp.agent.protocol import Agent
 from acp.client.protocol import Client
 from acp.terminal_handle import TerminalHandle
@@ -73,6 +72,13 @@ from acp.schema import (
     ToolCall,
 )
 from acp.stdio import stdio_streams, run_agent, connect_to_agent
+from acp.transports import (
+    serve,
+    StdioTransport,
+    WebSocketTransport,
+    StreamTransport,
+    Transport,
+)
 from acp.exceptions import RequestError
 
 __version__ = "0.0.1"
@@ -166,7 +172,10 @@ __all__ = [  # noqa: RUF022
     "FileSystemCapability",
     # stdio helper
     "stdio_streams",
-    # filesystem
-    "ACPFileSystem",
-    "ACPPath",
+    # transport
+    "serve",
+    "StdioTransport",
+    "WebSocketTransport",
+    "StreamTransport",
+    "Transport",
 ]

acp/acp_requests.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import asyncio
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
+
+import structlog
 
 from acp.schema import (
     CreateTerminalRequest,
@@ -19,7 +21,6 @@ from acp.schema import (
     WriteTextFileRequest,
 )
 from acp.terminal_handle import TerminalHandle
-from agentpool.log import get_logger
 
 
 if TYPE_CHECKING:
@@ -30,20 +31,10 @@ if TYPE_CHECKING:
         WaitForTerminalExitResponse,
     )
 
-logger = get_logger(__name__)
+logger = structlog.get_logger(__name__)
 
 
-RULES_FILE_NAMES = [
-    ".rules",
-    "CLAUDE.md",
-    "AGENT.md",
-    "AGENTS.md",
-    "GEMINI.md",
-    ".cursorrules",
-    ".windsurfrules",
-    ".clinerules",
-    ".github/copilot-instructions.md",
-]
+RULES_FILE_NAMES = ["CLAUDE.md", "AGENTS.md"]
 
 
 class ACPRequests:
@@ -54,12 +45,7 @@ class ACPRequests:
     """
 
     def __init__(self, client: Client, session_id: str) -> None:
-        """Initialize requests helper.
-
-        Args:
-            client: ACP client
-            session_id: Session ID
-        """
+        """Initialize requests helper."""
         self.client = client
         self.id = session_id
 
@@ -80,12 +66,7 @@ class ACPRequests:
         Returns:
             File content as string
         """
-        request = ReadTextFileRequest(
-            session_id=self.id,
-            path=path,
-            limit=limit,
-            line=line,
-        )
+        request = ReadTextFileRequest(session_id=self.id, path=path, limit=limit, line=line)
         response = await self.client.read_text_file(request)
         return response.content
 
@@ -104,12 +85,7 @@ class ACPRequests:
         return None
 
     async def write_text_file(self, path: str, content: str) -> None:
-        """Write text content to a file.
-
-        Args:
-            path: File path to write
-            content: Text content to write
-        """
+        """Write text content to a file."""
         request = WriteTextFileRequest(session_id=self.id, path=path, content=content)
         await self.client.write_text_file(request)
 
@@ -146,47 +122,22 @@ class ACPRequests:
         return TerminalHandle(terminal_id=response.terminal_id, requests=self)
 
     async def terminal_output(self, terminal_id: str) -> TerminalOutputResponse:
-        """Get output from a terminal session.
-
-        Args:
-            terminal_id: Terminal identifier
-
-        Returns:
-            Terminal output response
-        """
+        """Get output from a terminal session."""
         request = TerminalOutputRequest(session_id=self.id, terminal_id=terminal_id)
         return await self.client.terminal_output(request)
 
-    async def wait_for_terminal_exit(
-        self,
-        terminal_id: str,
-    ) -> WaitForTerminalExitResponse:
-        """Wait for a terminal to exit.
-
-        Args:
-            terminal_id: Terminal identifier
-
-        Returns:
-            Terminal exit response with exit_code
-        """
+    async def wait_for_terminal_exit(self, terminal_id: str) -> WaitForTerminalExitResponse:
+        """Wait for a terminal to exit."""
         request = WaitForTerminalExitRequest(session_id=self.id, terminal_id=terminal_id)
         return await self.client.wait_for_terminal_exit(request)
 
     async def kill_terminal(self, terminal_id: str) -> None:
-        """Kill a terminal session.
-
-        Args:
-            terminal_id: Terminal identifier to kill
-        """
+        """Kill a terminal session."""
         request = KillTerminalCommandRequest(session_id=self.id, terminal_id=terminal_id)
         await self.client.kill_terminal(request)
 
     async def release_terminal(self, terminal_id: str) -> None:
-        """Release a terminal session.
-
-        Args:
-            terminal_id: Terminal identifier to release
-        """
+        """Release a terminal session."""
         request = ReleaseTerminalRequest(session_id=self.id, terminal_id=terminal_id)
         await self.client.release_terminal(request)
 
@@ -228,10 +179,8 @@ class ACPRequests:
         try:
             if timeout_seconds:  # Wait for completion (with optional timeout)
                 try:
-                    exit_result = await asyncio.wait_for(
-                        self.wait_for_terminal_exit(terminal_id),
-                        timeout=timeout_seconds,
-                    )
+                    coro = self.wait_for_terminal_exit(terminal_id)
+                    exit_result = await asyncio.wait_for(coro, timeout=timeout_seconds)
                 except TimeoutError:  # Kill on timeout and get partial output
                     await self.kill_terminal(terminal_id)
                     output_response = await self.terminal_output(terminal_id)
@@ -250,6 +199,7 @@ class ACPRequests:
         tool_call_id: str,
         *,
         title: str | None = None,
+        raw_input: Any | None = None,
         options: list[PermissionOption] | None = None,
     ) -> RequestPermissionResponse:
         """Request permission from user before executing a tool call.
@@ -257,6 +207,7 @@ class ACPRequests:
         Args:
             tool_call_id: Unique identifier for the tool call
             title: Human-readable description of the operation
+            raw_input: The raw input parameters for the tool call
             options: Available permission options (defaults to allow/reject once)
 
         Returns:
@@ -264,19 +215,11 @@ class ACPRequests:
         """
         if options is None:
             options = [
-                PermissionOption(
-                    option_id="allow-once",
-                    name="Allow once",
-                    kind="allow_once",
-                ),
-                PermissionOption(
-                    option_id="reject-once",
-                    name="Reject",
-                    kind="reject_once",
-                ),
+                PermissionOption(option_id="allow-once", name="Allow once", kind="allow_once"),
+                PermissionOption(option_id="reject-once", name="Reject", kind="reject_once"),
             ]
 
-        tool_call = ToolCall(tool_call_id=tool_call_id, title=title)
+        tool_call = ToolCall(tool_call_id=tool_call_id, title=title, raw_input=raw_input)
         request = RequestPermissionRequest(
             session_id=self.id,
             tool_call=tool_call,

acp/agent/connection.py

@@ -30,6 +30,7 @@ from acp.schema import (
     RequestPermissionRequest,
     RequestPermissionResponse,
     SessionNotification,
+    SetSessionConfigOptionRequest,
     SetSessionModelRequest,
     SetSessionModeRequest,
     TerminalOutputRequest,
@@ -243,6 +244,13 @@ async def _agent_handler(  # noqa: PLR0911
                 if (model_result := await agent.set_session_model(set_model_request))
                 else {}
             )
+        case "session/set_config_option":
+            set_config_request = SetSessionConfigOptionRequest.model_validate(params)
+            return (
+                config_result.model_dump(by_alias=True, exclude_none=True)
+                if (config_result := await agent.set_session_config_option(set_config_request))
+                else {}
+            )
         case "authenticate":
             p = AuthenticateRequest.model_validate(params)
             result = await agent.authenticate(p)

acp/agent/implementations/debug_server/debug_server.py

@@ -25,6 +25,7 @@ import anyio
 from fastapi import FastAPI, HTTPException
 from fastapi.responses import HTMLResponse
 from pydantic import BaseModel, Field
+import structlog
 import uvicorn
 
 from acp import AgentSideConnection
@@ -57,7 +58,6 @@ from acp.schema import (
     WriteTextFileResponse,
 )
 from acp.stdio import stdio_streams
-from agentpool.log import get_logger
 
 
 if TYPE_CHECKING:
@@ -81,7 +81,7 @@ if TYPE_CHECKING:
     )
 
 
-logger = get_logger(__name__)
+logger = structlog.get_logger(__name__)
 MOCK_FILE = """\
 # Mock file: {path}
 # Generated by ACP Debug Server
@@ -190,6 +190,10 @@ class MockAgent(Agent):
         """Mock session model change."""
         logger.info("Mock session model change")
 
+    async def set_session_config_option(self, params: Any) -> None:
+        """Mock session config option change."""
+        logger.info("Mock session config option change")
+
     async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
         """Mock extensibility notification."""
         logger.info("Mock ext notification", method=method)

acp/agent/protocol.py

@@ -24,6 +24,8 @@ if TYPE_CHECKING:
         PromptResponse,
         ResumeSessionRequest,
         ResumeSessionResponse,
+        SetSessionConfigOptionRequest,
+        SetSessionConfigOptionResponse,
         SetSessionModelRequest,
         SetSessionModelResponse,
         SetSessionModeRequest,
@@ -60,6 +62,10 @@ class Agent(Protocol):
         self, params: SetSessionModelRequest
     ) -> SetSessionModelResponse | None: ...
 
+    async def set_session_config_option(
+        self, params: SetSessionConfigOptionRequest
+    ) -> SetSessionConfigOptionResponse | None: ...
+
     async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]: ...
 
     async def ext_notification(self, method: str, params: dict[str, Any]) -> None: ...

acp/bridge/README.md

@@ -1,10 +1,23 @@
 # ACP Bridge
 
-A stdio-to-HTTP bridge for ACP (Agent Client Protocol) agents.
+Bridges for exposing **external** stdio-based ACP agents over network transports.
+
+## When to Use
+
+**Use the bridge** when you need to expose an **external** stdio-based ACP agent (one you don't control) over HTTP or WebSocket.
+
+**Use native transports** when building your own agent with the `acp` library. The `acp.serve()` function supports multiple transports directly:
+
+```python
+from acp import serve, WebSocketTransport
+
+# Native WebSocket transport (no bridge needed)
+await serve(my_agent, WebSocketTransport(host="0.0.0.0", port=8765))
+```
 
 ## Overview
 
-The ACP Bridge allows you to expose stdio-based ACP agents via a streamable HTTP endpoint. This is useful when you want to run an agent as a subprocess but communicate with it over HTTP instead of stdio.
+The ACP Bridge allows you to expose stdio-based ACP agents via HTTP or WebSocket endpoints. This is useful when you want to run an external agent as a subprocess but communicate with it over the network instead of stdio.
 
 ## Features
 

acp/bridge/__init__.py

@@ -1,6 +1,7 @@
-"""ACP Bridge - stdio to streamable-http transport bridge for ACP agents."""
+"""ACP Bridge - transport bridges for ACP agents."""
 
 from acp.bridge.bridge import ACPBridge
 from acp.bridge.settings import BridgeSettings
+from acp.bridge.ws_server import ACPWebSocketServer
 
-__all__ = ["ACPBridge", "BridgeSettings"]
+__all__ = ["ACPBridge", "ACPWebSocketServer", "BridgeSettings"]

acp/bridge/__main__.py

@@ -1,8 +1,13 @@
 """CLI entry point for running the ACP bridge.
 
 Usage:
-    uv run -m acp_bridge <command> [args...]
-    uv run -m acp_bridge --port 8080 -- your-agent-command --arg1 value1
+    # HTTP bridge (default)
+    uv run -m acp.bridge <command> [args...]
+    uv run -m acp.bridge --port 8080 -- your-agent-command --arg1 value1
+
+    # WebSocket bridge
+    uv run -m acp.bridge --transport websocket <command> [args...]
+    uv run -m acp.bridge -t ws --port 8765 -- uv run agentpool serve-acp
 """
 
 from __future__ import annotations
@@ -18,24 +23,35 @@ import anyio
 def main() -> None:
     """Run the ACP bridge from command line."""
     parser = argparse.ArgumentParser(
-        description="Bridge a stdio ACP agent to streamable HTTP transport.",
+        description="Bridge a stdio ACP agent to HTTP or WebSocket transport.",
         epilog=(
             "Examples:\n"
+            "  # HTTP bridge\n"
             "  acp-bridge your-agent-command\n"
             "  acp-bridge --port 8080 -- your-agent --config config.yml\n"
-            "  acp-bridge -H 0.0.0.0 -p 9000 -- uv run my-agent\n"
+            "\n"
+            "  # WebSocket bridge\n"
+            "  acp-bridge -t ws -- uv run agentpool serve-acp\n"
+            "  acp-bridge --transport websocket --port 8765 -- uv run my-agent\n"
         ),
         formatter_class=argparse.RawTextHelpFormatter,
     )
 
     parser.add_argument("command", help="Command to spawn the ACP agent.")
     parser.add_argument("args", nargs="*", help="Arguments for the agent command.")
+    parser.add_argument(
+        "-t",
+        "--transport",
+        choices=["http", "websocket", "ws"],
+        default="http",
+        help="Transport type: http (default) or websocket/ws",
+    )
     parser.add_argument(
         "-p",
         "--port",
         type=int,
-        default=8080,
-        help="Port to serve the HTTP endpoint on. Default: 8080",
+        default=None,
+        help="Port to serve on. Default: 8080 (HTTP) or 8765 (WebSocket)",
     )
     parser.add_argument(
         "-H",
@@ -53,7 +69,7 @@ def main() -> None:
         "--allow-origin",
         action="append",
         default=[],
-        help="Allowed CORS origins. Can be specified multiple times.",
+        help="Allowed CORS origins (HTTP only). Can be specified multiple times.",
     )
     parser.add_argument(
         "--cwd",
@@ -69,22 +85,47 @@ def main() -> None:
 
     logging.basicConfig(
         level=getattr(logging, parsed.log_level),
-        format="[%(levelname)1.1s %(asctime)s.%(msecs)03d %(name)s] %(message)s",
-        datefmt="%H:%M:%S",
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
     )
 
-    from acp.bridge import ACPBridge, BridgeSettings
+    use_websocket = parsed.transport in ("websocket", "ws")
 
-    settings = BridgeSettings(
-        host=parsed.host,
-        port=parsed.port,
-        log_level=parsed.log_level,
-        allow_origins=parsed.allow_origin if parsed.allow_origin else None,
-    )
+    if use_websocket:
+        # Reduce websockets noise
+        logging.getLogger("websockets").setLevel(logging.WARNING)
+
+        from acp.bridge.ws_server import ACPWebSocketServer
+
+        port = parsed.port or 8765
+        server = ACPWebSocketServer(
+            command=parsed.command,
+            args=parsed.args,
+            host=parsed.host,
+            port=port,
+            cwd=parsed.cwd,
+        )
+
+        print(f"🔗 ACP WebSocket bridge starting on ws://{parsed.host}:{port}")
+        print(f"   Agent command: {parsed.command} {' '.join(parsed.args)}")
+
+        with contextlib.suppress(KeyboardInterrupt):
+            anyio.run(server.serve)
+    else:
+        from acp.bridge import ACPBridge, BridgeSettings
+
+        port = parsed.port or 8080
+        settings = BridgeSettings(
+            host=parsed.host,
+            port=port,
+            log_level=parsed.log_level,
+            allow_origins=parsed.allow_origin if parsed.allow_origin else None,
+        )
 
-    bridge = ACPBridge(command=parsed.command, args=parsed.args, cwd=parsed.cwd, settings=settings)
-    with contextlib.suppress(KeyboardInterrupt):
-        anyio.run(bridge.run)
+        bridge = ACPBridge(
+            command=parsed.command, args=parsed.args, cwd=parsed.cwd, settings=settings
+        )
+        with contextlib.suppress(KeyboardInterrupt):
+            anyio.run(bridge.run)
 
 
 if __name__ == "__main__":

acp/bridge/ws_server.py

@@ -0,0 +1,173 @@
+"""WebSocket server that bridges to a stdio ACP agent.
+
+Spawns a stdio-based ACP agent subprocess and exposes it via WebSocket,
+allowing clients like mcp-ws to connect.
+
+Usage:
+    python -m acp.bridge.ws_server "uv run agentpool serve-acp" --port 8765
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import logging
+from typing import TYPE_CHECKING, Any
+
+import anyenv
+import websockets
+
+from acp.transports import spawn_stdio_transport
+
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from pathlib import Path
+
+    from anyio.abc import ByteReceiveStream, ByteSendStream, Process
+    from websockets.asyncio.server import ServerConnection
+
+logger = logging.getLogger(__name__)
+
+
+class ACPWebSocketServer:
+    """WebSocket server that bridges to a stdio ACP agent."""
+
+    def __init__(
+        self,
+        command: str,
+        args: list[str] | None = None,
+        *,
+        host: str = "localhost",
+        port: int = 8765,
+        env: Mapping[str, str] | None = None,
+        cwd: str | Path | None = None,
+    ) -> None:
+        """Initialize the WebSocket server.
+
+        Args:
+            command: Command to spawn the ACP agent.
+            args: Arguments for the command.
+            host: Host to bind the WebSocket server to.
+            port: Port for the WebSocket server.
+            env: Environment variables for the subprocess.
+            cwd: Working directory for the subprocess.
+        """
+        self.command = command
+        self.args = args or []
+        self.host = host
+        self.port = port
+        self.env = env
+        self.cwd = cwd
+
+        self._process: Process | None = None
+        self._reader: ByteReceiveStream | None = None
+        self._writer: ByteSendStream | None = None
+        self._websocket: ServerConnection | None = None
+        self._shutdown = asyncio.Event()
+        self._read_buffer = b""
+
+    async def _read_jsonrpc_message(self) -> dict[str, Any] | None:
+        """Read a JSON-RPC message from the agent's stdout."""
+        if self._reader is None:
+            return None
+
+        while True:
+            # Check if we have a complete line in buffer
+            if b"\n" in self._read_buffer:
+                line, self._read_buffer = self._read_buffer.split(b"\n", 1)
+                if line.strip():
+                    try:
+                        return anyenv.load_json(line.decode(), return_type=dict)
+                    except anyenv.JsonLoadError:
+                        logger.exception("Failed to parse JSON from agent")
+                        continue
+
+            # Read more data
+            try:
+                chunk = await self._reader.receive(65536)
+                if not chunk:
+                    return None
+                self._read_buffer += chunk
+            except Exception:  # noqa: BLE001
+                return None
+
+    async def _send_to_agent(self, message: dict[str, Any]) -> None:
+        """Send a JSON-RPC message to the agent's stdin."""
+        if self._writer is None:
+            return
+
+        data = json.dumps(message) + "\n"
+        await self._writer.send(data.encode())
+
+    async def _agent_to_websocket(self) -> None:
+        """Forward messages from agent stdout to WebSocket."""
+        while not self._shutdown.is_set():
+            try:
+                message = await self._read_jsonrpc_message()
+                if message is None:
+                    logger.info("Agent stdout closed")
+                    break
+
+                if self._websocket is not None:
+                    await self._websocket.send(json.dumps(message))
+                    logger.debug("Agent → WebSocket: %s", message.get("method", message.get("id")))
+            except Exception:
+                logger.exception("Error forwarding agent → WebSocket")
+                break
+
+    async def _handle_client(self, websocket: ServerConnection) -> None:
+        """Handle a WebSocket client connection."""
+        logger.info("WebSocket client connected")
+        self._websocket = websocket
+
+        try:
+            async for raw_message in websocket:
+                try:
+                    message = json.loads(raw_message)
+                    logger.debug("WebSocket → Agent: %s", message.get("method", message.get("id")))
+                    await self._send_to_agent(message)
+                except json.JSONDecodeError:
+                    logger.exception("Invalid JSON from WebSocket")
+                    error_response = {
+                        "jsonrpc": "2.0",
+                        "id": None,
+                        "error": {"code": -32700, "message": "Parse error"},
+                    }
+                    await websocket.send(json.dumps(error_response))
+        except websockets.exceptions.ConnectionClosed:
+            logger.info("WebSocket client disconnected")
+        finally:
+            self._websocket = None
+
+    async def serve(self) -> None:
+        """Start the WebSocket server and agent process."""
+        cmd_str = f"{self.command} {' '.join(self.args)}".strip()
+        logger.info("Starting ACP agent: %s", cmd_str)
+
+        async with spawn_stdio_transport(self.command, *self.args, env=self.env, cwd=self.cwd) as (
+            reader,
+            writer,
+            process,
+        ):
+            self._reader = reader
+            self._writer = writer
+            self._process = process
+
+            # Start forwarding agent output to WebSocket
+            forward_task = asyncio.create_task(self._agent_to_websocket())
+
+            try:
+                async with websockets.serve(
+                    self._handle_client,
+                    self.host,
+                    self.port,
+                ):
+                    logger.info("WebSocket server running on ws://%s:%d", self.host, self.port)
+                    await self._shutdown.wait()
+            finally:
+                self._shutdown.set()
+                forward_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await forward_task