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

agentpool/agents/acp_agent/acp_converters.py

@@ -9,7 +9,7 @@ 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 typing import TYPE_CHECKING, Any, assert_never, overload
 
 from pydantic_ai import (
     AudioUrl,
@@ -53,12 +53,24 @@ from agentpool.agents.events import (
 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 pydantic_ai import FinishReason, UserContent
+
+    from acp.schema import (
+        ContentBlock,
+        HttpMcpServer,
+        McpServer,
+        SessionConfigOption,
+        SessionModelState,
+        SessionModeState,
+        SessionUpdate,
+        SseMcpServer,
+        StdioMcpServer,
+        StopReason,
+        ToolCallContent,
+        ToolCallLocation,
+    )
     from agentpool.agents.events import RichAgentStreamEvent, ToolCallContentItem
+    from agentpool.agents.modes import ModeCategory, ModeInfo
     from agentpool_config.mcp_server import (
         MCPServerConfig,
         SSEMCPServerConfig,
@@ -66,15 +78,122 @@ if TYPE_CHECKING:
         StreamableHTTPMCPServerConfig,
     )
 
+STOP_REASON_MAP: dict[StopReason, FinishReason] = {
+    "end_turn": "stop",
+    "max_tokens": "length",
+    "max_turn_requests": "length",
+    "refusal": "content_filter",
+    "cancelled": "error",
+}
+
+
+def get_modes(
+    config_options: list[SessionConfigOption],
+    available_modes: SessionModeState | None,
+    available_models: SessionModelState | None,
+) -> list[ModeCategory]:
+    from acp.schema import SessionConfigSelectGroup
+    from agentpool.agents.modes import ModeCategory, ModeInfo
+
+    categories: list[ModeCategory] = []
+
+    if config_options:
+        for config_opt in config_options:
+            # Extract options from the config (ungrouped or grouped)
+            mode_infos: list[ModeInfo] = []
+            if isinstance(config_opt.options, list):
+                for opt_item in config_opt.options:
+                    if isinstance(opt_item, SessionConfigSelectGroup):
+                        mode_infos.extend(
+                            ModeInfo(
+                                id=sub_opt.value,
+                                name=sub_opt.name,
+                                description=sub_opt.description or "",
+                                category_id=config_opt.id,
+                            )
+                            for sub_opt in opt_item.options
+                        )
+                    else:
+                        # Ungrouped options
+                        mode_infos.append(
+                            ModeInfo(
+                                id=opt_item.value,
+                                name=opt_item.name,
+                                description=opt_item.description or "",
+                                category_id=config_opt.id,
+                            )
+                        )
+
+            categories.append(
+                ModeCategory(
+                    id=config_opt.id,
+                    name=config_opt.name,
+                    available_modes=mode_infos,
+                    current_mode_id=config_opt.current_value,
+                    category=config_opt.category or "other",
+                )
+            )
+        return categories
+
+    # Legacy: Convert ACP SessionModeState to ModeCategory
+    if available_modes:
+        acp_modes = available_modes
+        modes = [
+            ModeInfo(
+                id=m.id,
+                name=m.name,
+                description=m.description or "",
+                category_id="permissions",
+            )
+            for m in acp_modes.available_modes
+        ]
+        categories.append(
+            ModeCategory(
+                id="permissions",
+                name="Mode",
+                available_modes=modes,
+                current_mode_id=acp_modes.current_mode_id,
+                category="mode",
+            )
+        )
+
+    # Legacy: Convert ACP SessionModelState to ModeCategory
+    if available_models:
+        acp_models = available_models
+        models = [
+            ModeInfo(
+                id=m.model_id,
+                name=m.name,
+                description=m.description or "",
+                category_id="model",
+            )
+            for m in acp_models.available_models
+        ]
+        categories.append(
+            ModeCategory(
+                id="model",
+                name="Model",
+                available_modes=models,
+                current_mode_id=acp_models.current_model_id,
+                category="model",
+            )
+        )
+
+    return categories
+
+
+def to_finish_reason(stop_reason: StopReason) -> FinishReason:
+    return STOP_REASON_MAP.get(stop_reason, "stop")
+
 
 def convert_acp_locations(
-    locations: list[ToolCallLocation] | None,
+    locations: Sequence[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]:
+def convert_acp_content(content: Sequence[ToolCallContent] | None) -> list[ToolCallContentItem]:
     """Convert ACP ToolCallContent list to native ToolCallContentItem list."""
     if not content:
         return []
@@ -217,7 +336,7 @@ def acp_to_native_event(update: SessionUpdate) -> RichAgentStreamEvent[Any] | No
                 raw_input=raw_input or {},
             )
 
-        # Tool call progress -> ToolCallProgressEvent
+        # Tool call progress -> ToolCallProgressEvent or ToolCallCompleteEvent
         case ToolCallProgress(
             tool_call_id=tool_call_id,
             status=status,
@@ -225,6 +344,20 @@ def acp_to_native_event(update: SessionUpdate) -> RichAgentStreamEvent[Any] | No
             content=content,
             raw_output=raw_output,
         ):
+            # If completed, return ToolCallCompleteEvent for metadata injection
+            if status == "completed":
+                from agentpool.agents.events import ToolCallCompleteEvent
+
+                return ToolCallCompleteEvent(
+                    tool_call_id=tool_call_id,
+                    tool_name=title or "unknown",
+                    tool_input={},  # ACP doesn't provide input in progress updates
+                    tool_result=str(raw_output) if raw_output else "",
+                    agent_name="",  # Will be set by agent
+                    message_id="",
+                    metadata=None,  # Will be injected by agent from metadata accumulator
+                )
+            # Otherwise return progress event
             return ToolCallProgressEvent(
                 tool_call_id=tool_call_id,
                 status=status or "in_progress",
@@ -247,22 +380,22 @@ def acp_to_native_event(update: SessionUpdate) -> RichAgentStreamEvent[Any] | No
 
 
 @overload
-def mcp_config_to_acp(config: StdioMCPServerConfig) -> StdioMcpServer | None: ...
+def mcp_config_to_acp(config: StdioMCPServerConfig) -> StdioMcpServer: ...
 
 
 @overload
-def mcp_config_to_acp(config: SSEMCPServerConfig) -> SseMcpServer | None: ...
+def mcp_config_to_acp(config: SSEMCPServerConfig) -> SseMcpServer: ...
 
 
 @overload
-def mcp_config_to_acp(config: StreamableHTTPMCPServerConfig) -> HttpMcpServer | None: ...
+def mcp_config_to_acp(config: StreamableHTTPMCPServerConfig) -> HttpMcpServer: ...
 
 
 @overload
-def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None: ...
+def mcp_config_to_acp(config: MCPServerConfig) -> McpServer: ...
 
 
-def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None:
+def mcp_config_to_acp(config: MCPServerConfig) -> McpServer:
     """Convert native MCPServerConfig to ACP McpServer format.
 
     If the config has tool filtering (enabled_tools or disabled_tools),
@@ -303,8 +436,8 @@ def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None:
         case StreamableHTTPMCPServerConfig(url=url):
             return HttpMcpServer(name=config.name or str(url), url=url, headers=[])
 
-        case _:
-            return None
+        case _ as unreachable:
+            assert_never(unreachable)
 
 
 def mcp_configs_to_acp(configs: Sequence[MCPServerConfig]) -> list[McpServer]:
@@ -316,4 +449,4 @@ def mcp_configs_to_acp(configs: Sequence[MCPServerConfig]) -> list[McpServer]:
     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]
+    return [mcp_config_to_acp(config) for config in configs]

agentpool/agents/acp_agent/client_handler.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import asyncio
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
-import uuid
 
 import anyio
 
@@ -21,7 +20,6 @@ from acp.schema import (
     WriteTextFileResponse,
 )
 from agentpool.log import get_logger
-from agentpool.tools.base import Tool
 
 
 if TYPE_CHECKING:
@@ -79,7 +77,7 @@ class ACPClientHandler(Client):
         self.state = state
         self._input_provider = input_provider
         self._update_event = asyncio.Event()
-        # Map ACP terminal IDs to process manager IDs
+        # Map ACP terminal IDs to process manager IDs (for local execution only)
         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
@@ -224,13 +222,21 @@ class ACPClientHandler(Client):
 
         if self._input_provider:
             ctx = self._agent.get_context()  # Use the agent's NodeContext
-            # Attach tool_call_id for permission event matching in TUI
+            # Attach tool call metadata for permission event matching
             ctx.tool_call_id = params.tool_call.tool_call_id
+            ctx.tool_name = params.tool_call.title
+            args = (
+                params.tool_call.raw_input if isinstance(params.tool_call.raw_input, dict) else {}
+            )
+            ctx.tool_input = args
             # 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
+            from agentpool.tools import FunctionTool
+
+            tool = FunctionTool(
+                callable=lambda: None, name=params.tool_call.tool_call_id, description=name
+            )
             try:
-                result = await self._input_provider.get_tool_confirmation(ctx, tool=tool, args={})
+                result = await self._input_provider.get_tool_confirmation(ctx, tool=tool, args=args)
                 # Map confirmation result to ACP response
                 if result == "allow":
                     option_id = params.options[0].option_id if params.options else "allow"
@@ -265,9 +271,10 @@ class ACPClientHandler(Client):
             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 (FileNotFoundError, KeyError):
+            # Match Zed behavior: return empty string for non-existent files
+            logger.debug("File not found, returning empty string", path=params.path)
+            return ReadTextFileResponse(content="")
         except Exception:
             logger.exception("Failed to read file", path=params.path)
             raise
@@ -290,11 +297,18 @@ class ACPClientHandler(Client):
             raise
 
     async def create_terminal(self, params: CreateTerminalRequest) -> CreateTerminalResponse:
-        """Create a new terminal session via ProcessManager."""
+        """Create a new terminal session via the configured ExecutionEnvironment.
+
+        The ProcessManager implementation determines where the terminal runs
+        (local, Docker, E2B, SSH, or forwarded to parent ACP client like Zed).
+
+        The terminal_id returned by process_manager.start_process() is used directly.
+        """
         if not self.allow_terminal:
             raise RuntimeError("Terminal operations not allowed")
+
         try:
-            process_id = await self.env.process_manager.start_process(
+            terminal_id = await self.env.process_manager.start_process(
                 command=params.command,
                 args=list(params.args) if params.args else None,
                 cwd=params.cwd,
@@ -304,10 +318,10 @@ class ACPClientHandler(Client):
             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)
+            # Use the ID from process_manager directly - for ACPProcessManager this
+            # is already the parent's terminal ID (e.g., Zed's)
+            self._terminal_to_process[terminal_id] = terminal_id
+            logger.info("Created terminal", terminal_id=terminal_id, command=params.command)
             return CreateTerminalResponse(terminal_id=terminal_id)
 
     async def terminal_output(self, params: TerminalOutputRequest) -> TerminalOutputResponse:
@@ -319,8 +333,7 @@ class ACPClientHandler(Client):
         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)
+        proc_output = await self.env.process_manager.get_output(terminal_id)
         output = proc_output.combined or proc_output.stdout or ""
         return TerminalOutputResponse(output=output, truncated=proc_output.truncated)
 
@@ -335,8 +348,7 @@ class ACPClientHandler(Client):
         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)
+        exit_code = await self.env.process_manager.wait_for_exit(terminal_id)
         logger.debug("Terminal exited", terminal_id=terminal_id, exit_code=exit_code)
         return WaitForTerminalExitResponse(exit_code=exit_code)
 
@@ -351,8 +363,7 @@ class ACPClientHandler(Client):
         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)
+        await self.env.process_manager.kill_process(terminal_id)
         logger.info("Killed terminal", terminal_id=terminal_id)
         return KillTerminalCommandResponse()
 
@@ -364,8 +375,8 @@ class ACPClientHandler(Client):
         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)
+
+        await self.env.process_manager.release_process(terminal_id)
         del self._terminal_to_process[terminal_id]
         logger.info("Released terminal", terminal_id=terminal_id)
         return ReleaseTerminalResponse()

agentpool/agents/acp_agent/session_state.py

@@ -9,7 +9,12 @@ from agentpool.log import get_logger
 
 
 if TYPE_CHECKING:
-    from acp.schema import AvailableCommandsUpdate, SessionModelState, SessionModeState
+    from acp.schema import (
+        AvailableCommandsUpdate,
+        SessionConfigOption,
+        SessionModelState,
+        SessionModeState,
+    )
     from agentpool.agents.events import RichAgentStreamEvent
 
 logger = get_logger(__name__)
@@ -28,20 +33,23 @@ class ACPSessionState:
     """Queue of native events converted from ACP updates."""
 
     current_model_id: str | None = None
-    """Current model ID from session state."""
+    """Current model ID from session state (legacy)."""
 
     models: SessionModelState | None = None
-    """Full model state including available models from nested ACP agent."""
+    """Full model state including available models (legacy)."""
 
     modes: SessionModeState | None = None
-    """Full mode state including available modes from nested ACP agent."""
+    """Full mode state including available modes (legacy)."""
 
     current_mode_id: str | None = None
-    """Current mode ID."""
+    """Current mode ID (legacy)."""
+
+    config_options: list[SessionConfigOption] = dataclass_field(default_factory=list)
+    """Unified session config options (replaces modes/models in newer ACP versions)."""
 
     available_commands: AvailableCommandsUpdate | None = None
     """Available commands from the agent."""
 
     def clear(self) -> None:
         self.events.clear()
-        # Note: Don't clear current_model_id or models - those persist across prompts
+        # Note: Don't clear current_model_id, models, config_options - those persist