Revert dependency upgrade and MCP API migration (#95) (#100)

Fully revert #95, restoring the pre-#95 pyproject.toml, source
(agent/core.py, tools/utils.py, terminal/screens.py), tests, and the
pre-#95 uv.lock. This pins dependencies back to their pre-#95 versions
(pydantic-ai 1.99.0, textual 8.0.0, pytest-asyncio 1.3.0, google-genai
2.4.0, rich 14.3.2, etc.), where the original
MCPServerStdio/MCPServerStreamableHTTP API, the file picker, and the
synchronous approval test all work without the adaptations #95
introduced.

#97's local-HTTP-server fetch tests (added after #95) are preserved.

This reverts commit 1244357.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: krasserm

freeact/agent/core.py

@@ -2,18 +2,18 @@
 import contextlib
 import logging
 import uuid
-from collections.abc import Sequence
+from collections.abc import Sequence, Set
 from dataclasses import replace
 from pathlib import Path
-from typing import AsyncIterator
+from typing import Any, AsyncIterator
 
 import ipybox
 from aiostream.stream import merge
-from fastmcp.client.transports import StdioTransport, StreamableHttpTransport
 from ipybox.utils import arun
+from mcp import types as mcp_types
 from pydantic_ai import BinaryContent
 from pydantic_ai.direct import model_request_stream
-from pydantic_ai.mcp import ToolResult
+from pydantic_ai.mcp import MCPServer, MCPServerStdio, MCPServerStreamableHTTP, ToolResult
 from pydantic_ai.messages import (
     ModelMessage,
     ModelRequest,
@@ -51,7 +51,6 @@
 from freeact.agent.shell import split_composite_command
 from freeact.agent.store import SessionStore, ToolResultMaterializer
 from freeact.tools.utils import (
-    _McpServer,
     get_tool_definitions,
     load_ipybox_tool_definitions,
     load_subagent_task_tool_definitions,
@@ -60,6 +59,18 @@
 logger = logging.getLogger("freeact")
 
 
+class _MCPServerStdioFiltered(MCPServerStdio):
+    """MCPServerStdio that filters out specified tools."""
+
+    def __init__(self, excluded_tools: Set[str], **kwargs: Any):
+        super().__init__(**kwargs)
+        self._excluded_tools = excluded_tools
+
+    async def list_tools(self) -> list[mcp_types.Tool]:
+        tools = await super().list_tools()
+        return [t for t in tools if t.name not in self._excluded_tools]
+
+
 class Agent:
     """Code action agent that executes Python code and shell commands.
 
@@ -136,9 +147,9 @@ def __init__(
             )
 
         self._mcp_servers = config.resolved_mcp_servers
-        self._mcp_server_instances: dict[str, _McpServer] = {}
+        self._mcp_server_instances: dict[str, MCPServer] = {}
 
-        self._tool_mapping: dict[str, _McpServer] = {}
+        self._tool_mapping: dict[str, MCPServer] = {}
         self._tool_definitions: list[ToolDefinition] = []
 
         self._kernel_env = config.resolved_kernel_env
@@ -217,6 +228,7 @@ async def start(self) -> None:
         resource_supervisors = [_ResourceSupervisor(self._code_executor, "code-executor")]
         for name, server in self._mcp_server_instances.items():
             logger.debug(f"Starting MCP server: {name}")
+            server.tool_prefix = name
             resource_supervisors.append(_ResourceSupervisor(server, f"mcp-server-{name}"))
 
         try:
@@ -269,27 +281,28 @@ async def stop(self) -> None:
             raise ExceptionGroup("Multiple errors while stopping agent resources", errors)
         self._mcp_server_instances = {}
 
-    def _create_mcp_servers(self) -> dict[str, _McpServer]:
+    def _create_mcp_servers(self) -> dict[str, MCPServer]:
         if not self._mcp_servers:
             return {}
 
-        servers: dict[str, _McpServer] = {}
+        servers: dict[str, MCPServer] = {}
 
         for name, raw_cfg in self._mcp_servers.items():
             cfg = dict(raw_cfg)
-            excluded_tools = frozenset(cfg.pop("excluded_tools", None) or ())
+            excluded_tools = cfg.pop("excluded_tools", None)
             match cfg:
-                case {"command": command}:
-                    transport: StdioTransport | StreamableHttpTransport = StdioTransport(
-                        command=command,
-                        args=cfg.get("args", []),
-                        env=cfg.get("env"),
-                    )
-                case {"url": url}:
-                    transport = StreamableHttpTransport(url=url, headers=cfg.get("headers"))
+                case {"command": _}:
+                    if excluded_tools:
+                        servers[name] = _MCPServerStdioFiltered(
+                            excluded_tools=frozenset(excluded_tools),
+                            **cfg,
+                        )
+                    else:
+                        servers[name] = MCPServerStdio(**cfg)
+                case {"url": _}:
+                    servers[name] = MCPServerStreamableHTTP(**cfg)
                 case _:
                     raise ValueError(f"Invalid server config for {name}: must have 'command' or 'url'")
-            servers[name] = _McpServer(transport, tool_prefix=name, excluded_tools=excluded_tools)
 
         return servers
 

freeact/terminal/screens.py

@@ -88,20 +88,6 @@ def action_collapse_cursor_node(self) -> None:
         if self._safe_is_dir(dir_entry.path):
             cursor_node.collapse()
 
-    async def watch_path(self) -> None:
-        """Suppress the reactive reload that races with cursor positioning.
-
-        `DirectoryTree.watch_path` fires when the root path is set during
-        construction and reloads the tree, rebuilding the root's children and
-        resetting the cursor to the root. That runs concurrently with
-        `FilePickerScreen._focus_tree_path`, which loads and expands the path
-        down to the working directory and positions the cursor there; the
-        reactive reload orphans the navigated nodes, leaving the cursor stuck
-        at the root. The picker keeps a fixed root, so loading and cursor
-        positioning are driven entirely by the screen's `on_mount`.
-        """
-        return None
-
 
 class FilePickerScreen(ModalScreen[Path | None]):
     """Modal file picker opened from `@path` prompt completion."""
@@ -253,10 +239,6 @@ async def _focus_tree_path(self, tree: FilePickerTree, target_path: Path) -> Non
             current_path = next_path
             if child.allow_expand:
                 await tree.reload_node(child)
-        # Build the tree's line layout so the target node's line index is
-        # assigned; otherwise `node._line` is still -1 and `move_cursor` falls
-        # back to the root (line 0).
-        _ = tree._tree_lines
         tree.move_cursor(node, animate=False)
 
 

freeact/tools/utils.py

@@ -1,64 +1,18 @@
 import asyncio
 import json
-from collections.abc import Set
 from dataclasses import asdict
 from pathlib import Path
-from typing import Any
 
-from fastmcp.client.transports import ClientTransport, StdioTransport
 from ipybox.utils import arun
-from pydantic_ai import RunContext
-from pydantic_ai.mcp import MCPToolset
+from pydantic_ai.mcp import MCPServer, MCPServerStdio
 from pydantic_ai.tools import ToolDefinition
-from pydantic_ai.toolsets import FilteredToolset, PrefixedToolset
-from pydantic_ai.toolsets.abstract import AbstractToolset, ToolsetTool
 
 IPYBOX_TOOL_PREFIX = "ipybox"
 IPYBOX_TOOL_DEFS_PATH = Path(__file__).parent / "ipybox.json"
 SUBAGENT_TOOL_DEFS_PATH = Path(__file__).parent / "subagent.json"
 
 
-class _McpServer:
-    """MCP server adapter that namespaces and filters an `MCPToolset`.
-
-    Wraps a pydantic-ai [`MCPToolset`][pydantic_ai.mcp.MCPToolset] so that tool
-    names exposed via `get_tools` are prefixed with `tool_prefix` (avoiding
-    collisions between servers) and optionally excludes selected tools. Tool
-    calls route to the underlying toolset via `direct_call_tool` using the
-    un-prefixed tool name.
-    """
-
-    def __init__(
-        self,
-        transport: ClientTransport,
-        *,
-        tool_prefix: str,
-        excluded_tools: Set[str] = frozenset(),
-    ) -> None:
-        self.tool_prefix = tool_prefix
-        self._toolset = MCPToolset(transport)
-
-        view: AbstractToolset[Any] = self._toolset
-        if excluded_tools:
-            excluded = frozenset(excluded_tools)
-            view = FilteredToolset(view, lambda ctx, tool_def: tool_def.name not in excluded)
-        self._view: AbstractToolset[Any] = PrefixedToolset(view, tool_prefix)
-
-    async def __aenter__(self) -> "_McpServer":
-        await self._view.__aenter__()
-        return self
-
-    async def __aexit__(self, *exc_info: object) -> bool | None:
-        return await self._view.__aexit__(*exc_info)
-
-    async def get_tools(self, ctx: RunContext[Any]) -> dict[str, ToolsetTool[Any]]:
-        return await self._view.get_tools(ctx)
-
-    async def direct_call_tool(self, name: str, args: dict[str, Any]) -> Any:
-        return await self._toolset.direct_call_tool(name=name, args=args)
-
-
-async def get_tool_definitions(server: _McpServer) -> list[ToolDefinition]:
+async def get_tool_definitions(server: MCPServer) -> list[ToolDefinition]:
     """Extract tool definitions from an MCP server.
 
     Args:
@@ -67,10 +21,11 @@ async def get_tool_definitions(server: _McpServer) -> list[ToolDefinition]:
     Returns:
         List of tool definitions exposed by the server.
     """
+    from pydantic_ai import RunContext
     from pydantic_ai.models.test import TestModel
     from pydantic_ai.result import RunUsage
 
-    ctx: RunContext[Any] = RunContext(
+    ctx = RunContext(
         deps=None,
         model=TestModel(),
         usage=RunUsage(),
@@ -120,9 +75,9 @@ async def save_ipybox_tool_definitions() -> None:
     Connects to a live ipybox MCP server, extracts tool definitions
     (excluding `install_package`), and saves them to the bundled JSON file.
     """
-    transport = StdioTransport(command="uvx", args=["ipybox"])
-    server = _McpServer(transport, tool_prefix=IPYBOX_TOOL_PREFIX, excluded_tools={"install_package"})
-    async with server:
+    server = MCPServerStdio("uvx", args=["ipybox"], tool_prefix=IPYBOX_TOOL_PREFIX)
+    server = server.filtered(lambda _, t: t.name != f"{IPYBOX_TOOL_PREFIX}_install_package")
+    async with server as server:
         tool_defs = await get_tool_definitions(server)
         await arun(save_tool_definitions, tool_defs, IPYBOX_TOOL_DEFS_PATH)
 

pyproject.toml

@@ -10,17 +10,17 @@ readme = "README.md"
 license = "Apache-2.0"
 dependencies = [
     "aiostream>=0.7.1",
-    "google-genai>=2.7.0",
-    "pydantic-ai>=1.104.0",
-    "python-dotenv>=1.2.2",
-    "pillow>=12.2.0",
+    "google-genai>=2.4.0",
+    "pydantic-ai>=1.99.0",
+    "python-dotenv>=1.0.0",
+    "pillow>=12.0.0",
     "pyyaml>=6.0.3",
-    "rich>=15.0.0",
-    "textual>=8.2.7",
+    "rich>=14.2.0",
+    "textual>=8.0.0",
     "ipybox>=0.9.1",
     "mcpygen>=0.1.4",
-    "sqlite-vec>=0.1.9",
-    "watchfiles>=1.2.0",
+    "sqlite-vec>=0.1.0",
+    "watchfiles>=1.0.0",
     "trafilatura>=2.0.0",
 ]
 
@@ -35,21 +35,21 @@ default-groups = [
 
 [dependency-groups]
 docs = [
-    "griffe-pydantic>=1.3.1",
+    "griffe-pydantic>=1.1.8",
     "mkdocs>=1.6.1,<2",
-    "mkdocs-material>=9.7.6,<10",
-    "mkdocstrings-python>=2.0.3,<3",
-    "mkdocs-llmstxt>=0.5.0",
-    "click>=8.4.1",
+    "mkdocs-material>=9.5.48,<10",
+    "mkdocstrings-python>=1.12.2,<2",
+    "mkdocs-llmstxt>=0.4.0",
+    "click<=8.2.1",
 ]
 dev = [
-    "invoke>=3.0.3,<4",
-    "pre-commit>=4.6.0,<5",
-    "pytest>=9.0.3,<10",
-    "pytest-asyncio>=1.4.0,<2",
-    "pytest-cov>=7.1.0,<8",
+    "invoke>=2.2,<3",
+    "pre-commit>=4.3.0,<5",
+    "pytest>=8.4.2,<9",
+    "pytest-asyncio>=1.2.0,<2",
+    "pytest-cov>=4.1.0,<5",
     "pytest-xdist>=3.8.0",
-    "types-pyyaml>=6.0.12.20260518",
+    "types-pyyaml>=6.0.12.20250915",
 ]
 
 [build-system]