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

agentpool_server/acp_server/input_provider.py

@@ -15,9 +15,9 @@ from agentpool.ui.base import InputProvider
 
 if TYPE_CHECKING:
     from acp import RequestPermissionResponse
+    from agentpool import AgentContext
     from agentpool.agents.context import ConfirmationResult
     from agentpool.messaging import ChatMessage
-    from agentpool.messaging.context import NodeContext
     from agentpool.tools.base import Tool
     from agentpool_server.acp_server.session import ACPSession
 
@@ -100,7 +100,7 @@ class ACPInputProvider(InputProvider):
 
     async def get_tool_confirmation(
         self,
-        context: NodeContext[Any],
+        context: AgentContext[Any],
         tool: Tool,
         args: dict[str, Any],
         message_history: list[ChatMessage[Any]] | None = None,
@@ -131,18 +131,53 @@ class ACPInputProvider(InputProvider):
                     return "skip"
 
             # Create a descriptive title for the permission request
-            args_str = ", ".join(f"{k}={v}" for k, v in args.items())
+            # args_str = ", ".join(f"{k}={v}" for k, v in args.items())
+            # Use the tool_call_id from context - this must match the UI tool call
+            actual_tool_call_id = getattr(context, "tool_call_id", None)
+            if not actual_tool_call_id:
+                msg = (
+                    f"No tool_call_id in context for tool {tool.name!r}. "
+                    "This indicates a bug in tool call tracking."
+                )
+                logger.error(msg)
+                raise RuntimeError(msg)  # noqa: TRY301
+            logger.debug(
+                "Requesting permission",
+                tool_name=tool.name,
+                tool_call_id=actual_tool_call_id,
+            )
+            # Note: We no longer send tool_call_start/progress notifications here.
+            # The streaming loop (via ACPEventConverter) already sends ToolCallStart
+            # before the permission callback is invoked, so Zed already knows about
+            # the tool call. Sending duplicates was causing sync issues.
+
+            from acp.utils import generate_tool_title
+
+            title = generate_tool_title(tool.name, args)
             response = await self.session.requests.request_permission(
-                tool_call_id=f"{tool.name}_{hash(frozenset(args.items()))}",
-                title=f"Execute tool {tool.name!r} with args: {args_str}",
+                tool_call_id=actual_tool_call_id,
+                title=title,
+                raw_input=args,
                 options=DEFAULT_PERMISSION_OPTIONS,
             )
+            logger.info(
+                "Permission response received",
+                tool_name=tool.name,
+                outcome=response.outcome,
+                outcome_type=type(response.outcome).__name__,
+            )
             # Map ACP permission response to our confirmation result
             if isinstance(response.outcome, AllowedOutcome):
+                logger.info(
+                    "AllowedOutcome detected",
+                    option_id=response.outcome.option_id,
+                    tool_name=tool.name,
+                )
                 return self._handle_permission_response(response.outcome.option_id, tool.name)
             if response.outcome.outcome == "cancelled":
+                logger.debug("Permission cancelled", tool_name=tool.name)
                 return "skip"
-            # Handle other outcomes
+            # Handle other unexpected outcomes
             logger.warning("Unexpected permission outcome", outcome=response.outcome.outcome)
 
         except Exception:
@@ -150,20 +185,28 @@ class ACPInputProvider(InputProvider):
             # Default to abort on error to be safe
             return "abort_run"
         else:
-            return "abort_run"
+            return "skip"  # Default to skip for unknown outcomes
 
     def _handle_permission_response(self, option_id: str, tool_name: str) -> ConfirmationResult:
         """Handle permission response and update tool approval state."""
-        match option_id:
+        # Normalize to hyphen format for matching
+        normalized = option_id.replace("_", "-")
+        logger.info(
+            "Handling permission response",
+            option_id=option_id,
+            normalized=normalized,
+            tool_name=tool_name,
+        )
+        match normalized:
             case "allow-once":
                 return "allow"
             case "allow-always":
                 self._tool_approvals[tool_name] = "allow_always"
                 logger.info("Tool approval set", tool_name=tool_name, approval="allow_always")
                 return "allow"
-            case "reject-once":
+            case "reject-once" | "deny-once":
                 return "skip"
-            case "reject-always":
+            case "reject-always" | "deny-always":
                 self._tool_approvals[tool_name] = "reject_always"
                 logger.info("Tool approval set", tool_name=tool_name, approval="reject_always")
                 return "skip"

agentpool_server/acp_server/server.py

@@ -7,14 +7,10 @@ the Agent Client Protocol.
 from __future__ import annotations
 
 import asyncio
-from datetime import timedelta
 import functools
 from typing import TYPE_CHECKING, Any, Self
 
-import logfire
-
-from acp import AgentSideConnection
-from acp.stdio import stdio_streams
+from acp import serve
 from agentpool import AgentPool
 from agentpool.log import get_logger
 from agentpool.models.manifest import AgentsManifest
@@ -23,41 +19,14 @@ from agentpool_server.acp_server.acp_agent import AgentPoolACPAgent
 
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
-
-    from tokonomics.model_discovery import ProviderType
-    from tokonomics.model_discovery.model_info import ModelInfo
     from upathtools import JoinablePathLike
 
-    from acp.schema import ModelInfo as ACPModelInfo
+    from acp import Transport
 
 
 logger = get_logger(__name__)
 
 
-def _convert_to_acp_model_info(
-    toko_models: Sequence[ModelInfo],
-) -> list[ACPModelInfo]:
-    """Convert tokonomics ModelInfo list to ACP ModelInfo list.
-
-    Args:
-        toko_models: List of tokonomics ModelInfo objects
-
-    Returns:
-        List of ACP ModelInfo objects with pydantic_ai_id as model_id
-    """
-    from acp.schema import ModelInfo as ACPModelInfo
-
-    return [
-        ACPModelInfo(
-            model_id=model.pydantic_ai_id,
-            name=f"{model.provider}: {model.name}" if model.provider else model.name,
-            description=model.format(),
-        )
-        for model in toko_models
-    ]
-
-
 class ACPServer(BaseServer):
     """ACP (Agent Client Protocol) server for agentpool using external library.
 
@@ -75,13 +44,13 @@ class ACPServer(BaseServer):
         name: str | None = None,
         file_access: bool = True,
         terminal_access: bool = True,
-        providers: list[ProviderType] | None = None,
         debug_messages: bool = False,
         debug_file: str | None = None,
         debug_commands: bool = False,
         agent: str | None = None,
         load_skills: bool = True,
         config_path: str | None = None,
+        transport: Transport = "stdio",
     ) -> None:
         """Initialize ACP server with configuration.
 
@@ -90,27 +59,24 @@ class ACPServer(BaseServer):
             name: Optional Server name (auto-generated if None)
             file_access: Whether to support file access operations
             terminal_access: Whether to support terminal access operations
-            providers: List of providers to use for model discovery (None = openrouter)
             debug_messages: Whether to enable debug message logging
             debug_file: File path for debug message logging
             debug_commands: Whether to enable debug slash commands for testing
             agent: Optional specific agent name to use (defaults to first agent)
             load_skills: Whether to load client-side skills from .claude/skills
             config_path: Path to the configuration file (for tracking/hot-switching)
+            transport: Transport configuration ("stdio", "websocket", or transport object)
         """
         super().__init__(pool, name=name, raise_exceptions=True)
         self.file_access = file_access
         self.terminal_access = terminal_access
-        self.providers = providers or ["openai", "anthropic", "gemini"]
         self.debug_messages = debug_messages
         self.debug_file = debug_file
         self.debug_commands = debug_commands
         self.agent = agent
         self.load_skills = load_skills
         self.config_path = config_path
-
-        self._available_models: list[ACPModelInfo] = []
-        self._models_initialized = False
+        self.transport: Transport = transport
 
     @classmethod
     def from_config(
@@ -119,12 +85,12 @@ class ACPServer(BaseServer):
         *,
         file_access: bool = True,
         terminal_access: bool = True,
-        providers: list[ProviderType] | None = None,
         debug_messages: bool = False,
         debug_file: str | None = None,
         debug_commands: bool = False,
         agent: str | None = None,
         load_skills: bool = True,
+        transport: Transport = "stdio",
     ) -> Self:
         """Create ACP server from existing agentpool configuration.
 
@@ -132,12 +98,12 @@ class ACPServer(BaseServer):
             config_path: Path to agentpool YAML config file
             file_access: Enable file system access
             terminal_access: Enable terminal access
-            providers: List of provider types to use for model discovery
             debug_messages: Enable saving JSON messages to file
             debug_file: Path to debug file
             debug_commands: Enable debug slash commands for testing
             agent: Optional specific agent name to use (defaults to first agent)
             load_skills: Whether to load client-side skills from .claude/skills
+            transport: Transport configuration ("stdio", "websocket", or transport object)
 
         Returns:
             Configured ACP server instance with agent pool from config
@@ -148,13 +114,13 @@ class ACPServer(BaseServer):
             pool,
             file_access=file_access,
             terminal_access=terminal_access,
-            providers=providers,
             debug_messages=debug_messages,
             debug_file=debug_file or "acp-debug.jsonl" if debug_messages else None,
             debug_commands=debug_commands,
             agent=agent,
             load_skills=load_skills,
             config_path=str(config_path),
+            transport=transport,
         )
         agent_names = list(server.pool.agents.keys())
 
@@ -170,13 +136,13 @@ class ACPServer(BaseServer):
 
     async def _start_async(self) -> None:
         """Start the ACP server (blocking async - runs until stopped)."""
-        agent_names = list(self.pool.agents.keys())
-        self.log.info("Starting ACP server on stdio", agent_names=agent_names)
-        await self._initialize_models()  # Initialize models on first run
+        transport_name = (
+            type(self.transport).__name__ if not isinstance(self.transport, str) else self.transport
+        )
+        self.log.info("Starting ACP server", transport=transport_name)
         create_acp_agent = functools.partial(
             AgentPoolACPAgent,
             agent_pool=self.pool,
-            available_models=self._available_models,
             file_access=self.file_access,
             terminal_access=self.terminal_access,
             debug_commands=self.debug_commands,
@@ -184,27 +150,26 @@ class ACPServer(BaseServer):
             load_skills=self.load_skills,
             server=self,
         )
-        reader, writer = await stdio_streams()
-        file = self.debug_file if self.debug_messages else None
-        conn = AgentSideConnection(create_acp_agent, writer, reader, debug_file=file)
+
+        debug_file = self.debug_file if self.debug_messages else None
         self.log.info("ACP server started", file=self.file_access, terminal=self.terminal_access)
-        try:  # Keep the connection alive until shutdown
-            await self._shutdown_event.wait()
+
+        try:
+            await serve(
+                create_acp_agent,
+                transport=self.transport,
+                shutdown_event=self._shutdown_event,
+                debug_file=debug_file,
+            )
         except asyncio.CancelledError:
             self.log.info("ACP server shutdown requested")
             raise
         except KeyboardInterrupt:
             self.log.info("ACP server shutdown requested")
         except Exception:
-            self.log.exception("Connection receive task failed")
-        finally:
-            await conn.close()
+            self.log.exception("ACP server error")
 
-    async def swap_pool(
-        self,
-        config_path: str,
-        agent: str | None = None,
-    ) -> list[str]:
+    async def swap_pool(self, config_path: str, agent: str | None = None) -> list[str]:
         """Swap the current pool with a new one from config.
 
         This method handles the full lifecycle of swapping pools:
@@ -228,17 +193,14 @@ class ACPServer(BaseServer):
         self.log.info("Loading new pool configuration", config_path=config_path)
         new_manifest = AgentsManifest.from_file(config_path)
         new_pool = AgentPool(manifest=new_manifest)
-
         # 2. Validate agent exists in new pool if specified
         agent_names = list(new_pool.all_agents.keys())
         if not agent_names:
             msg = "New configuration contains no agents"
             raise ValueError(msg)
-
         if agent and agent not in agent_names:
             msg = f"Agent {agent!r} not found in new config. Available: {agent_names}"
             raise ValueError(msg)
-
         # 3. Enter new pool context first (so we can roll back if it fails)
         try:
             await new_pool.__aenter__()
@@ -246,43 +208,15 @@ class ACPServer(BaseServer):
             self.log.exception("Failed to initialize new pool")
             msg = f"Failed to initialize new pool: {e}"
             raise ValueError(msg) from e
-
         # 4. Exit old pool context
         old_pool = self.pool
         try:
             await old_pool.__aexit__(None, None, None)
         except Exception:
             self.log.exception("Error closing old pool (continuing with swap)")
-
         # 5. Update references
         self.pool = new_pool
         self.agent = agent
         self.config_path = config_path
-
         self.log.info("Pool swapped successfully", agent_names=agent_names, default_agent=agent)
         return agent_names
-
-    @logfire.instrument("ACP: Initializing models.")
-    async def _initialize_models(self) -> None:
-        """Initialize available models using tokonomics model discovery.
-
-        Converts tokonomics ModelInfo to ACP ModelInfo format at startup
-        so all downstream code works with ACP types consistently.
-        """
-        from tokonomics.model_discovery import get_all_models
-
-        if self._models_initialized:
-            return
-        try:
-            self.log.info("Discovering available models...")
-            delta = timedelta(days=200)
-            toko_models = await get_all_models(providers=self.providers, max_age=delta)
-            # Convert to ACP format once at startup
-            self._available_models = _convert_to_acp_model_info(toko_models)
-            self._models_initialized = True
-            self.log.info("Discovered models", count=len(self._available_models))
-        except Exception:
-            self.log.exception("Failed to discover models")
-            self._available_models = []
-        finally:
-            self._models_initialized = True