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

agentpool/agents/acp_agent/client_handler.py

@@ -25,9 +25,13 @@ from agentpool.tools.base import Tool
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from exxec import ExecutionEnvironment
+    from slashed import Command
 
     from acp.schema import (
+        AvailableCommand,
         CreateTerminalRequest,
         KillTerminalCommandRequest,
         ReadTextFileRequest,
@@ -98,11 +102,93 @@ class ACPClientHandler(Client):
         return self._agent.config.allow_terminal
 
     async def session_update(self, params: SessionNotification[Any]) -> None:
-        """Handle session update notifications from the agent."""
+        """Handle session update notifications from the agent.
+
+        Some updates are state changes (mode, model, config) that should update
+        session state. Others are stream events (text chunks, tool calls) that
+        should be queued for the run_stream consumer.
+        """
+        from acp.schema import (
+            AvailableCommandsUpdate,
+            ConfigOptionUpdate,
+            CurrentModelUpdate,
+            CurrentModeUpdate,
+        )
         from agentpool.agents.acp_agent.acp_converters import acp_to_native_event
 
         update = params.update
-        # Convert to native event and queue it
+
+        # Handle state updates - these modify session state, not stream events
+        match update:
+            case CurrentModeUpdate(current_mode_id=mode_id):
+                if self.state.modes:
+                    self.state.modes.current_mode_id = mode_id
+                    # Find ModeInfo and emit signal
+                    for acp_mode in self.state.modes.available_modes:
+                        if acp_mode.id == mode_id:
+                            from agentpool.agents.modes import ModeInfo
+
+                            mode_info = ModeInfo(
+                                id=acp_mode.id,
+                                name=acp_mode.name,
+                                description=acp_mode.description or "",
+                                category_id="remote",
+                            )
+                            await self._agent.state_updated.emit(mode_info)
+                            break
+                self.state.current_mode_id = mode_id
+                logger.debug("Mode updated", mode_id=mode_id)
+                self._update_event.set()
+                return
+
+            case CurrentModelUpdate(current_model_id=model_id):
+                self.state.current_model_id = model_id
+                if self.state.models:
+                    self.state.models.current_model_id = model_id
+                    # Find ModelInfo and emit signal
+                    for acp_model in self.state.models.available_models:
+                        if acp_model.model_id == model_id:
+                            from tokonomics.model_discovery.model_info import (
+                                ModelInfo as TokoModelInfo,
+                            )
+
+                            model_info = TokoModelInfo(
+                                id=acp_model.model_id,
+                                name=acp_model.name,
+                                description=acp_model.description,
+                            )
+                            await self._agent.state_updated.emit(model_info)
+                            break
+                logger.debug("Model updated", model_id=model_id)
+                self._update_event.set()
+                return
+
+            case ConfigOptionUpdate():
+                await self._agent.state_updated.emit(update)
+                logger.debug("Config option updated", update=update)
+                self._update_event.set()
+                return
+
+            case AvailableCommandsUpdate():
+                self.state.available_commands = update
+                # Populate command store with remote commands
+                self._populate_command_store(update.available_commands)
+                # Emit to parent session - remote commands will be merged with local ones.
+                # The "way back" works because session.split_commands() only extracts
+                # LOCAL commands; remote commands pass through to the agent prompt.
+                await self._agent.state_updated.emit(update)
+                logger.debug("Available commands updated", count=len(update.available_commands))
+                self._update_event.set()
+                return
+
+        # TODO: AgentPlanUpdate handling is complex and needs design work.
+        # Options:
+        # 1. Update pool.todos - requires merging with existing todos
+        # 2. Pass through to UI - but then todos aren't centrally managed
+        # 3. Switch to agent-owned todos instead of pool-owned
+        # For now, AgentPlanUpdate falls through to stream events.
+
+        # All other updates are stream events - convert and queue
         if native_event := acp_to_native_event(update):
             self.state.events.append(native_event)
         self._update_event.set()
@@ -138,6 +224,8 @@ 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
+            ctx.tool_call_id = params.tool_call.tool_call_id
             # 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
@@ -301,13 +389,79 @@ class ACPClientHandler(Client):
         """Handle extension notifications."""
         logger.debug("Extension notification", method=method)
 
+    def _populate_command_store(self, commands: Sequence[AvailableCommand]) -> None:
+        """Populate the agent's command store with remote ACP commands.
+
+        Args:
+            commands: List of AvailableCommand objects from the remote agent
+        """
+        store = self._agent.command_store
+
+        for cmd in commands:
+            command = self._create_acp_command(cmd)
+            # Unregister if already exists (in case of update)
+            if store.get_command(cmd.name):
+                store.unregister_command(cmd.name)
+            store.register_command(command)
+
+        logger.debug("Populated command store", command_count=len(store.list_commands()))
+
+    def _create_acp_command(self, cmd: AvailableCommand) -> Command:
+        """Create a slashed Command from an ACP AvailableCommand.
+
+        The command, when executed, sends a prompt with the slash command
+        to the remote ACP agent.
+
+        Args:
+            cmd: AvailableCommand from remote agent
+
+        Returns:
+            A slashed Command that sends the command to the remote agent
+        """
+        from pydantic_ai import PartDeltaEvent, TextPartDelta
+        from slashed import Command
+
+        name = cmd.name
+        description = cmd.description
+        input_hint = cmd.input.root.hint if cmd.input else None
+
+        async def execute_command(
+            ctx: Any,
+            args: list[str],
+            kwargs: dict[str, str],
+        ) -> None:
+            """Execute the remote ACP slash command."""
+            # Build command string
+            args_str = " ".join(args) if args else ""
+            if kwargs:
+                kwargs_str = " ".join(f"{k}={v}" for k, v in kwargs.items())
+                args_str = f"{args_str} {kwargs_str}".strip()
+
+            full_command = f"/{name} {args_str}".strip()
+
+            # Execute via agent run_stream - the slash command goes as a prompt
+            async for event in self._agent.run_stream(full_command):
+                # Extract text from PartDeltaEvent with TextPartDelta
+                if isinstance(event, PartDeltaEvent):
+                    delta = event.delta
+                    if isinstance(delta, TextPartDelta):
+                        await ctx.print(delta.content_delta)
+
+        return Command.from_raw(
+            execute_command,
+            name=name,
+            description=description,
+            category="remote",
+            usage=input_hint,
+        )
+
 
 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"]
+        args = ["run", "agentpool", "serve-acp"]
         cwd = str(Path.cwd())
         async with ACPAgent(command="uv", args=args, cwd=cwd, event_handlers=["detailed"]) as agent:
             print("Response (streaming): ", end="", flush=True)

agentpool/agents/acp_agent/session_state.py

@@ -9,7 +9,7 @@ from agentpool.log import get_logger
 
 
 if TYPE_CHECKING:
-    from acp.schema import SessionModelState, SessionModeState
+    from acp.schema import AvailableCommandsUpdate, SessionModelState, SessionModeState
     from agentpool.agents.events import RichAgentStreamEvent
 
 logger = get_logger(__name__)
@@ -39,6 +39,9 @@ class ACPSessionState:
     current_mode_id: str | None = None
     """Current mode ID."""
 
+    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