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

agentpool_server/acp_server/acp_agent.py

@@ -16,10 +16,13 @@ from acp.schema import (
     NewSessionResponse,
     PromptResponse,
     ResumeSessionResponse,
+    SessionConfigOption,
+    SessionConfigSelectOption,
     SessionInfo,
     SessionMode,
     SessionModelState,
     SessionModeState,
+    SetSessionConfigOptionResponse,
     SetSessionModelRequest,
     SetSessionModelResponse,
     SetSessionModeRequest,
@@ -27,17 +30,13 @@ from acp.schema import (
 )
 from agentpool.log import get_logger
 from agentpool.utils.tasks import TaskManager
-from agentpool_server.acp_server.converters import (
-    # agent_to_mode,  # TODO: Re-enable when supporting agent switching via modes
-    mode_id_to_confirmation_mode,
-)
 from agentpool_server.acp_server.session_manager import ACPSessionManager
 
 
 if TYPE_CHECKING:
     from pydantic_ai import ModelRequest, ModelResponse
 
-    from acp import AgentSideConnection, Client
+    from acp import Client
     from acp.schema import (
         AuthenticateRequest,
         CancelNotification,
@@ -50,6 +49,7 @@ if TYPE_CHECKING:
         NewSessionRequest,
         PromptRequest,
         ResumeSessionRequest,
+        SetSessionConfigOptionRequest,
         SetSessionModelRequest,
         SetSessionModeRequest,
     )
@@ -93,14 +93,8 @@ async def get_session_model_state(
     for toko in toko_models:
         # Use id_override if set (e.g., "opus" for Claude Code), otherwise use id
         model_id = toko.id_override if toko.id_override else toko.id
-        acp_models.append(
-            ACPModelInfo(
-                model_id=model_id,
-                name=toko.name,
-                description=toko.description or "",
-            )
-        )
-
+        info = ACPModelInfo(model_id=model_id, name=toko.name, description=toko.description or "")
+        acp_models.append(info)
     if not acp_models:
         return None
 
@@ -108,14 +102,9 @@ async def get_session_model_state(
     all_ids = [model.model_id for model in acp_models]
     if current_model and current_model not in all_ids:
         # Add current model to the list so the UI shows it
-        acp_models.insert(
-            0,
-            ACPModelInfo(
-                model_id=current_model,
-                name=current_model,
-                description="Currently configured model",
-            ),
-        )
+        desc = "Currently configured model"
+        model_info = ACPModelInfo(model_id=current_model, name=current_model, description=desc)
+        acp_models.insert(0, model_info)
         current_model_id = current_model
     else:
         current_model_id = current_model if current_model in all_ids else all_ids[0]
@@ -123,11 +112,11 @@ async def get_session_model_state(
     return SessionModelState(available_models=acp_models, current_model_id=current_model_id)
 
 
-def get_session_mode_state(agent: Any) -> SessionModeState | None:
+async def get_session_mode_state(agent: Any) -> SessionModeState | None:
     """Get SessionModeState from an agent using its get_modes() method.
 
     Converts agentpool ModeCategory to ACP SessionModeState format.
-    Currently uses the first mode category (ACP only supports one dropdown for now).
+    Uses the first category that looks like permissions (not model).
 
     Args:
         agent: Any agent with get_modes() method
@@ -141,7 +130,7 @@ def get_session_mode_state(agent: Any) -> SessionModeState | None:
         return None
 
     try:
-        mode_categories = agent.get_modes()
+        mode_categories = await agent.get_modes()
     except Exception:
         logger.exception("Failed to get modes from agent")
         return None
@@ -149,8 +138,10 @@ def get_session_mode_state(agent: Any) -> SessionModeState | None:
     if not mode_categories:
         return None
 
-    # Use first category for now (ACP currently only supports single mode dropdown)
-    category = mode_categories[0]
+    # Find the permissions category (not model)
+    category = next((c for c in mode_categories if c.id != "model"), None)
+    if not category:
+        return None
 
     # Convert ModeInfo to ACP SessionMode
     acp_modes = [
@@ -168,6 +159,56 @@ def get_session_mode_state(agent: Any) -> SessionModeState | None:
     )
 
 
+async def get_session_config_options(agent: Any) -> list[SessionConfigOption]:
+    """Get SessionConfigOptions from an agent using its get_modes() method.
+
+    Converts all agentpool ModeCategories to ACP SessionConfigOption format.
+
+    Args:
+        agent: Any agent with get_modes() method
+
+    Returns:
+        List of SessionConfigOption from agent's mode categories
+    """
+    from agentpool.agents.base_agent import BaseAgent
+
+    if not isinstance(agent, BaseAgent):
+        return []
+
+    try:
+        mode_categories = await agent.get_modes()
+    except Exception:
+        logger.exception("Failed to get modes from agent")
+        return []
+
+    if not mode_categories:
+        return []
+
+    # Convert each ModeCategory to a SessionConfigOption
+    config_options: list[SessionConfigOption] = []
+    for category in mode_categories:
+        options = [
+            SessionConfigSelectOption(
+                value=mode.id,
+                name=mode.name,
+                description=mode.description,
+            )
+            for mode in category.available_modes
+        ]
+        config_options.append(
+            SessionConfigOption(
+                id=category.id,
+                name=category.name,
+                description=None,
+                category=category.category,
+                current_value=category.current_mode_id,
+                options=options,
+            )
+        )
+
+    return config_options
+
+
 @dataclass
 class AgentPoolACPAgent(ACPAgent):
     """Implementation of ACP Agent protocol interface for AgentPool.
@@ -178,7 +219,7 @@ class AgentPoolACPAgent(ACPAgent):
 
     PROTOCOL_VERSION: ClassVar = 1
 
-    connection: AgentSideConnection
+    client: Client
     """ACP connection for client communication."""
 
     agent_pool: AgentPool[Any]
@@ -206,7 +247,6 @@ class AgentPoolACPAgent(ACPAgent):
 
     def __post_init__(self) -> None:
         """Initialize derived attributes and setup after field assignment."""
-        self.client: Client = self.connection
         self.client_capabilities: ClientCapabilities | None = None
         self.client_info: Implementation | None = None
         self.session_manager = ACPSessionManager(pool=self.agent_pool)
@@ -274,6 +314,7 @@ class AgentPoolACPAgent(ACPAgent):
 
             state: SessionModeState | None = None
             models: SessionModelState | None = None
+            config_options: list[SessionConfigOption] = []
 
             if session := self.session_manager.get_session(session_id):
                 if isinstance(session.agent, ACPAgentClient):
@@ -281,10 +322,13 @@ class AgentPoolACPAgent(ACPAgent):
                     if session.agent._state:
                         models = session.agent._state.models
                         state = session.agent._state.modes
+                    # Also get config_options from nested agent
+                    config_options = await get_session_config_options(session.agent)
                 else:
                     # Use unified helpers for all other agents
                     models = await get_session_model_state(session.agent, session.agent.model_name)
-                    state = get_session_mode_state(session.agent)
+                    state = await get_session_mode_state(session.agent)
+                    config_options = await get_session_config_options(session.agent)
         except Exception:
             logger.exception("Failed to create new session")
             raise
@@ -299,7 +343,13 @@ class AgentPoolACPAgent(ACPAgent):
                     coro_4 = session.init_client_skills()
                     self.tasks.create_task(coro_4, name=f"init_client_skills_{session_id}")
             logger.info("Created session", session_id=session_id)
-            return NewSessionResponse(session_id=session_id, modes=state, models=models)
+
+            return NewSessionResponse(
+                session_id=session_id,
+                modes=state,
+                models=models,
+                config_options=config_options if config_options else None,
+            )
 
     async def load_session(self, params: LoadSessionRequest) -> LoadSessionResponse:
         """Load an existing session from storage.
@@ -311,13 +361,14 @@ class AgentPoolACPAgent(ACPAgent):
         4. Replay conversation history via ACP notifications
         5. Return session state (modes, models)
         """
+        from agentpool.agents.acp_agent import ACPAgent as ACPAgentClient
+
         if not self._initialized:
             raise RuntimeError("Agent not initialized")
 
         try:
             # First check if session is already active
             session = self.session_manager.get_session(params.session_id)
-
             if not session:
                 # Try to resume from storage
                 msg = "Attempting to resume session from storage"
@@ -344,21 +395,21 @@ class AgentPoolACPAgent(ACPAgent):
                 session.mcp_servers = params.mcp_servers
                 await session.initialize_mcp_servers()
 
-            # Build response with current session state
-            from agentpool.agents.acp_agent import ACPAgent as ACPAgentClient
-
             mode_state: SessionModeState | None = None
             models: SessionModelState | None = None
+            config_opts: list[SessionConfigOption] = []
 
             if isinstance(session.agent, ACPAgentClient):
                 # Nested ACP agent - pass through its state directly
                 if session.agent._state:
                     mode_state = session.agent._state.modes
                     models = session.agent._state.models
+                config_opts = await get_session_config_options(session.agent)
             elif session.agent:
                 # Use unified helpers for all other agents
-                mode_state = get_session_mode_state(session.agent)
+                mode_state = await get_session_mode_state(session.agent)
                 models = await get_session_model_state(session.agent, session.agent.model_name)
+                config_opts = await get_session_config_options(session.agent)
             else:
                 models = None
             # Schedule post-load initialization tasks
@@ -367,7 +418,7 @@ class AgentPoolACPAgent(ACPAgent):
             # Replay conversation history via ACP notifications
             self.tasks.create_task(self._replay_conversation_history(session))
             logger.info("Session loaded successfully", agent=session.current_agent_name)
-            return LoadSessionResponse(models=models, modes=mode_state)
+            return LoadSessionResponse(models=models, modes=mode_state, config_options=config_opts)
 
         except Exception:
             logger.exception("Failed to load session", session_id=params.session_id)
@@ -626,14 +677,8 @@ class AgentPoolACPAgent(ACPAgent):
     ) -> SetSessionModeResponse | None:
         """Set the session mode (change tool confirmation level).
 
-        Maps ACP mode IDs to ToolConfirmationMode and calls set_tool_confirmation_mode
-        on the session's agent. Each agent type handles the mode change appropriately:
-        - Agent/AGUIAgent: Updates local confirmation mode
-        - ACPAgent: Updates local mode AND forwards to remote ACP server
-
-        Mode mappings:
-        - "default": per_tool (confirm tools marked as requiring it)
-        - "acceptEdits": never (auto-approve all tool calls)
+        Calls set_mode directly on the agent with the mode_id, allowing the agent
+        to handle mode-specific logic (e.g., acceptEdits auto-allowing edit tools).
         """
         from agentpool.agents.acp_agent import ACPAgent as ACPAgentClient
 
@@ -643,15 +688,8 @@ class AgentPoolACPAgent(ACPAgent):
                 logger.warning("Session not found for mode switch", session_id=params.session_id)
                 return None
 
-            # Map mode_id to confirmation mode
-            confirmation_mode = mode_id_to_confirmation_mode(params.mode_id)
-            if not confirmation_mode:
-                logger.error("Invalid mode_id", mode_id=params.mode_id)
-                return None
-
-            # All agent types support set_tool_confirmation_mode
-            # ACPAgent handles forwarding to remote server internally
-            await session.agent.set_tool_confirmation_mode(confirmation_mode)
+            # Call set_mode directly - agent handles mode-specific logic
+            await session.agent.set_mode(params.mode_id)
 
             # Update stored mode state for ACPAgent
             if (
@@ -662,9 +700,8 @@ class AgentPoolACPAgent(ACPAgent):
                 session.agent._state.modes.current_mode_id = params.mode_id
 
             logger.info(
-                "Set tool confirmation mode",
+                "Set mode",
                 mode_id=params.mode_id,
-                confirmation_mode=confirmation_mode,
                 session_id=params.session_id,
                 agent_type=type(session.agent).__name__,
             )
@@ -726,13 +763,45 @@ class AgentPoolACPAgent(ACPAgent):
 
             # Set the model on the agent (all agents now have async set_model)
             await session.agent.set_model(params.model_id)
-
             logger.info("Set model", model_id=params.model_id, session_id=params.session_id)
             return SetSessionModelResponse()
         except Exception:
             logger.exception("Failed to set session model", session_id=params.session_id)
             return None
 
+    async def set_session_config_option(
+        self, params: SetSessionConfigOptionRequest
+    ) -> SetSessionConfigOptionResponse | None:
+        """Set a session config option.
+
+        Forwards the config option change to the agent's set_mode method
+        and returns the updated config options.
+        """
+        try:
+            session = self.session_manager.get_session(params.session_id)
+            if not session or not session.agent:
+                msg = "Session not found for config option change"
+                logger.warning(msg, session_id=params.session_id)
+                return None
+
+            logger.info(
+                "Set config option",
+                config_id=params.config_id,
+                value=params.value,
+                session_id=params.session_id,
+            )
+
+            # Forward to agent's set_mode method
+            # config_id maps to category_id, value maps to mode_id
+            await session.agent.set_mode(params.value, category_id=params.config_id)
+
+            # Return updated config options
+            config_options = await get_session_config_options(session.agent)
+            return SetSessionConfigOptionResponse(config_options=config_options)
+        except Exception:
+            logger.exception("Failed to set session config option", session_id=params.session_id)
+            return None
+
     async def swap_pool(self, config_path: str, agent: str | None = None) -> list[str]:
         """Swap the agent pool with a new one from configuration.