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

agentpool/agents/acp_agent/acp_agent.py

@@ -50,12 +50,17 @@ from agentpool.agents.acp_agent.client_handler import ACPClientHandler
 from agentpool.agents.acp_agent.session_state import ACPSessionState
 from agentpool.agents.base_agent import BaseAgent
 from agentpool.agents.events import RunStartedEvent, StreamCompleteEvent, ToolCallStartEvent
+from agentpool.agents.modes import ModeInfo
 from agentpool.log import get_logger
 from agentpool.messaging import ChatMessage
 from agentpool.messaging.processing import prepare_prompts
 from agentpool.models.acp_agents import ACPAgentConfig, MCPCapableACPAgentConfig
-from agentpool.talk.stats import MessageStats
-from agentpool.utils.streams import merge_queue_into_iterator
+from agentpool.utils.streams import (
+    FileTracker,
+    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:
@@ -66,7 +71,8 @@ if TYPE_CHECKING:
     from evented.configs import EventConfig
     from exxec import ExecutionEnvironment
     from pydantic_ai import FinishReason
-    from tokonomics.model_discovery import ProviderType
+    from slashed import BaseCommand
+    from tokonomics.model_discovery.model_info import ModelInfo
 
     from acp.agent.protocol import Agent as ACPAgentProtocol
     from acp.client.connection import ClientSideConnection
@@ -80,6 +86,7 @@ if TYPE_CHECKING:
     from acp.schema.mcp import McpServer
     from agentpool.agents import AgentContext
     from agentpool.agents.events import RichAgentStreamEvent
+    from agentpool.agents.modes import ModeCategory
     from agentpool.common_types import (
         BuiltinEventHandlerType,
         IndividualEventHandler,
@@ -106,34 +113,6 @@ STOP_REASON_MAP: dict[StopReason, FinishReason] = {
 }
 
 
-def extract_file_path_from_tool_call(tool_name: str, raw_input: dict[str, Any]) -> str | None:
-    """Extract file path from a tool call if it's a file-writing tool.
-
-    Uses simple heuristics by default:
-    - Tool name contains 'write' or 'edit' (case-insensitive)
-    - Input contains 'path' or 'file_path' key
-
-    Override in subclasses for agent-specific tool naming conventions.
-
-    Args:
-        tool_name: Name of the tool being called
-        raw_input: Tool call arguments
-
-    Returns:
-        File path if this is a file-writing tool, None otherwise
-    """
-    name_lower = tool_name.lower()
-    if "write" not in name_lower and "edit" not in name_lower:
-        return None
-
-    # Try common path argument names
-    for key in ("file_path", "path", "filepath", "filename", "file"):
-        if key in raw_input and isinstance(val := raw_input[key], str):
-            return val
-
-    return None
-
-
 class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
     """MessageNode that wraps an external ACP agent subprocess.
 
@@ -174,6 +153,7 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         enable_logging: bool = True,
         event_configs: Sequence[EventConfig] | None = None,
         event_handlers: Sequence[IndividualEventHandler | BuiltinEventHandlerType] | None = None,
+        commands: Sequence[BaseCommand] | None = None,
     ) -> None: ...
 
     @overload
@@ -190,13 +170,13 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         env: ExecutionEnvironment | None = None,
         allow_file_operations: bool = True,
         allow_terminal: bool = True,
-        providers: list[ProviderType] | None = None,
         input_provider: InputProvider | None = None,
         agent_pool: AgentPool[Any] | None = None,
         enable_logging: bool = True,
         event_configs: Sequence[EventConfig] | None = None,
         event_handlers: Sequence[IndividualEventHandler | BuiltinEventHandlerType] | None = None,
         tool_confirmation_mode: ToolConfirmationMode = "always",
+        commands: Sequence[BaseCommand] | None = None,
     ) -> None: ...
 
     def __init__(
@@ -213,13 +193,13 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         env: ExecutionEnvironment | None = None,
         allow_file_operations: bool = True,
         allow_terminal: bool = True,
-        providers: list[ProviderType] | None = None,
         input_provider: InputProvider | None = None,
         agent_pool: AgentPool[Any] | None = None,
         enable_logging: bool = True,
         event_configs: Sequence[EventConfig] | None = None,
         event_handlers: Sequence[IndividualEventHandler | BuiltinEventHandlerType] | None = None,
         tool_confirmation_mode: ToolConfirmationMode = "always",
+        commands: Sequence[BaseCommand] | None = None,
     ) -> None:
         # Build config from kwargs if not provided
         if config is None:
@@ -237,7 +217,6 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
                 allow_file_operations=allow_file_operations,
                 allow_terminal=allow_terminal,
                 requires_tool_confirmation=tool_confirmation_mode,
-                providers=list(providers) if providers else [],
             )
 
         super().__init__(
@@ -252,6 +231,7 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
             input_provider=input_provider,
             tool_confirmation_mode=tool_confirmation_mode,
             event_handlers=event_handlers,
+            commands=commands,
         )
 
         # ACP-specific state
@@ -327,9 +307,13 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         """Start subprocess and initialize ACP connection."""
         await super().__aenter__()
         await self._setup_toolsets()  # Setup toolsets before session creation
-        await self._start_process()
-        await self._initialize()
-        await self._create_session()
+        process = await self._start_process()
+        try:
+            async with monitor_process(process, context="ACP initialization"):
+                await self._initialize()
+                await self._create_session()
+        except SubprocessError as e:
+            raise RuntimeError(str(e)) from e
         await anyio.sleep(0.3)  # Small delay to let subprocess fully initialize
         return self
 
@@ -343,8 +327,12 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         await self._cleanup()
         await super().__aexit__(exc_type, exc_val, exc_tb)
 
-    async def _start_process(self) -> None:
-        """Start the ACP server subprocess."""
+    async def _start_process(self) -> Process:
+        """Start the ACP server subprocess.
+
+        Returns:
+            The started Process instance
+        """
         prompt_manager = self.agent_pool.manifest.prompt_manager if self.agent_pool else None
         args = await self.config.get_args(prompt_manager)
         cmd = [self.config.get_command(), *args]
@@ -361,9 +349,12 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         if not self._process.stdin or not self._process.stdout:
             msg = "Failed to create subprocess pipes"
             raise RuntimeError(msg)
+        return self._process
 
     async def _initialize(self) -> None:
         """Initialize the ACP connection."""
+        from importlib.metadata import metadata
+
         from acp.client.connection import ClientSideConnection
         from acp.schema import InitializeRequest
 
@@ -382,9 +373,10 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
             input_stream=self._process.stdin,
             output_stream=self._process.stdout,
         )
+        pkg_meta = metadata("agentpool")
         init_request = InitializeRequest.create(
-            title="AgentPool",
-            version="0.1.0",
+            title=pkg_meta["Name"],
+            version=pkg_meta["Version"],
             name="agentpool",
             protocol_version=PROTOCOL_VERSION,
             terminal=self.config.allow_terminal,
@@ -422,10 +414,6 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         model = self._state.current_model_id if self._state else None
         self.log.info("ACP session created", session_id=self._session_id, model=model)
 
-    def add_mcp_server(self, server: McpServer) -> None:
-        """Add an MCP server to be passed to the next session."""
-        self._extra_mcp_servers.append(server)
-
     async def add_tool_bridge(self, bridge: ToolManagerBridge) -> None:
         """Add an external tool bridge to expose its tools via MCP.
 
@@ -517,6 +505,8 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         message_id: str | None = None,
         input_provider: InputProvider | None = None,
         message_history: MessageHistory | None = None,
+        deps: TDeps | None = None,
+        event_handlers: Sequence[IndividualEventHandler | BuiltinEventHandlerType] | None = None,
     ) -> AsyncIterator[RichAgentStreamEvent[str]]:
         """Stream native events as they arrive from ACP agent.
 
@@ -525,6 +515,8 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
             message_id: Optional message id for the final message
             input_provider: Optional input provider for permission requests
             message_history: Optional MessageHistory to use instead of agent's own
+            deps: Optional dependencies accessible via ctx.data in tools
+            event_handlers: Optional event handlers for this run (overrides agent's handlers)
 
         Yields:
             RichAgentStreamEvent instances converted from ACP session updates
@@ -541,14 +533,26 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
             msg = "Agent not initialized - use async context manager"
             raise RuntimeError(msg)
 
-        # Capture state for use in nested function (avoids type narrowing issues)
-        state = self._state
-
         conversation = message_history if message_history is not None else self.conversation
+        # Use provided event handlers or fall back to agent's handlers
+        if event_handlers is not None:
+            from anyenv import MultiEventHandler
+
+            from agentpool.agents.events import resolve_event_handlers
+
+            handler: MultiEventHandler[IndividualEventHandler] = MultiEventHandler(
+                resolve_event_handlers(event_handlers)
+            )
+        else:
+            handler = self.event_handler
         # Prepare user message for history and convert to ACP content blocks
-        user_msg, processed_prompts, _original_message = await prepare_prompts(*prompts)
+        # Get parent_id from last message in history for tree structure
+        last_msg_id = conversation.get_last_message_id()
+        user_msg, processed_prompts, _original_message = await prepare_prompts(
+            *prompts, parent_id=last_msg_id
+        )
         run_id = str(uuid.uuid4())
-        state.clear()  # Reset state
+        self._state.clear()  # Reset state
         # Track messages in pydantic-ai format: ModelRequest -> ModelResponse -> ...
         # This mirrors pydantic-ai's new_messages() which includes the initial user request.
         model_messages: list[ModelResponse | ModelRequest] = []
@@ -557,25 +561,22 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         model_messages.append(initial_request)
         current_response_parts: list[TextPart | ThinkingPart | ToolCallPart] = []
         text_chunks: list[str] = []  # For final content string
-        touched_files: set[str] = set()  # Track files modified by tool calls
+        file_tracker = FileTracker()  # Track files modified by tool calls
         run_started = RunStartedEvent(
             thread_id=self.conversation_id,
             run_id=run_id,
             agent_name=self.name,
         )
-        for handler in self.event_handler._wrapped_handlers:
-            await handler(None, run_started)
+        await handler(None, run_started)
         yield run_started
         content_blocks = convert_to_acp_content(processed_prompts)
         pending_parts = conversation.get_pending_parts()
         final_blocks = [*to_acp_content_blocks(pending_parts), *content_blocks]
         prompt_request = PromptRequest(session_id=self._session_id, prompt=final_blocks)
         self.log.debug("Starting streaming prompt", num_blocks=len(final_blocks))
-
         # Reset cancellation state
         self._cancelled = False
         self._current_stream_task = asyncio.current_task()
-
         # Run prompt in background
         prompt_task = asyncio.create_task(self._connection.prompt(prompt_request))
         self._prompt_task = prompt_task
@@ -584,6 +585,7 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         async def poll_acp_events() -> AsyncIterator[RichAgentStreamEvent[str]]:
             """Poll events from ACP state until prompt completes."""
             last_idx = 0
+            assert self._state
             while not prompt_task.done():
                 if self._client_handler:
                     try:
@@ -595,21 +597,26 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
                         pass
 
                 # Yield new events from state
-                while last_idx < len(state.events):
-                    yield state.events[last_idx]
+                while last_idx < len(self._state.events):
+                    yield self._state.events[last_idx]
                     last_idx += 1
 
             # Yield remaining events after prompt completes
-            while last_idx < len(state.events):
-                yield state.events[last_idx]
+            while last_idx < len(self._state.events):
+                yield self._state.events[last_idx]
                 last_idx += 1
 
+        # Set deps on tool bridge for access during tool invocations
+        # (ContextVar doesn't work because MCP server runs in a separate task)
+        if self._tool_bridge:
+            self._tool_bridge.current_deps = deps
+
         # Merge ACP events with custom events from queue
         try:
             async with merge_queue_into_iterator(
                 poll_acp_events(), self._event_queue
             ) as merged_events:
-                async for event in merged_events:
+                async for event in file_tracker.track(merged_events):
                     # Check for cancellation
                     if self._cancelled:
                         self.log.info("Stream cancelled by user")
@@ -628,40 +635,35 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
                             current_response_parts.append(
                                 ToolCallPart(tool_name=tc_name, args=tc_input, tool_call_id=tc_id)
                             )
-                            # Track files modified by write/edit tools
-                            if file_path := extract_file_path_from_tool_call(
-                                tc_name or "", tc_input or {}
-                            ):
-                                touched_files.add(file_path)
-
-                    # Distribute to handlers
-                    for handler in self.event_handler._wrapped_handlers:
-                        await handler(None, event)
+
+                    await handler(None, event)
                     yield event
         except asyncio.CancelledError:
             self.log.info("Stream cancelled via task cancellation")
             self._cancelled = True
+        finally:
+            # Clear deps from tool bridge
+            if self._tool_bridge:
+                self._tool_bridge.current_deps = None
 
         # Handle cancellation - emit partial message
         if self._cancelled:
             text_content = "".join(text_chunks)
-            metadata: SimpleJsonType = {}
-            if touched_files:
-                metadata["touched_files"] = sorted(touched_files)
+            metadata: SimpleJsonType = file_tracker.get_metadata()
             message = ChatMessage[str](
                 content=text_content,
                 role="assistant",
                 name=self.name,
                 message_id=message_id or str(uuid.uuid4()),
                 conversation_id=self.conversation_id,
+                parent_id=user_msg.message_id,
                 model_name=self.model_name,
                 messages=model_messages,
                 metadata=metadata,
                 finish_reason="stop",
             )
             complete_event = StreamCompleteEvent(message=message)
-            for handler in self.event_handler._wrapped_handlers:
-                await handler(None, complete_event)
+            await handler(None, complete_event)
             yield complete_event
             self._current_stream_task = None
             self._prompt_task = None
@@ -672,27 +674,44 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         finish_reason: FinishReason = STOP_REASON_MAP.get(response.stop_reason, "stop")
         # Flush response parts to model_messages
         if current_response_parts:
-            model_messages.append(ModelResponse(parts=current_response_parts))
+            model_messages.append(
+                ModelResponse(
+                    parts=current_response_parts,
+                    finish_reason=finish_reason,
+                    model_name=self.model_name,
+                    provider_name=self.config.type,
+                )
+            )
 
         text_content = "".join(text_chunks)
-        # Build metadata with touched files if any
-        metadata = {}
-        if touched_files:
-            metadata["touched_files"] = sorted(touched_files)
+        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",
             name=self.name,
             message_id=message_id or str(uuid.uuid4()),
             conversation_id=self.conversation_id,
+            parent_id=user_msg.message_id,
             model_name=self.model_name,
             messages=model_messages,
             metadata=metadata,
             finish_reason=finish_reason,
+            usage=usage,
+            cost_info=cost_info,
         )
         complete_event = StreamCompleteEvent(message=message)
-        for handler in self.event_handler._wrapped_handlers:
-            await handler(None, complete_event)
+        await handler(None, complete_event)
         yield complete_event  # Emit final StreamCompleteEvent with aggregated message
         self.message_sent.emit(message)
         conversation.add_chat_messages([user_msg, message])  # Record to conversation history
@@ -754,8 +773,9 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         if self._process:  # Clean up existing process if any
             await self._cleanup()
         self.config = new_config  # Update config and restart
-        await self._start_process()
-        await self._initialize()
+        process = await self._start_process()
+        async with monitor_process(process, context="ACP initialization"):
+            await self._initialize()
 
     async def set_tool_confirmation_mode(self, mode: ToolConfirmationMode) -> None:
         """Set the tool confirmation mode for this agent.
@@ -790,10 +810,6 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         else:
             self.log.info("Tool confirmation mode changed (local only)", mode=mode)
 
-    async def get_stats(self) -> MessageStats:
-        """Get message statistics."""
-        return MessageStats(messages=list(self.conversation.chat_messages))
-
     async def interrupt(self) -> None:
         """Interrupt the currently running stream.
 
@@ -822,12 +838,111 @@ class ACPAgent[TDeps = None](BaseAgent[TDeps, str]):
         if self._current_stream_task and not self._current_stream_task.done():
             self._current_stream_task.cancel()
 
+    async def get_available_models(self) -> list[ModelInfo] | None:
+        """Get available models from the ACP session state.
+
+        Converts ACP ModelInfo to tokonomics ModelInfo format.
+
+        Returns:
+            List of tokonomics ModelInfo, or None if not available
+        """
+        from tokonomics.model_discovery.model_info import ModelInfo
+
+        if not self._state or not self._state.models:
+            return None
+
+        # Convert ACP ModelInfo to tokonomics ModelInfo
+        result: list[ModelInfo] = []
+        for acp_model in self._state.models.available_models:
+            toko_model = ModelInfo(
+                id=acp_model.model_id,
+                name=acp_model.name,
+                description=acp_model.description,
+            )
+            result.append(toko_model)
+        return result
+
+    def get_modes(self) -> list[ModeCategory]:
+        """Get available modes from the ACP session state.
+
+        Passthrough from remote ACP server's mode state.
+
+        Returns:
+            List of ModeCategory from remote server, empty if not available
+        """
+        from agentpool.agents.modes import ModeCategory, ModeInfo
+
+        if not self._state or not self._state.modes:
+            return []
+
+        # Convert ACP SessionModeState to our ModeCategory
+        acp_modes = self._state.modes
+        category_id = "remote"
+        modes = [
+            ModeInfo(
+                id=m.id,
+                name=m.name,
+                description=m.description or "",
+                category_id=category_id,
+            )
+            for m in acp_modes.available_modes
+        ]
+
+        return [
+            ModeCategory(
+                id=category_id,
+                name="Mode",
+                available_modes=modes,
+                current_mode_id=acp_modes.current_mode_id,
+            )
+        ]
+
+    async def set_mode(self, mode: ModeInfo | str, category_id: str | None = None) -> None:
+        """Set a mode on the remote ACP server.
+
+        For ACPAgent, this forwards the mode change to the remote ACP server.
+
+        Args:
+            mode: The mode to set - ModeInfo object or mode ID string
+            category_id: Optional category ID (ignored for ACP, only one category)
+
+        Raises:
+            RuntimeError: If not connected to ACP server
+            ValueError: If mode is not available
+        """
+        from acp.schema import SetSessionModeRequest
+
+        # Extract mode_id from ModeInfo if provided
+        mode_id = mode.id if isinstance(mode, ModeInfo) else mode
+
+        if not self._connection or not self._session_id:
+            msg = "Not connected to ACP server"
+            raise RuntimeError(msg)
+
+        # Validate mode is available
+        available_modes = self.get_modes()
+        if available_modes:
+            valid_ids = {m.id for cat in available_modes for m in cat.available_modes}
+            if mode_id not in valid_ids:
+                msg = f"Unknown mode: {mode_id}. Available: {valid_ids}"
+                raise ValueError(msg)
+
+        # Forward mode change to remote ACP server
+        request = SetSessionModeRequest(session_id=self._session_id, mode_id=mode_id)
+        await self._connection.set_session_mode(request)
+
+        # Update local state
+        if self._state and self._state.modes:
+            self._state.modes.current_mode_id = mode_id
+
+        self.log.info("Mode changed on remote ACP server", mode_id=mode_id)
+
 
 if __name__ == "__main__":
 
     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/acp_converters.py

@@ -189,42 +189,56 @@ def acp_to_native_event(update: SessionUpdate) -> RichAgentStreamEvent[Any] | No
         # Text message chunks -> PartDeltaEvent with TextPartDelta
         case AgentMessageChunk(content=TextContentBlock(text=text)):
             return PartDeltaEvent(index=0, delta=TextPartDelta(content_delta=text))
+
         # Thought chunks -> PartDeltaEvent with ThinkingPartDelta
         case AgentThoughtChunk(content=TextContentBlock(text=text)):
             return PartDeltaEvent(index=0, delta=ThinkingPartDelta(content_delta=text))
-        # User message echo - could emit as PartStartEvent if needed
+
+        # User message echo - usually ignored
         case UserMessageChunk():
-            return None  # Usually ignored
+            return None
+
         # Tool call start -> ToolCallStartEvent
-        case ToolCallStart() as tc:
+        case ToolCallStart(
+            tool_call_id=tool_call_id,
+            title=title,
+            kind=kind,
+            content=content,
+            locations=locations,
+            raw_input=raw_input,
+        ):
             return ToolCallStartEvent(
-                tool_call_id=tc.tool_call_id,
-                tool_name=tc.title,  # ACP uses title, not separate tool_name
-                title=tc.title,
-                kind=tc.kind or "other",
-                content=convert_acp_content(list(tc.content) if tc.content else None),
-                locations=convert_acp_locations(list(tc.locations) if tc.locations else None),
-                raw_input=tc.raw_input or {},
+                tool_call_id=tool_call_id,
+                tool_name=title,  # ACP uses title, not separate tool_name
+                title=title,
+                kind=kind or "other",
+                content=convert_acp_content(list(content) if content else None),
+                locations=convert_acp_locations(list(locations) if locations else None),
+                raw_input=raw_input or {},
             )
 
         # Tool call progress -> ToolCallProgressEvent
-        case ToolCallProgress() as tc:
-            items = convert_acp_content(list(tc.content) if tc.content else None)
+        case ToolCallProgress(
+            tool_call_id=tool_call_id,
+            status=status,
+            title=title,
+            content=content,
+            raw_output=raw_output,
+        ):
             return ToolCallProgressEvent(
-                tool_call_id=tc.tool_call_id,
-                status=tc.status or "in_progress",
-                title=tc.title,
-                items=items,
-                message=str(tc.raw_output) if tc.raw_output else None,
+                tool_call_id=tool_call_id,
+                status=status or "in_progress",
+                title=title,
+                items=convert_acp_content(list(content) if content else None),
+                message=str(raw_output) if raw_output else None,
             )
 
         # Plan update -> PlanUpdateEvent
-        case AgentPlanUpdate(entries=acp_entries):
+        case AgentPlanUpdate(entries=entries):
             from agentpool.resource_providers.plan_provider import PlanEntry
 
             native_entries = [
-                PlanEntry(content=e.content, priority=e.priority, status=e.status)
-                for e in acp_entries
+                PlanEntry(content=e.content, priority=e.priority, status=e.status) for e in entries
             ]
             return PlanUpdateEvent(entries=native_entries)
 
@@ -251,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
 
@@ -265,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