geny-executor 2.2.0__tar.gz → 2.2.1__tar.gz

{geny_executor-2.2.0 → geny_executor-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.2.0
+Version: 2.2.1
 Summary: Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.2.0 → geny_executor-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.2.0"
+version = "2.2.1"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "MIT"

{geny_executor-2.2.0 → geny_executor-2.2.1}/src/geny_executor/__init__.py

@@ -116,7 +116,7 @@ from geny_executor.stages.s12_agent.subagent_type import (
     resolve_subagent_provider,
 )
 
-__version__ = "2.2.0"
+__version__ = "2.2.1"
 
 __all__ = [
     # Core

{geny_executor-2.2.0 → geny_executor-2.2.1}/src/geny_executor/core/pipeline.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import logging
 import uuid
 from collections import deque
@@ -223,6 +224,144 @@ def _mcp_configs_from_manifest(manifest: "EnvironmentManifest") -> Dict[str, Any
     return configs
 
 
+def _provider_wants_mcp_passthrough(provider_name: str) -> bool:
+    """True when *provider_name*'s client class executes tools inside its
+    own subprocess AND can receive MCP servers via its own config channel.
+
+    The 2.2.1 incident this gates on: a manifest declared
+    ``tools.mcp_servers`` on a ``claude_code_cli`` environment. The
+    pipeline dutifully connected the server HOST-side (spawning the MCP
+    child inside the host process) and registered its tools into the
+    pipeline ToolRegistry — but Stage 10 never dispatches for subprocess
+    backends (the CLI runs its own agentic loop), and the CLI subprocess
+    only sees servers passed through ``--mcp-config``. Net effect: the
+    user attached an MCP server in the environment editor, the session
+    built cleanly, and the LLM had no idea the tools existed.
+
+    For such providers the manifest's MCP servers must be PASSED THROUGH
+    to the client instead of host-connected. Detection is class-level
+    (no client construction, no credentials needed): ``is_subprocess``
+    AND ``supports_mcp_passthrough`` on the registered capabilities.
+    Unknown/unregistered providers return False — the host-side path is
+    the safe default.
+    """
+    if not provider_name or provider_name not in ClientRegistry.available():
+        return False
+    try:
+        caps = ClientRegistry.get(provider_name).capabilities
+    except Exception:  # noqa: BLE001 — registry factories may raise on missing extras
+        return False
+    return bool(
+        getattr(caps, "is_subprocess", False) and getattr(caps, "supports_mcp_passthrough", False)
+    )
+
+
+def _mcp_servers_to_cli_config(
+    configs: Dict[str, Any],
+) -> tuple[Dict[str, Any], List[str]]:
+    """Translate manifest ``MCPServerConfig`` entries into the Claude Code
+    CLI's ``--mcp-config`` JSON shape.
+
+    Returns ``(cli_config, skipped_names)`` where ``cli_config`` is
+    ``{"mcpServers": {name: entry}}`` and ``skipped_names`` lists servers
+    whose transport could not be expressed (logged by the caller).
+
+    Shape mapping (per the CLI's documented mcp-config schema):
+      stdio      → {"type": "stdio", "command", "args", "env"}
+      sse        → {"type": "sse", "url", "headers"}
+      http       → {"type": "http", "url", "headers"}
+    """
+    servers: Dict[str, Any] = {}
+    skipped: List[str] = []
+    for name, cfg in configs.items():
+        transport = (getattr(cfg, "transport", "") or "stdio").lower()
+        if transport == "stdio":
+            entry: Dict[str, Any] = {
+                "type": "stdio",
+                "command": cfg.command,
+                "args": list(cfg.args or []),
+            }
+            if cfg.env:
+                entry["env"] = dict(cfg.env)
+        elif transport in ("sse", "http"):
+            entry = {"type": transport, "url": cfg.url}
+            if cfg.headers:
+                entry["headers"] = dict(cfg.headers)
+        else:
+            skipped.append(name)
+            continue
+        servers[name] = entry
+    return {"mcpServers": servers}, skipped
+
+
+def _merge_cli_mcp_config(
+    host_config: Any,
+    manifest_config: Dict[str, Any],
+) -> Any:
+    """Merge manifest-declared MCP servers into a host-supplied CLI
+    mcp-config.
+
+    Precedence: the HOST config wins on server-name collision — a host
+    that wires a session-scoped bridge (Geny's ``geny`` server) or
+    deliberately overrides a server keeps control. ``host_config`` may
+    be:
+
+    - ``None`` / empty → the manifest config is used as-is.
+    - a dict ``{"mcpServers": {...}}`` → key-merged.
+    - a file path (str) → the file is read and key-merged; on any read/
+      parse failure the host path is returned unchanged and the manifest
+      servers are dropped with a warning (the CLI accepts exactly one
+      ``--mcp-config``, so an unreadable host file cannot be merged
+      without guessing).
+    """
+    manifest_servers = dict(manifest_config.get("mcpServers", {}))
+    if not manifest_servers:
+        return host_config
+    if not host_config:
+        return {"mcpServers": manifest_servers}
+
+    if isinstance(host_config, str):
+        try:
+            with open(host_config, "r", encoding="utf-8") as fh:
+                loaded = json.load(fh)
+            if not isinstance(loaded, dict):
+                raise ValueError("mcp-config file is not a JSON object")
+            host_config = loaded
+        except Exception:  # noqa: BLE001
+            logger.warning(
+                "CLI MCP passthrough: host mcp_config path %r could not be "
+                "read/parsed — manifest-declared MCP servers %s will NOT "
+                "reach the CLI subprocess (the CLI accepts a single "
+                "--mcp-config).",
+                host_config,
+                sorted(manifest_servers),
+            )
+            return host_config
+
+    if not isinstance(host_config, dict):
+        logger.warning(
+            "CLI MCP passthrough: host mcp_config has unsupported type %s — "
+            "manifest MCP servers %s dropped.",
+            type(host_config).__name__,
+            sorted(manifest_servers),
+        )
+        return host_config
+
+    merged = dict(host_config)
+    host_servers = dict(merged.get("mcpServers", {}))
+    for name, entry in manifest_servers.items():
+        if name in host_servers:
+            logger.info(
+                "CLI MCP passthrough: server %r declared in both the host "
+                "mcp_config and the manifest — host definition wins.",
+                name,
+            )
+            continue
+        host_servers[name] = entry
+    merged["mcpServers"] = host_servers
+    return merged
+
+
 @dataclass
 class ToolResolutionReport:
     """What happened to every tool name the manifest asked for.
@@ -559,6 +698,12 @@ class Pipeline:
         self._event_taps: List[asyncio.Queue] = []
         self._mcp_manager: Any = None  # MCPManager | None — set by from_manifest_async
         self._tool_registry: Any = None  # ToolRegistry | None — set by from_manifest_async
+        # CLI MCP passthrough (2.2.1): manifest mcp_servers translated to
+        # the CLI's mcp-config shape, merged into the client's mcp_config
+        # at _build_client_for time. Empty for SDK providers (host-side
+        # MCPManager path) and for manifests without MCP servers.
+        self._cli_mcp_passthrough: Dict[str, Any] = {}
+        self._cli_mcp_passthrough_provider: str = ""
         # MemoryProvider built from the manifest's ``memory`` block
         # (2.2.0 Wave 3); None for hosts that wire memory themselves.
         self._memory_provider: Any = None
@@ -1202,19 +1347,59 @@ class Pipeline:
 
         configs = _mcp_configs_from_manifest(manifest)
         if configs:
-            try:
-                await manager.connect_all(configs)
-                adapters = await manager.discover_all()
-                for adapter in adapters:
-                    registry.register(adapter)
-            except BaseException:
-                # Unwind providers if MCP bring-up fails mid-flight so no
-                # half-started resources leak out.
-                from geny_executor.tools.provider import shutdown_providers
-
-                await shutdown_providers(started_providers)
-                await manager.disconnect_all()
-                raise
+            # ── CLI MCP passthrough (2.2.1) ───────────────────────────
+            # Subprocess backends (claude_code_cli) run their own agentic
+            # loop: Stage 10 never dispatches for them, so HOST-side MCP
+            # connections are invisible to the actual LLM — the only MCP
+            # channel that reaches it is the client's own --mcp-config.
+            # Connecting host-side here therefore spawned the MCP child
+            # for nothing while the user-attached server's tools never
+            # surfaced in the conversation (the 2.2.1 incident). When the
+            # manifest's Stage-6 provider is such a backend, hand the
+            # servers to the client instead of the manager; the merge
+            # into the client's mcp_config happens in _build_client_for
+            # (host-supplied config wins on name collisions, e.g. Geny's
+            # per-session bridge server).
+            primary_provider = ""
+            for entry in manifest.stage_entries():
+                if entry.name == "api" and entry.active:
+                    primary_provider = str((entry.config or {}).get("provider") or "")
+                    break
+            if _provider_wants_mcp_passthrough(primary_provider):
+                cli_config, skipped = _mcp_servers_to_cli_config(configs)
+                if skipped:
+                    logger.warning(
+                        "CLI MCP passthrough: server(s) %s have transports the "
+                        "CLI mcp-config cannot express — they will not reach "
+                        "the %s subprocess.",
+                        sorted(skipped),
+                        primary_provider,
+                    )
+                if cli_config.get("mcpServers"):
+                    pipeline._cli_mcp_passthrough = cli_config
+                    pipeline._cli_mcp_passthrough_provider = primary_provider
+                    logger.info(
+                        "CLI MCP passthrough: %d manifest MCP server(s) %s "
+                        "routed to the %s subprocess via --mcp-config "
+                        "(host-side connection skipped).",
+                        len(cli_config["mcpServers"]),
+                        sorted(cli_config["mcpServers"]),
+                        primary_provider,
+                    )
+            else:
+                try:
+                    await manager.connect_all(configs)
+                    adapters = await manager.discover_all()
+                    for adapter in adapters:
+                        registry.register(adapter)
+                except BaseException:
+                    # Unwind providers if MCP bring-up fails mid-flight so no
+                    # half-started resources leak out.
+                    from geny_executor.tools.provider import shutdown_providers
+
+                    await shutdown_providers(started_providers)
+                    await manager.disconnect_all()
+                    raise
 
         pipeline._mcp_manager = manager
         pipeline._tool_registry = registry
@@ -2592,6 +2777,26 @@ class Pipeline:
         creds = self._credentials.require(provider)
         client_cls = ClientRegistry.get(provider)
         kwargs = _creds_to_client_kwargs(provider, creds)
+        # CLI MCP passthrough (2.2.1): hand manifest-declared MCP servers
+        # to the subprocess client. Host-supplied mcp_config (e.g. Geny's
+        # per-session bridge) wins on name collision. Manifest-declared
+        # servers are also auto-allowed (``mcp__<server>``) — the
+        # operator attached them in the environment editor, and the CLI's
+        # --print mode has no human to answer a permission prompt, so
+        # without the allow entry the passthrough would be dead on
+        # arrival.
+        if provider == self._cli_mcp_passthrough_provider and self._cli_mcp_passthrough.get(
+            "mcpServers"
+        ):
+            kwargs["mcp_config"] = _merge_cli_mcp_config(
+                kwargs.get("mcp_config"), self._cli_mcp_passthrough
+            )
+            allow = list(kwargs.get("allow_tools", ()) or ())
+            for server_name in self._cli_mcp_passthrough["mcpServers"]:
+                entry = f"mcp__{server_name}"
+                if entry not in allow:
+                    allow.append(entry)
+            kwargs["allow_tools"] = tuple(allow)
         return client_cls(**kwargs)
 
     async def _try_run_stage(self, order: int, current: Any, state: PipelineState) -> Any:

geny_executor-2.2.1/tests/unit/test_cli_mcp_passthrough.py

@@ -0,0 +1,302 @@
+"""CLI MCP passthrough (2.2.1) — manifest ``tools.mcp_servers`` must reach
+subprocess backends through their own ``--mcp-config`` channel.
+
+The incident this pins: a user attached an MCP server (``gapt-service``,
+stdio, ``npx gapt-mcp``) to a ``claude_code_cli`` environment through the
+host UI. The manifest carried it correctly, the pipeline built cleanly —
+and the agent had no idea the tools existed. Root cause: the pipeline
+connected the server HOST-side (MCPManager) and registered its tools into
+the pipeline ToolRegistry, but Stage 10 never dispatches for subprocess
+backends (the CLI runs its own agentic loop) and the CLI subprocess only
+sees servers passed via ``--mcp-config`` (which carried only the host's
+session bridge). The host even spawned the MCP child process for nothing.
+
+The fix routes manifest MCP servers to the client instead:
+``from_manifest_async`` skips the host-side connect for passthrough-capable
+providers and ``_build_client_for`` merges the servers into the client's
+``mcp_config`` (host config wins on name collision) plus auto-allows
+``mcp__<server>`` so ``--print`` mode (no human to answer permission
+prompts) can actually call them.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from geny_executor import CredentialBundle, ProviderCredentials
+from geny_executor.core.environment import EnvironmentManifest
+from geny_executor.core.pipeline import (
+    Pipeline,
+    _mcp_servers_to_cli_config,
+    _merge_cli_mcp_config,
+    _provider_wants_mcp_passthrough,
+)
+from geny_executor.llm_client.types import APIRequest
+from geny_executor.llm_client.translators._cli import claude_code_argv
+from geny_executor.tools.mcp.manager import MCPServerConfig
+
+
+# ─────────────────────────────────── provider detection ─
+
+
+def test_claude_code_cli_wants_passthrough() -> None:
+    assert _provider_wants_mcp_passthrough("claude_code_cli") is True
+
+
+@pytest.mark.parametrize("provider", ["anthropic", "openai", "google", "vllm"])
+def test_sdk_providers_do_not_want_passthrough(provider: str) -> None:
+    assert _provider_wants_mcp_passthrough(provider) is False
+
+
+def test_unknown_or_empty_provider_is_safe_default() -> None:
+    assert _provider_wants_mcp_passthrough("") is False
+    assert _provider_wants_mcp_passthrough("no-such-provider") is False
+
+
+# ─────────────────────────────────── shape translation ─
+
+
+def test_stdio_server_translates_with_env() -> None:
+    cfg, skipped = _mcp_servers_to_cli_config(
+        {
+            "gapt-service": MCPServerConfig(
+                name="gapt-service",
+                command="npx",
+                args=["gapt-mcp"],
+                env={"GAPT_BASE_URL": "https://gapt.example/"},
+                transport="stdio",
+            )
+        }
+    )
+    assert skipped == []
+    entry = cfg["mcpServers"]["gapt-service"]
+    assert entry == {
+        "type": "stdio",
+        "command": "npx",
+        "args": ["gapt-mcp"],
+        "env": {"GAPT_BASE_URL": "https://gapt.example/"},
+    }
+
+
+def test_sse_and_http_servers_translate_with_headers() -> None:
+    cfg, skipped = _mcp_servers_to_cli_config(
+        {
+            "a": MCPServerConfig(
+                name="a", transport="sse", url="https://x/sse",
+                headers={"Authorization": "Bearer t"},
+            ),
+            "b": MCPServerConfig(name="b", transport="http", url="https://x/mcp"),
+        }
+    )
+    assert skipped == []
+    assert cfg["mcpServers"]["a"] == {
+        "type": "sse", "url": "https://x/sse",
+        "headers": {"Authorization": "Bearer t"},
+    }
+    assert cfg["mcpServers"]["b"] == {"type": "http", "url": "https://x/mcp"}
+
+
+def test_unknown_transport_is_skipped_and_reported() -> None:
+    cfg, skipped = _mcp_servers_to_cli_config(
+        {"weird": MCPServerConfig(name="weird", transport="carrier-pigeon")}
+    )
+    assert skipped == ["weird"]
+    assert cfg["mcpServers"] == {}
+
+
+# ─────────────────────────────────── merge semantics ─
+
+
+_MANIFEST_CFG = {"mcpServers": {"gapt-service": {"type": "stdio", "command": "npx"}}}
+
+
+def test_merge_into_empty_host_config() -> None:
+    assert _merge_cli_mcp_config(None, _MANIFEST_CFG) == _MANIFEST_CFG
+    assert _merge_cli_mcp_config({}, _MANIFEST_CFG) == _MANIFEST_CFG
+
+
+def test_merge_host_dict_keeps_both_and_host_wins_collisions() -> None:
+    host = {
+        "mcpServers": {
+            "geny": {"type": "stdio", "command": "python"},
+            "gapt-service": {"type": "stdio", "command": "host-pinned"},
+        }
+    }
+    merged = _merge_cli_mcp_config(host, _MANIFEST_CFG)
+    assert set(merged["mcpServers"]) == {"geny", "gapt-service"}
+    # Host definition survives the collision — session bridges and host
+    # overrides must not be silently replaced by manifest entries.
+    assert merged["mcpServers"]["gapt-service"]["command"] == "host-pinned"
+
+
+def test_merge_host_path_readable(tmp_path) -> None:
+    p = tmp_path / "host-mcp.json"
+    p.write_text(json.dumps({"mcpServers": {"geny": {"type": "stdio", "command": "python"}}}))
+    merged = _merge_cli_mcp_config(str(p), _MANIFEST_CFG)
+    assert set(merged["mcpServers"]) == {"geny", "gapt-service"}
+
+
+def test_merge_host_path_unreadable_keeps_host_path(tmp_path, caplog) -> None:
+    bogus = str(tmp_path / "missing.json")
+    with caplog.at_level("WARNING"):
+        out = _merge_cli_mcp_config(bogus, _MANIFEST_CFG)
+    assert out == bogus  # the single --mcp-config slot stays with the host
+    assert any("could not be read" in r.message for r in caplog.records)
+
+
+# ─────────────────────────────────── end-to-end pipeline ─
+
+
+def _cli_manifest_with_mcp() -> EnvironmentManifest:
+    return EnvironmentManifest.from_dict(
+        {
+            "metadata": {"id": "t-cli-mcp", "name": "t"},
+            "pipeline": {"max_iterations": 1},
+            "model": {},
+            "stages": [
+                {"order": 1, "name": "input", "active": True},
+                {
+                    "order": 6,
+                    "name": "api",
+                    "active": True,
+                    "config": {"provider": "claude_code_cli"},
+                    "strategies": {"retry": "no_retry", "router": "passthrough"},
+                },
+                {"order": 9, "name": "parse", "active": True},
+                {"order": 21, "name": "yield", "active": True},
+            ],
+            "tools": {
+                "built_in": [],
+                "external": [],
+                "mcp_servers": [
+                    {
+                        # A command that CANNOT spawn — if the pipeline
+                        # tried the host-side connect, build would raise.
+                        "name": "gapt-service",
+                        "transport": "stdio",
+                        "command": "/nonexistent-mcp-binary",
+                        "args": ["gapt-mcp"],
+                        "env": {"GAPT_BASE_URL": "https://gapt.example/"},
+                    }
+                ],
+            },
+        }
+    )
+
+
+def _cli_bundle(extras: dict | None = None) -> CredentialBundle:
+    # binary_path points at a real executable so the credentials are
+    # non-empty (require() gate) — the client never spawns it in these
+    # tests.
+    return CredentialBundle(
+        by_provider={
+            "claude_code_cli": ProviderCredentials(
+                api_key="", binary_path="/bin/sh", extras=dict(extras or {})
+            )
+        }
+    )
+
+
+@pytest.mark.asyncio
+async def test_cli_provider_skips_host_connect_and_stashes_passthrough() -> None:
+    pipeline = await Pipeline.from_manifest_async(
+        _cli_manifest_with_mcp(), credentials=_cli_bundle(), strict=False
+    )
+    try:
+        # Host-side connect was skipped: a /nonexistent binary would have
+        # raised MCPConnectionError during build.
+        assert pipeline._cli_mcp_passthrough["mcpServers"]["gapt-service"]["command"] == (
+            "/nonexistent-mcp-binary"
+        )
+        assert pipeline._cli_mcp_passthrough_provider == "claude_code_cli"
+
+        client = pipeline._build_client_for("claude_code_cli")
+        assert "gapt-service" in client._mcp_config["mcpServers"]
+        assert "mcp__gapt-service" in client._allow_tools
+    finally:
+        await pipeline.aclose()
+
+
+@pytest.mark.asyncio
+async def test_cli_passthrough_merges_with_host_bridge_config() -> None:
+    """Geny's per-session bridge (extras['mcp_config']) and the manifest
+    server must BOTH reach the CLI in one --mcp-config."""
+    bridge = {"mcpServers": {"geny": {"type": "stdio", "command": "python", "args": ["bridge.py"]}}}
+    pipeline = await Pipeline.from_manifest_async(
+        _cli_manifest_with_mcp(),
+        credentials=_cli_bundle(extras={"mcp_config": bridge, "allow_tools": ("mcp__geny",)}),
+        strict=False,
+    )
+    try:
+        client = pipeline._build_client_for("claude_code_cli")
+        servers = client._mcp_config["mcpServers"]
+        assert set(servers) == {"geny", "gapt-service"}
+        assert "mcp__geny" in client._allow_tools
+        assert "mcp__gapt-service" in client._allow_tools
+
+        # And the argv the subprocess actually receives carries both.
+        argv = claude_code_argv(
+            APIRequest(model="m", messages=[], system="", stream=False),
+            mcp_config=client._mcp_config,
+            allow_tools=client._allow_tools,
+        )
+        blob = argv[argv.index("--mcp-config") + 1]
+        assert set(json.loads(blob)["mcpServers"]) == {"geny", "gapt-service"}
+        assert "--strict-mcp-config" in argv
+        allowed = argv[argv.index("--allowedTools") + 1]
+        assert "mcp__gapt-service" in allowed
+    finally:
+        await pipeline.aclose()
+
+
+@pytest.mark.asyncio
+async def test_sdk_provider_still_host_connects(monkeypatch) -> None:
+    """Regression: SDK providers keep the host-side MCPManager path."""
+    from geny_executor.tools.mcp import manager as mcp_manager_mod
+
+    calls = {}
+
+    async def fake_connect_all(self, configs):
+        calls["configs"] = dict(configs)
+
+    async def fake_discover_all(self):
+        return []
+
+    monkeypatch.setattr(mcp_manager_mod.MCPManager, "connect_all", fake_connect_all)
+    monkeypatch.setattr(mcp_manager_mod.MCPManager, "discover_all", fake_discover_all)
+
+    manifest_dict = _cli_manifest_with_mcp().to_dict()
+    manifest_dict["stages"][1]["config"]["provider"] = "anthropic"
+    manifest = EnvironmentManifest.from_dict(manifest_dict)
+
+    pipeline = await Pipeline.from_manifest_async(
+        manifest,
+        credentials=CredentialBundle(
+            by_provider={"anthropic": ProviderCredentials(api_key="sk-test")}
+        ),
+        strict=False,
+    )
+    try:
+        assert "gapt-service" in calls["configs"]
+        assert pipeline._cli_mcp_passthrough == {}
+    finally:
+        await pipeline.aclose()
+
+
+@pytest.mark.asyncio
+async def test_cli_manifest_without_mcp_servers_untouched() -> None:
+    manifest_dict = _cli_manifest_with_mcp().to_dict()
+    manifest_dict["tools"]["mcp_servers"] = []
+    pipeline = await Pipeline.from_manifest_async(
+        EnvironmentManifest.from_dict(manifest_dict),
+        credentials=_cli_bundle(),
+        strict=False,
+    )
+    try:
+        assert pipeline._cli_mcp_passthrough == {}
+        client = pipeline._build_client_for("claude_code_cli")
+        assert client._mcp_config is None
+    finally:
+        await pipeline.aclose()