agentpool 2.1.9__py3-none-any.whl

acp/agent/connection.py

@@ -0,0 +1,256 @@
+"""Agent ACP Connection."""
+
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING, Any, Self
+
+import logfire
+
+from acp.agent.protocol import Agent
+from acp.client.protocol import Client
+from acp.connection import Connection
+from acp.exceptions import RequestError
+from acp.schema import (
+    AuthenticateRequest,
+    CancelNotification,
+    CreateTerminalRequest,
+    CreateTerminalResponse,
+    InitializeRequest,
+    KillTerminalCommandRequest,
+    KillTerminalCommandResponse,
+    ListSessionsRequest,
+    LoadSessionRequest,
+    NewSessionRequest,
+    PromptRequest,
+    ReadTextFileRequest,
+    ReadTextFileResponse,
+    ReleaseTerminalRequest,
+    ReleaseTerminalResponse,
+    RequestPermissionRequest,
+    RequestPermissionResponse,
+    SessionNotification,
+    SetSessionModelRequest,
+    SetSessionModeRequest,
+    TerminalOutputRequest,
+    TerminalOutputResponse,
+    WaitForTerminalExitRequest,
+    WaitForTerminalExitResponse,
+    WriteTextFileRequest,
+    WriteTextFileResponse,
+)
+from acp.task import DebuggingMessageStateStore
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from anyio.abc import ByteReceiveStream, ByteSendStream
+
+    from acp.agent.protocol import Agent
+    from acp.connection import StreamObserver
+    from acp.schema import (
+        AgentMethod,
+        CreateTerminalRequest,
+        InitializeResponse,
+        KillTerminalCommandRequest,
+        ListSessionsResponse,
+        LoadSessionResponse,
+        NewSessionResponse,
+        PromptResponse,
+        ReadTextFileRequest,
+        ReleaseTerminalRequest,
+        RequestPermissionRequest,
+        SessionNotification,
+        TerminalOutputRequest,
+        WaitForTerminalExitRequest,
+        WriteTextFileRequest,
+    )
+
+
+class AgentSideConnection(Client):
+    """Agent-side connection.
+
+    Use when you implement the Agent and need to talk to a Client.
+
+    Args:
+        to_agent: factory that receives this connection and returns your Agent
+        input: ByteSendStream (local -> peer)
+        output: ByteReceiveStream (peer -> local)
+    """
+
+    def __init__(
+        self,
+        to_agent: Callable[[AgentSideConnection], Agent],
+        input_stream: ByteSendStream,
+        output_stream: ByteReceiveStream,
+        observers: list[StreamObserver] | None = None,
+        *,
+        debug_file: str | None = None,
+    ) -> None:
+        """Initialize the agent-side connection.
+
+        Args:
+            to_agent: factory that receives this connection and returns your Agent
+            input_stream: ByteSendStream (local -> peer)
+            output_stream: ByteReceiveStream (peer -> local)
+            observers: list of StreamObserver instances to observe the connection
+            debug_file: path to a file to write debug information to
+        """
+        agent = to_agent(self)
+        handler = partial(_agent_handler, agent)
+        store = DebuggingMessageStateStore(debug_file=debug_file) if debug_file else None
+        self._conn = Connection(
+            handler,
+            input_stream,
+            output_stream,
+            state_store=store,
+            observers=observers,
+        )
+
+    # client-bound methods (agent -> client)
+    async def session_update(self, params: SessionNotification) -> None:
+        """Send session update notification."""
+        dct = params.model_dump(by_alias=True, exclude_none=True)
+        await self._conn.send_notification("session/update", dct)
+
+    async def request_permission(
+        self, params: RequestPermissionRequest
+    ) -> RequestPermissionResponse:
+        """Request permission from the client."""
+        dct = params.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True)
+        method = "session/request_permission"
+        resp = await self._conn.send_request(method, dct)
+        return RequestPermissionResponse.model_validate(resp)
+
+    async def read_text_file(self, params: ReadTextFileRequest) -> ReadTextFileResponse:
+        """Read text file from the client."""
+        dct = params.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True)
+        resp = await self._conn.send_request("fs/read_text_file", dct)
+        return ReadTextFileResponse.model_validate(resp)
+
+    async def write_text_file(self, params: WriteTextFileRequest) -> WriteTextFileResponse:
+        """Write text file to the client."""
+        dct = params.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True)
+        r = await self._conn.send_request("fs/write_text_file", dct)
+        return WriteTextFileResponse.model_validate(r)
+
+    # async def createTerminal(self, params: CreateTerminalRequest) -> TerminalHandle:
+    async def create_terminal(self, params: CreateTerminalRequest) -> CreateTerminalResponse:
+        """Create a terminal on the client."""
+        dct = params.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True)
+        resp = await self._conn.send_request("terminal/create", dct)
+        #  resp = CreateTerminalResponse.model_validate(resp)
+        #  return TerminalHandle(resp.terminal_id, params.session_id, self._conn)
+        return CreateTerminalResponse.model_validate(resp)
+
+    async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        """Call an extension method on the client."""
+        return await self._conn.send_request(f"_{method}", params)  # type: ignore[no-any-return]
+
+    async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
+        """Send an extension notification to the client."""
+        await self._conn.send_notification(f"_{method}", params)
+
+    async def terminal_output(self, params: TerminalOutputRequest) -> TerminalOutputResponse:
+        """Show terminal output on the client."""
+        dct = params.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True)
+        resp = await self._conn.send_request("terminal/output", dct)
+        return TerminalOutputResponse.model_validate(resp)
+
+    async def release_terminal(self, params: ReleaseTerminalRequest) -> ReleaseTerminalResponse:
+        """Release a terminal on the client."""
+        dct = params.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True)
+        resp = await self._conn.send_request("terminal/release", dct)
+        return ReleaseTerminalResponse.model_validate(resp)
+
+    async def wait_for_terminal_exit(
+        self, params: WaitForTerminalExitRequest
+    ) -> WaitForTerminalExitResponse:
+        """Wait for a terminal to exit on the client."""
+        dct = params.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True)
+        resp = await self._conn.send_request("terminal/wait_for_exit", dct)
+        return WaitForTerminalExitResponse.model_validate(resp)
+
+    async def kill_terminal(
+        self, params: KillTerminalCommandRequest
+    ) -> KillTerminalCommandResponse:
+        """Kill a terminal on the client."""
+        dct = params.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True)
+        resp = await self._conn.send_request("terminal/kill", dct)
+        return KillTerminalCommandResponse.model_validate(resp)
+
+    async def close(self) -> None:
+        """Close the connection."""
+        await self._conn.close()
+
+    async def __aenter__(self) -> Self:
+        """Enter the async context."""
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        """Exit the async context (close the connection)."""
+        await self.close()
+
+
+@logfire.instrument(r"Handle Agent Request {method}")
+async def _agent_handler(  # noqa: PLR0911
+    agent: Agent,
+    method: AgentMethod | str,
+    params: dict[str, Any] | None,
+    is_notification: bool,
+) -> (
+    NewSessionResponse
+    | InitializeResponse
+    | PromptResponse
+    | LoadSessionResponse
+    | ListSessionsResponse
+    | dict[str, Any]
+    | None
+):
+    """Handle an agent request."""
+    match method:
+        case "initialize":
+            initialize_request = InitializeRequest.model_validate(params)
+            return await agent.initialize(initialize_request)
+        case "session/new":
+            new_session_request = NewSessionRequest.model_validate(params)
+            return await agent.new_session(new_session_request)
+        case "session/load":
+            load_request = LoadSessionRequest.model_validate(params)
+            return await agent.load_session(load_request)
+        case "session/list":
+            list_request = ListSessionsRequest.model_validate(params)
+            return await agent.list_sessions(list_request)
+        case "session/set_mode":
+            set_mode_request = SetSessionModeRequest.model_validate(params)
+            return (
+                session_resp.model_dump(by_alias=True, exclude_none=True)
+                if (session_resp := await agent.set_session_mode(set_mode_request))
+                else {}
+            )
+        case "session/prompt":
+            prompt_request = PromptRequest.model_validate(params)
+            return await agent.prompt(prompt_request)
+        case "session/cancel":
+            cancel_notification = CancelNotification.model_validate(params)
+            await agent.cancel(cancel_notification)
+            return None
+        case "session/set_model":
+            set_model_request = SetSessionModelRequest.model_validate(params)
+            return (
+                model_result.model_dump(by_alias=True, exclude_none=True)
+                if (model_result := await agent.set_session_model(set_model_request))
+                else {}
+            )
+        case "authenticate":
+            p = AuthenticateRequest.model_validate(params)
+            result = await agent.authenticate(p)
+            return result.model_dump(by_alias=True, exclude_none=True) if result else {}
+        case str() if method.startswith("_") and is_notification:
+            await agent.ext_notification(method[1:], params or {})
+            return None
+        case str() if method.startswith("_"):
+            return await agent.ext_method(method[1:], params or {})
+        case _:
+            raise RequestError.method_not_found(method)

acp/agent/implementations/__init__.py

@@ -0,0 +1,6 @@
+"""Basic agent implementations."""
+
+from __future__ import annotations
+from .testing import TestAgent
+
+__all__ = ["TestAgent"]

acp/agent/implementations/debug_server/__init__.py

@@ -0,0 +1 @@
+"""ACP Debug Server."""

acp/agent/implementations/debug_server/cli.py

@@ -0,0 +1,79 @@
+"""CLI for ACP Debug Server.
+
+Simple command-line interface for the ACP debug server that combines
+ACP protocol server with FastAPI web interface for testing.
+"""
+
+import argparse
+import logging
+import sys
+
+import anyio
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="ACP Debug Server - Combined ACP + FastAPI testing server",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Run with defaults (ACP on stdio, web UI on localhost:8000)
+  python -m acp.cli
+
+  # Custom port for web interface
+  python -m acp.cli --port 9000
+
+  # Custom host and port
+  python -m acp.cli --host 0.0.0.0 --port 8080
+
+  # Test ACP connection
+  echo '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":1},"id":1}' | python -m acp
+
+  # Open web interface at http://localhost:8000 to manually send notifications
+        """,  # noqa: E501
+    )
+
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=7777,
+        help="Port for FastAPI web interface (default: 8000)",
+    )
+    parser.add_argument(
+        "--host",
+        default="127.0.0.1",
+        help="Host for FastAPI web interface (default: 127.0.0.1)",
+    )
+    parser.add_argument(
+        "--log-level",
+        choices=["debug", "info", "warning", "error"],
+        default="info",
+        help="Logging level (default: info)",
+    )
+    from acp.agent.implementations.debug_server.debug_server import ACPDebugServer
+
+    args = parser.parse_args()
+
+    # Configure logging
+    level = getattr(logging, args.log_level.upper())
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[logging.StreamHandler(sys.stderr)],
+    )
+
+    # Create and run debug server
+    server = ACPDebugServer(fastapi_port=args.port, fastapi_host=args.host)
+
+    try:
+        anyio.run(server.run)
+    except KeyboardInterrupt:
+        print("\nDebug server interrupted", file=sys.stderr)
+    except Exception as e:  # noqa: BLE001
+        print(f"Debug server error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

acp/agent/implementations/debug_server/debug.html

@@ -0,0 +1,234 @@
+<!doctype html>
+<html>
+    <head>
+        <title>ACP Debug Server</title>
+        <style>
+            body {
+                font-family: Arial, sans-serif;
+                margin: 20px;
+            }
+            .container {
+                max-width: 1200px;
+                margin: 0 auto;
+            }
+            .section {
+                margin: 20px 0;
+                padding: 15px;
+                border: 1px solid #ddd;
+                border-radius: 5px;
+            }
+            .form-group {
+                margin: 10px 0;
+            }
+            label {
+                display: block;
+                margin-bottom: 5px;
+            }
+            input,
+            select,
+            textarea {
+                width: 100%;
+                padding: 5px;
+            }
+            button {
+                padding: 10px 20px;
+                margin: 5px;
+                cursor: pointer;
+            }
+            .status {
+                background: #f0f8ff;
+            }
+            .notifications {
+                background: #f8f8f0;
+            }
+            .response {
+                background: #f0f0f0;
+                margin-top: 10px;
+                padding: 10px;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>🐛 ACP Debug Server</h1>
+
+            <div class="section status">
+                <h2>Status</h2>
+                <div id="status">Loading...</div>
+                <button onclick="refreshStatus()">Refresh Status</button>
+            </div>
+
+            <div class="section notifications">
+                <h2>Send Notifications</h2>
+                <div class="form-group">
+                    <label>Session ID:</label>
+                    <input type="text" id="sessionId" placeholder="Enter session ID" />
+                </div>
+
+                <div class="form-group">
+                    <label>Notification Type:</label>
+                    <select id="notificationType" onchange="updateForm()">
+                        <option value="agent_message">Agent Message</option>
+                        <option value="user_message">User Message</option>
+                        <option value="agent_thought">Agent Thought</option>
+                        <option value="tool_call_start">Tool Call Start</option>
+                        <option value="tool_call_progress">Tool Call Progress</option>
+                        <option value="plan_update">Plan Update</option>
+                        <option value="commands_update">Commands Update</option>
+                        <option value="mode_update">Mode Update</option>
+                    </select>
+                </div>
+
+                <div id="dynamicForm"></div>
+
+                <button onclick="sendNotification()">Send Notification</button>
+                <div id="response" class="response" style="display: none"></div>
+            </div>
+        </div>
+
+        <script>
+            async function refreshStatus() {
+                try {
+                    const response = await fetch("/status");
+                    const status = await response.json();
+                    document.getElementById("status").innerHTML = `
+                    <strong>Sessions:</strong> ${status.active_sessions.join(", ") || "None"}<br>
+                    <strong>Current Session:</strong> ${status.current_session || "None"}<br>
+                    <strong>Notifications Sent:</strong> ${status.notifications_sent}<br>
+                    <strong>ACP Connected:</strong> ${status.acp_connected ? "Yes" : "No"}
+                `;
+
+                    // Auto-fill session ID if available
+                    if (
+                        status.current_session &&
+                        !document.getElementById("sessionId").value
+                    ) {
+                        document.getElementById("sessionId").value =
+                            status.current_session;
+                    }
+                } catch (e) {
+                    document.getElementById("status").innerHTML = "Error loading status";
+                }
+            }
+
+            function updateForm() {
+                const type = document.getElementById("notificationType").value;
+                const form = document.getElementById("dynamicForm");
+
+                switch (type) {
+                    case "agent_message":
+                    case "user_message":
+                    case "agent_thought":
+                        form.innerHTML = `
+                        <div class="form-group">
+                            <label>Text Content:</label>
+                            <textarea id="text" rows="3" placeholder="Enter message text"></textarea>
+                        </div>
+                    `;
+                        break;
+                    case "tool_call_start":
+                        form.innerHTML = `
+                        <div class="form-group">
+                            <label>Tool Call ID:</label>
+                            <input type="text" id="toolCallId" placeholder="tool-call-123">
+                        </div>
+                        <div class="form-group">
+                            <label>Title:</label>
+                            <input type="text" id="title" placeholder="Tool call title">
+                        </div>
+                        <div class="form-group">
+                            <label>Kind:</label>
+                            <select id="kind">
+                                <option value="other">Other</option>
+                                <option value="read">Read</option>
+                                <option value="edit">Edit</option>
+                                <option value="execute">Execute</option>
+                            </select>
+                        </div>
+                    `;
+                        break;
+                    case "tool_call_progress":
+                        form.innerHTML = `
+                        <div class="form-group">
+                            <label>Tool Call ID:</label>
+                            <input type="text" id="toolCallId" placeholder="tool-call-123">
+                        </div>
+                        <div class="form-group">
+                            <label>Status:</label>
+                            <select id="status">
+                                <option value="in_progress">In Progress</option>
+                                <option value="completed">Completed</option>
+                                <option value="failed">Failed</option>
+                            </select>
+                        </div>
+                        <div class="form-group">
+                            <label>Output:</label>
+                            <textarea id="output" rows="3" placeholder="Tool output"></textarea>
+                        </div>
+                    `;
+                        break;
+                    default:
+                        form.innerHTML = "";
+                }
+            }
+
+            async function sendNotification() {
+                const sessionId = document.getElementById("sessionId").value;
+                const type = document.getElementById("notificationType").value;
+
+                if (!sessionId) {
+                    alert("Please enter a session ID");
+                    return;
+                }
+
+                let data = {};
+
+                // Collect form data based on type
+                switch (type) {
+                    case "agent_message":
+                    case "user_message":
+                    case "agent_thought":
+                        data.text = document.getElementById("text").value;
+                        break;
+                    case "tool_call_start":
+                        data.tool_call_id = document.getElementById("toolCallId").value;
+                        data.title = document.getElementById("title").value;
+                        data.kind = document.getElementById("kind").value;
+                        break;
+                    case "tool_call_progress":
+                        data.tool_call_id = document.getElementById("toolCallId").value;
+                        data.status = document.getElementById("status").value;
+                        data.output = document.getElementById("output").value;
+                        break;
+                }
+
+                try {
+                    const response = await fetch("/send-notification", {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({
+                            session_id: sessionId,
+                            notification_type: type,
+                            data: data,
+                        }),
+                    });
+
+                    const result = await response.text();
+                    document.getElementById("response").style.display = "block";
+                    document.getElementById("response").innerHTML = response.ok
+                        ? "✅ Notification sent successfully!"
+                        : "❌ Error: " + result;
+                } catch (e) {
+                    document.getElementById("response").style.display = "block";
+                    document.getElementById("response").innerHTML =
+                        "❌ Error: " + e.message;
+                }
+            }
+
+            // Initialize
+            updateForm();
+            refreshStatus();
+            setInterval(refreshStatus, 5000); // Auto-refresh every 5 seconds
+        </script>
+    </body>
+</html>