agentpool 2.2.0__tar.gz → 2.2.2__tar.gz

{agentpool-2.2.0 → agentpool-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentpool
-Version: 2.2.0
+Version: 2.2.2
 Summary: Pydantic-AI based Multi-Agent Framework with YAML-based Agents, Teams, Workflows & Extended ACP / AGUI integration
 Keywords: 
 Author: Philipp Temminghoff
@@ -55,6 +55,7 @@ Requires-Dist: tokonomics>=0.1.2
 Requires-Dist: toprompt>=0.0.1
 Requires-Dist: typer
 Requires-Dist: upathtools>=0.1.0
+Requires-Dist: watchfiles>=1.1.1
 Requires-Dist: websockets>=15.0
 Requires-Dist: yamling>=2.0.2
 Requires-Dist: fasta2a ; extra == 'a2a'

{agentpool-2.2.0 → agentpool-2.2.2}/pyproject.toml

@@ -2,7 +2,7 @@
 
 [project]
 name = "agentpool"
-version = "2.2.0"
+version = "2.2.2"
 description = "Pydantic-AI based Multi-Agent Framework with YAML-based Agents, Teams, Workflows & Extended ACP / AGUI integration"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -65,6 +65,7 @@ dependencies = [
   "toprompt>=0.0.1",
   "typer",
   "upathtools>=0.1.0",
+  "watchfiles>=1.1.1",
   "websockets>=15.0",
   "yamling>=2.0.2",
 ]
@@ -261,7 +262,7 @@ reportPrivateImportUsage = false
 reportUnusedExpression = false
 
 [tool.pytest]
-addopts = ["-m", "not slow and not acp_cli_snapshot"]
+addopts = ["-m", "not slow and not acp_snapshot"]
 filterwarnings = [
   "ignore::DeprecationWarning:psygnal.*",
   "ignore::DeprecationWarning:pydantic.*:",
@@ -272,7 +273,7 @@ log_date_format = "%Y-%m-%d %H:%M:%S"
 log_format = "%(asctime)s %(levelname)s %(message)s"
 log_level = "ERROR"
 markers = [
-  "acp_cli_snapshot: marks tests as ACP CLI snapshot tests (excluded by default)",
+  "acp_snapshot: marks tests as ACP snapshot tests (excluded by default)",
   "asyncio: mark test as async",
   "integration: marks tests as integration tests",
   "slow: marks tests as slow",

{agentpool-2.2.0 → agentpool-2.2.2}/src/acp/stdio.py

@@ -87,10 +87,20 @@ async def spawn_stdio_connection(
     env: Mapping[str, str] | None = None,
     cwd: str | Path | None = None,
     observers: list[StreamObserver] | None = None,
-    **transport_kwargs: Any,
+    log_stderr: bool = False,
 ) -> AsyncIterator[tuple[Connection, Process]]:
-    """Spawn a subprocess and bind its stdio to a low-level Connection."""
-    async with spawn_stdio_transport(command, *args, env=env, cwd=cwd, **transport_kwargs) as (
+    """Spawn a subprocess and bind its stdio to a low-level Connection.
+
+    Args:
+        handler: Method handler for the connection.
+        command: The command to execute.
+        *args: Arguments for the command.
+        env: Environment variables for the subprocess.
+        cwd: Working directory for the subprocess.
+        observers: Optional stream observers.
+        log_stderr: If True, log stderr output from the subprocess.
+    """
+    async with spawn_stdio_transport(command, *args, env=env, cwd=cwd, log_stderr=log_stderr) as (
         reader,
         writer,
         process,
@@ -109,16 +119,26 @@ async def spawn_agent_process(
     *args: str,
     env: Mapping[str, str] | None = None,
     cwd: str | Path | None = None,
-    transport_kwargs: Mapping[str, Any] | None = None,
+    log_stderr: bool = False,
     **connection_kwargs: Any,
 ) -> AsyncIterator[tuple[ClientSideConnection, Process]]:
-    """Spawn an ACP agent subprocess and return a ClientSideConnection to it."""
+    """Spawn an ACP agent subprocess and return a ClientSideConnection to it.
+
+    Args:
+        to_client: Factory function that creates a Client from an Agent.
+        command: The command to execute.
+        *args: Arguments for the command.
+        env: Environment variables for the subprocess.
+        cwd: Working directory for the subprocess.
+        log_stderr: If True, log stderr output from the subprocess.
+        **connection_kwargs: Additional arguments for ClientSideConnection.
+    """
     async with spawn_stdio_transport(
         command,
         *args,
         env=env,
         cwd=cwd,
-        **(dict(transport_kwargs) if transport_kwargs else {}),
+        log_stderr=log_stderr,
     ) as (reader, writer, process):
         conn = ClientSideConnection(to_client, writer, reader, **connection_kwargs)
         try:
@@ -134,16 +154,26 @@ async def spawn_client_process(
     *args: str,
     env: Mapping[str, str] | None = None,
     cwd: str | Path | None = None,
-    transport_kwargs: Mapping[str, Any] | None = None,
+    log_stderr: bool = False,
     **connection_kwargs: Any,
 ) -> AsyncIterator[tuple[AgentSideConnection, Process]]:
-    """Spawn an ACP client subprocess and return an AgentSideConnection to it."""
+    """Spawn an ACP client subprocess and return an AgentSideConnection to it.
+
+    Args:
+        to_agent: Factory function that creates an Agent from an AgentSideConnection.
+        command: The command to execute.
+        *args: Arguments for the command.
+        env: Environment variables for the subprocess.
+        cwd: Working directory for the subprocess.
+        log_stderr: If True, log stderr output from the subprocess.
+        **connection_kwargs: Additional arguments for AgentSideConnection.
+    """
     async with spawn_stdio_transport(
         command,
         *args,
         env=env,
         cwd=cwd,
-        **(dict(transport_kwargs) if transport_kwargs else {}),
+        log_stderr=log_stderr,
     ) as (reader, writer, process):
         conn = AgentSideConnection(to_agent, writer, reader, **connection_kwargs)
         try:

{agentpool-2.2.0 → agentpool-2.2.2}/src/acp/transports.py

@@ -362,6 +362,32 @@ def default_environment() -> dict[str, str]:
     return env
 
 
+async def _drain_stderr_to_log(
+    process: Process,
+    command: str,
+    log_level: int = logging.WARNING,
+) -> None:
+    """Read stderr from a process and log each line.
+
+    Args:
+        process: The subprocess to read stderr from.
+        command: Command name for log messages.
+        log_level: Log level for stderr output (default WARNING).
+    """
+    if process.stderr is None:
+        return
+
+    try:
+        async for line_bytes in process.stderr:
+            line = line_bytes.decode(errors="replace").rstrip()
+            if line:
+                logger.log(log_level, "[%s stderr] %s", command, line)
+    except anyio.EndOfStream:
+        pass
+    except Exception:  # noqa: BLE001
+        logger.debug("Error reading stderr from %s", command, exc_info=True)
+
+
 @asynccontextmanager
 async def spawn_stdio_transport(
     command: str,
@@ -370,11 +396,23 @@ async def spawn_stdio_transport(
     cwd: str | Path | None = None,
     stderr: int | None = subprocess.PIPE,
     shutdown_timeout: float = 2.0,
+    log_stderr: bool = False,
+    stderr_log_level: int = logging.WARNING,
 ) -> AsyncIterator[tuple[ByteReceiveStream, ByteSendStream, Process]]:
     """Launch a subprocess and expose its stdio streams as anyio streams.
 
     This mirrors the defensive shutdown behaviour used by the MCP Python SDK:
     close stdin first, wait for graceful exit, then escalate to terminate/kill.
+
+    Args:
+        command: The command to execute.
+        *args: Arguments for the command.
+        env: Environment variables (merged with defaults).
+        cwd: Working directory for the subprocess.
+        stderr: How to handle stderr (default: subprocess.PIPE).
+        shutdown_timeout: Timeout for graceful shutdown.
+        log_stderr: If True, read stderr in background and log each line.
+        stderr_log_level: Log level for stderr output (default WARNING).
     """
     merged_env = default_environment()
     if env:
@@ -395,9 +433,19 @@ async def spawn_stdio_transport(
         msg = "spawn_stdio_transport requires stdout/stdin pipes"
         raise RuntimeError(msg)
 
+    stderr_task: asyncio.Task[None] | None = None
+    if log_stderr and process.stderr is not None:
+        stderr_task = asyncio.create_task(_drain_stderr_to_log(process, command, stderr_log_level))
+
     try:
         yield process.stdout, process.stdin, process
     finally:
+        # Cancel stderr logging task
+        if stderr_task is not None:
+            stderr_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await stderr_task
+
         # Attempt graceful stdin shutdown first
         if process.stdin is not None:
             with contextlib.suppress(Exception):

{agentpool-2.2.0 → agentpool-2.2.2}/src/acp/utils.py

@@ -122,6 +122,14 @@ def generate_tool_title(tool_name: str, tool_input: dict[str, Any]) -> str:  # n
     """
     name_lower = tool_name.lower()
 
+    # Exact matches for common tool names (OpenCode compatibility)
+    if name_lower == "read" and (path := tool_input.get("path") or tool_input.get("file_path")):
+        return f"Reading: {path}"
+    if name_lower in ("write", "edit") and (
+        path := tool_input.get("path") or tool_input.get("file_path")
+    ):
+        return f"Editing: {path}"
+
     # Command/script execution - show the command
     if any(k in name_lower for k in ["command", "execute", "run", "shell", "script"]) and (
         cmd := tool_input.get("command")
@@ -217,6 +225,11 @@ def infer_tool_kind(tool_name: str) -> ToolCallKind:  # noqa: PLR0911
         Tool kind string for ACP protocol
     """
     name_lower = tool_name.lower()
+
+    # Exact matches for common tool names (OpenCode compatibility)
+    if name_lower in ("read", "write", "edit"):
+        return "read" if name_lower == "read" else "edit"
+
     if any(i in name_lower for i in ["read", "load", "get"]) and any(
         i in name_lower for i in ["file", "path", "content"]
     ):

{agentpool-2.2.0 → agentpool-2.2.2}/src/agentpool/agents/acp_agent/acp_agent.py

@@ -60,6 +60,7 @@ from agentpool.utils.streams import (
     merge_queue_into_iterator,
 )
 from agentpool.utils.subprocess_utils import SubprocessError, monitor_process
+from agentpool.utils.token_breakdown import calculate_usage_from_parts
 
 
 if TYPE_CHECKING:
@@ -684,6 +685,17 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
 
         text_content = "".join(text_chunks)
         metadata = file_tracker.get_metadata()
+
+        # Calculate approximate token usage from what we can observe
+        input_parts = [*processed_prompts, *pending_parts]
+        usage, cost_info = await calculate_usage_from_parts(
+            input_parts=input_parts,
+            response_parts=current_response_parts,
+            text_content=text_content,
+            model_name=self.model_name,
+            provider=self.config.type,
+        )
+
         message = ChatMessage[str](
             content=text_content,
             role="assistant",
@@ -695,6 +707,8 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
             messages=model_messages,
             metadata=metadata,
             finish_reason=finish_reason,
+            usage=usage,
+            cost_info=cost_info,
         )
         complete_event = StreamCompleteEvent(message=message)
         await handler(None, complete_event)

{agentpool-2.2.0 → agentpool-2.2.2}/src/agentpool/agents/acp_agent/acp_converters.py

@@ -265,6 +265,9 @@ def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None: ...
 def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None:
     """Convert native MCPServerConfig to ACP McpServer format.
 
+    If the config has tool filtering (enabled_tools or disabled_tools),
+    the server is wrapped with mcp-filter proxy to apply the filtering.
+
     Args:
         config: agentpool MCP server configuration
 
@@ -279,19 +282,27 @@ def mcp_config_to_acp(config: MCPServerConfig) -> McpServer | None:
         StreamableHTTPMCPServerConfig,
     )
 
+    # If filtering is configured, wrap with mcp-filter first
+    if config.needs_tool_filtering():
+        config = config.wrap_with_mcp_filter()
+
     match config:
         case StdioMCPServerConfig(command=command, args=args):
             env_vars = config.get_env_vars() if hasattr(config, "get_env_vars") else {}
+            env_list = [EnvVariable(name=k, value=v) for k, v in env_vars.items()]
             return StdioMcpServer(
                 name=config.name or command,
                 command=command,
                 args=list(args) if args else [],
-                env=[EnvVariable(name=k, value=v) for k, v in env_vars.items()],
+                env=env_list,
             )
+
         case SSEMCPServerConfig(url=url):
             return SseMcpServer(name=config.name or str(url), url=url, headers=[])
+
         case StreamableHTTPMCPServerConfig(url=url):
             return HttpMcpServer(name=config.name or str(url), url=url, headers=[])
+
         case _:
             return None
 

{agentpool-2.2.0 → agentpool-2.2.2}/src/agentpool/agents/acp_agent/client_handler.py

@@ -224,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

{agentpool-2.2.0 → agentpool-2.2.2}/src/agentpool/agents/agent.py

@@ -222,7 +222,7 @@ class Agent[TDeps = None, OutputDataT = str](BaseAgent[TDeps, OutputDataT]):
             builtin_tools: PydanticAI builtin tools (WebSearchTool, CodeExecutionTool, etc.)
             usage_limits: Usage limits for the agent
             providers: Model providers for model discovery (e.g., ["openai", "anthropic"]).
-                Defaults to ["openai", "anthropic", "gemini"] if not specified.
+                Defaults to ["models.dev"] if not specified.
             commands: Slash commands
         """
         from agentpool.agents.interactions import Interactions
@@ -1302,10 +1302,11 @@ class Agent[TDeps = None, OutputDataT = str](BaseAgent[TDeps, OutputDataT]):
 
         from tokonomics.model_discovery import get_all_models
 
-        providers = self._providers or ["openai", "anthropic", "gemini"]
         try:
             max_age = timedelta(days=200)
-            return await get_all_models(providers=providers, max_age=max_age)
+            return await get_all_models(
+                providers=self._providers or ["models.dev"], max_age=max_age
+            )
         except Exception:
             self.log.exception("Failed to discover models")
             return None

{agentpool-2.2.0 → agentpool-2.2.2}/src/agentpool/agents/agui_agent/agui_agent.py

@@ -36,6 +36,7 @@ from agentpool.messaging import ChatMessage
 from agentpool.messaging.processing import prepare_prompts
 from agentpool.tools import ToolManager
 from agentpool.utils.streams import FileTracker
+from agentpool.utils.token_breakdown import calculate_usage_from_parts
 
 
 if TYPE_CHECKING:
@@ -627,6 +628,16 @@ class AGUIAgent[TDeps = None](BaseAgent[TDeps, str]):
                 break
 
         text_content = "".join(text_chunks)
+
+        # Calculate approximate token usage from what we can observe
+        input_parts = [*processed_prompts, *pending_parts]
+        usage, cost_info = await calculate_usage_from_parts(
+            input_parts=input_parts,
+            response_parts=current_response_parts,
+            text_content=text_content,
+            model_name=self.model_name,
+        )
+
         final_message = ChatMessage[str](
             content=text_content,
             role="assistant",
@@ -636,6 +647,8 @@ class AGUIAgent[TDeps = None](BaseAgent[TDeps, str]):
             parent_id=user_msg.message_id,
             messages=model_messages,
             metadata=file_tracker.get_metadata(),
+            usage=usage,
+            cost_info=cost_info,
         )
         complete_event = StreamCompleteEvent(message=final_message)
         await self.event_handler(None, complete_event)

{agentpool-2.2.0 → agentpool-2.2.2}/src/agentpool/agents/base_agent.py

@@ -28,7 +28,11 @@ if TYPE_CHECKING:
     from agentpool.agents.context import AgentContext
     from agentpool.agents.events import RichAgentStreamEvent
     from agentpool.agents.modes import ModeCategory, ModeInfo
-    from agentpool.common_types import BuiltinEventHandlerType, IndividualEventHandler
+    from agentpool.common_types import (
+        BuiltinEventHandlerType,
+        IndividualEventHandler,
+        MCPServerStatus,
+    )
     from agentpool.delegation import AgentPool
     from agentpool.talk.stats import MessageStats
     from agentpool.ui.base import InputProvider
@@ -127,9 +131,15 @@ class BaseAgent[TDeps = None, TResult = str](MessageNode[TDeps, TResult]):
         # Command store for slash commands
         from slashed import CommandStore
 
+        from agentpool_commands import get_commands
+
         self._command_store: CommandStore = CommandStore()
 
-        # Register provided commands
+        # Register default agent commands
+        for command in get_commands():
+            self._command_store.register_command(command)
+
+        # Register additional provided commands
         if commands:
             for command in commands:
                 self._command_store.register_command(command)
@@ -222,6 +232,56 @@ class BaseAgent[TDeps = None, TResult = str](MessageNode[TDeps, TResult]):
 
         return MessageStats(messages=list(self.conversation.chat_messages))
 
+    def get_mcp_server_info(self) -> dict[str, MCPServerStatus]:
+        """Get information about configured MCP servers.
+
+        Returns a dict mapping server names to their status info. Used by
+        the OpenCode /mcp endpoint to display MCP servers in the UI.
+
+        The default implementation checks external_providers on the tool manager.
+        Subclasses may override to provide agent-specific MCP server info
+        (e.g., ClaudeCodeAgent has its own MCP server handling).
+
+        Returns:
+            Dict mapping server name to MCPServerStatus
+        """
+        from agentpool.common_types import MCPServerStatus
+        from agentpool.mcp_server.manager import MCPManager
+        from agentpool.resource_providers import AggregatingResourceProvider
+        from agentpool.resource_providers.mcp_provider import MCPResourceProvider
+
+        def add_status(provider: MCPResourceProvider, result: dict[str, MCPServerStatus]) -> None:
+            status_dict = provider.get_status()
+            status_type = status_dict.get("status", "disabled")
+            if status_type == "connected":
+                result[provider.name] = MCPServerStatus(
+                    name=provider.name, status="connected", server_type="stdio"
+                )
+            elif status_type == "failed":
+                error = status_dict.get("error", "Unknown error")
+                result[provider.name] = MCPServerStatus(
+                    name=provider.name, status="error", error=error
+                )
+            else:
+                result[provider.name] = MCPServerStatus(name=provider.name, status="disconnected")
+
+        result: dict[str, MCPServerStatus] = {}
+        try:
+            for provider in self.tools.external_providers:
+                if isinstance(provider, MCPResourceProvider):
+                    add_status(provider, result)
+                elif isinstance(provider, AggregatingResourceProvider):
+                    for nested in provider.providers:
+                        if isinstance(nested, MCPResourceProvider):
+                            add_status(nested, result)
+                elif isinstance(provider, MCPManager):
+                    for mcp_provider in provider.get_mcp_providers():
+                        add_status(mcp_provider, result)
+        except Exception:  # noqa: BLE001
+            pass
+
+        return result
+
     @abstractmethod
     async def get_available_models(self) -> list[ModelInfo] | None:
         """Get available models for this agent.