agentpool 2.2.3__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

@@ -169,11 +169,7 @@ class ACPServer(BaseServer):
         except Exception:
             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:
@@ -197,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__()
@@ -215,18 +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