geny-executor 2.0.4__tar.gz → 2.0.6__tar.gz

{geny_executor-2.0.4 → geny_executor-2.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.0.4
+Version: 2.0.6
 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.0.4 → geny_executor-2.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.0.4"
+version = "2.0.6"
 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.0.4 → geny_executor-2.0.6}/src/geny_executor/__init__.py

@@ -95,7 +95,7 @@ from geny_executor.memory import (
     ProviderDrivenStrategy,
 )
 
-__version__ = "2.0.4"
+__version__ = "2.0.6"
 
 __all__ = [
     # Core

{geny_executor-2.0.4 → geny_executor-2.0.6}/src/geny_executor/core/pipeline.py

@@ -97,16 +97,6 @@ def _creds_to_client_kwargs(provider: str, creds: ProviderCredentials) -> Dict[s
                     kwargs[key] = extras[key]
         return kwargs
 
-    if provider == "copilot_cli":
-        extras = dict(creds.extras or {})
-        kwargs = {}
-        if creds.binary_path:
-            kwargs["gh_binary_path"] = creds.binary_path
-        for key in ("allow_tools", "cwd", "extra_args", "timeout_s"):
-            if key in extras:
-                kwargs[key] = extras[key]
-        return kwargs
-
     # API providers (anthropic / openai / google)
     kwargs = {"api_key": creds.api_key}
     if creds.base_url is not None:

{geny_executor-2.0.4 → geny_executor-2.0.6}/src/geny_executor/llm_client/__init__.py

@@ -9,7 +9,6 @@ credentials via :class:`CredentialBundle` (built from
 from geny_executor.llm_client.anthropic import AnthropicClient
 from geny_executor.llm_client.base import BaseClient, ClientCapabilities
 from geny_executor.llm_client.claude_code import ClaudeCodeCLIClient
-from geny_executor.llm_client.copilot import CopilotCLIClient
 from geny_executor.llm_client.credentials import (
     ConfigError,
     CredentialBundle,
@@ -28,7 +27,6 @@ __all__ = [
     "ClientRegistry",
     "ConfigError",
     "ContentBlock",
-    "CopilotCLIClient",
     "CredentialBundle",
     "ProviderCredentials",
 ]

{geny_executor-2.0.4 → geny_executor-2.0.6}/src/geny_executor/llm_client/_cli_runtime.py

@@ -1,8 +1,10 @@
 """Async subprocess primitives shared by CLI-backed LLM clients.
 
 This module is the *only* place where ``asyncio.create_subprocess_exec`` is
-called inside ``llm_client/``. Both ``ClaudeCodeCLIClient`` (Phase B) and
-``CopilotCLIClient`` (Phase C) drive their work through these helpers.
+called inside ``llm_client/``. ``ClaudeCodeCLIClient`` (Phase B) drives its
+work through these helpers. (The Phase-C ``CopilotCLIClient`` was removed
+in 2.0.6 — see the commit message for the structural-incompatibility
+rationale.)
 
 Design rules
 ------------

{geny_executor-2.0.4 → geny_executor-2.0.6}/src/geny_executor/llm_client/registry.py

@@ -74,15 +74,8 @@ def _claude_code_cli_factory() -> Type[BaseClient]:
     return ClaudeCodeCLIClient
 
 
-def _copilot_cli_factory() -> Type[BaseClient]:
-    from geny_executor.llm_client.copilot import CopilotCLIClient
-
-    return CopilotCLIClient
-
-
 ClientRegistry.register("anthropic", _anthropic_factory)
 ClientRegistry.register("openai", _openai_factory)
 ClientRegistry.register("google", _google_factory)
 ClientRegistry.register("vllm", _vllm_factory)
 ClientRegistry.register("claude_code_cli", _claude_code_cli_factory)
-ClientRegistry.register("copilot_cli", _copilot_cli_factory)

{geny_executor-2.0.4 → geny_executor-2.0.6}/src/geny_executor/llm_client/translators/__init__.py

@@ -33,10 +33,7 @@ from geny_executor.llm_client.translators._cli import (
     assemble_response_from_stream_json,
     build_stream_json_stdin,
     claude_code_argv,
-    compose_copilot_prompt,
-    copilot_argv,
     parse_json_output_to_response,
-    parse_plain_text_to_response,
     stream_json_line_to_canonical_event,
     thinking_to_effort,
 )
@@ -55,11 +52,8 @@ __all__ = [
     "canonical_tools_to_google",
     "canonical_tools_to_openai",
     "claude_code_argv",
-    "compose_copilot_prompt",
-    "copilot_argv",
     "normalize_stop_reason",
     "parse_json_output_to_response",
-    "parse_plain_text_to_response",
     "split_tool_results",
     "split_tool_uses",
     "stream_json_line_to_canonical_event",

{geny_executor-2.0.4 → geny_executor-2.0.6}/src/geny_executor/llm_client/translators/_cli.py

@@ -1,20 +1,22 @@
 """Canonical ↔ CLI translation helpers.
 
-Used by ``ClaudeCodeCLIClient`` (Phase B) and ``CopilotCLIClient`` (Phase C)
-to:
+Used by ``ClaudeCodeCLIClient`` (Phase B) to:
 
   - Build vendor-specific argv lists from a canonical :class:`APIRequest`.
   - Assemble a canonical :class:`APIResponse` from CLI output.
   - Map streaming stream-json line types to canonical event dicts.
 
-Claude Code helpers landed in Phase B1; ``gh copilot`` helpers
-(``compose_copilot_prompt``, ``copilot_argv``, ``parse_plain_text_to_response``)
-land here in Phase C1.
+The Phase-C ``gh copilot`` helpers (``compose_copilot_prompt``,
+``copilot_argv``, ``parse_plain_text_to_response``) were removed in
+2.0.6 along with the ``CopilotCLIClient`` itself — ``gh copilot``
+does not support streaming, tools, or MCP, so it could not host the
+pipeline's Stage-10 dispatch loop.
 """
 
 from __future__ import annotations
 
 import json
+import os
 from typing import Any, AsyncIterator, Dict, List, Optional, Sequence
 
 from geny_executor.core.state import TokenUsage
@@ -83,8 +85,19 @@ def claude_code_argv(
 
     # Output / input formats: always stream-json for streaming requests,
     # else json so we can parse a single object.
+    #
+    # ``--verbose`` is required by Claude Code CLI ≥ 2.1.x whenever
+    # ``--print`` is combined with ``--output-format=stream-json``;
+    # without it the CLI exits 1 with:
+    #
+    #     Error: When using --print, --output-format=stream-json
+    #     requires --verbose
+    #
+    # 2.0.6 emits it automatically alongside the stream-json switch so
+    # hosts don't have to thread an opt-in flag through their settings.
     if request.stream:
         argv += [
+            "--verbose",
             "--input-format", "stream-json",
             "--output-format", "stream-json",
             "--include-partial-messages",
@@ -92,8 +105,21 @@ def claude_code_argv(
     else:
         argv += ["--output-format", "json"]
 
+    # ``--bare`` skips OAuth + keychain reads (per ``claude --help``:
+    # "Anthropic auth is strictly ANTHROPIC_API_KEY or apiKeyHelper via
+    # --settings (OAuth and keychain are never read)"). That's correct
+    # for the API-key auth path but **wrong** for the subscription
+    # OAuth path — passing ``--bare`` without an API key crashes every
+    # subscription user with "Not logged in · Please run /login". 2.0.6
+    # auto-strips ``--bare`` when no API key is reachable in the
+    # spawning process's environment, so the same ``bare_mode=True``
+    # default works for both auth paths transparently. Callers that
+    # explicitly want OAuth even with an API key present can still
+    # pass ``bare_mode=False``.
     if bare_mode:
-        argv.append("--bare")
+        has_api_key = bool(os.environ.get("ANTHROPIC_API_KEY", "").strip())
+        if has_api_key:
+            argv.append("--bare")
 
     # Model: alias or pinned id.
     if request.model:
@@ -139,12 +165,39 @@ def claude_code_argv(
     if settings_path:
         argv += ["--settings", settings_path]
 
-    # MCP config: accept dict (inline JSON), str path, or pre-serialized JSON.
-    if mcp_config is not None:
-        if isinstance(mcp_config, str):
-            argv += ["--mcp-config", mcp_config]
+    # MCP config — precedence:
+    #   1. ``request.mcp_config`` (per-request, set by host for
+    #      session-scoped MCP wraps). Phase I: Geny synthesizes a
+    #      per-session MCP config that bridges its tool registry to
+    #      the CLI so the LLM can call host tools via MCP.
+    #   2. ``mcp_config`` constructor kwarg (legacy per-client static
+    #      config from the LLM-backends settings card).
+    # Both flow to ``--mcp-config <json|path>``.
+    effective_mcp_config: Any = (
+        request.mcp_config if request.mcp_config is not None else mcp_config
+    )
+    has_host_mcp = bool(effective_mcp_config)
+    if has_host_mcp:
+        if isinstance(effective_mcp_config, str):
+            argv += ["--mcp-config", effective_mcp_config]
         else:
-            argv += ["--mcp-config", json.dumps(mcp_config)]
+            argv += [
+                "--mcp-config",
+                json.dumps(effective_mcp_config, ensure_ascii=False),
+            ]
+        # ``--strict-mcp-config`` ignores any other MCP config sources
+        # (user-level / project-level) so the per-session bridge is
+        # the sole MCP surface the CLI sees. The CLI's *built-in* tool
+        # palette (``Bash`` / ``Read`` / ``Write`` / ``Edit`` / …)
+        # stays available alongside the MCP surface — earlier
+        # executor versions auto-emitted ``--tools ""`` here to
+        # disable it (a defensive measure against the LLM
+        # hallucinating against unknown built-ins), but in practice
+        # most hosts *want* both surfaces (e.g. a Sub-Worker writing
+        # files via ``Write`` while delegating to MCP-wrapped host
+        # tools). Hosts that prefer the old MCP-only behaviour can
+        # pass ``extra_args=("--tools", "")`` explicitly.
+        argv += ["--strict-mcp-config"]
 
     # JSON schema (structured output).
     if request.response_format:
@@ -426,6 +479,11 @@ def parse_json_output_to_response(stdout: bytes, *, model: str) -> APIResponse:
     if not isinstance(obj, dict):
         raise ValueError("Claude Code json output is not an object")
 
+    # ``tool_use`` blocks in the json output are intentionally dropped
+    # for the same reason as ``StreamJsonAccumulator.finalize`` — the
+    # CLI handles tool dispatch internally and host pipelines should
+    # see only the final assistant text. See ``finalize``'s docstring
+    # for the full rationale.
     blocks: List[ContentBlock] = []
     for block in obj.get("content", []) or []:
         if not isinstance(block, dict):
@@ -437,15 +495,6 @@ def parse_json_output_to_response(stdout: bytes, *, model: str) -> APIResponse:
             blocks.append(
                 ContentBlock(type="thinking", thinking_text=block.get("text", ""))
             )
-        elif btype == "tool_use":
-            blocks.append(
-                ContentBlock(
-                    type="tool_use",
-                    tool_use_id=block.get("id"),
-                    tool_name=block.get("name"),
-                    tool_input=block.get("input") or {},
-                )
-            )
 
     usage_in = obj.get("usage", {}) or {}
     usage = TokenUsage(
@@ -552,9 +601,39 @@ class StreamJsonAccumulator:
         return [{"type": "cli_unknown", "raw": line}]
 
     def finalize(self) -> APIResponse:
-        """Build the canonical :class:`APIResponse` from accumulated state."""
+        """Build the canonical :class:`APIResponse` from accumulated state.
+
+        ``tool_use`` blocks observed during streaming are intentionally
+        **dropped** from the assembled response. Claude Code CLI 2.1.x
+        runs its agentic loop *internally* (LLM → tool → LLM → tool →
+        …); each intermediate turn arrives as its own ``"assistant"``
+        envelope and the accumulator collects every block from every
+        envelope into the shared buffers below. The CLI has already
+        dispatched those tool calls (via its own built-ins or via the
+        host's MCP bridge) and emitted the matching ``"user"``
+        ``tool_result`` envelopes in the same stream — so including the
+        ``tool_use`` blocks in the terminal :class:`APIResponse` would
+        push host pipelines (Geny's Stage 10, the canonical reference
+        consumer) into trying to re-dispatch tools they have no
+        registration for, producing instant ``ERROR (0 ms) — No
+        output`` ghost failures for every CLI tool call. Per the Phase
+        I design contract:
+
+            Stage 10 receives that assistant message, sees no
+            ``tool_use`` blocks (they were executed inside the CLI),
+            and naturally no-ops.
+
+        Hosts that *do* want the raw tool_use record can still recover
+        it from the per-line stream events the accumulator yields
+        through ``feed()`` (each ``tool_use`` block produces a
+        ``{"type": "tool_use", "id": ..., "name": ..., "input": ...}``
+        event).
+        """
         # Flush any unclosed tool — the message form often skips
-        # ``content_block_stop`` entirely.
+        # ``content_block_stop`` entirely. We still call this so the
+        # accumulator's internal state is consistent for callers that
+        # rely on ``_tool_uses`` directly; only the *response* blocks
+        # below skip them.
         self._close_current_tool()
 
         blocks: List[ContentBlock] = []
@@ -564,15 +643,6 @@ class StreamJsonAccumulator:
             )
         if self._text_buf:
             blocks.append(ContentBlock(type="text", text="".join(self._text_buf)))
-        for tu in self._tool_uses:
-            blocks.append(
-                ContentBlock(
-                    type="tool_use",
-                    tool_use_id=tu.get("id"),
-                    tool_name=tu.get("name"),
-                    tool_input=tu.get("input") or {},
-                )
-            )
 
         usage_in: Dict[str, Any] = (self._final_obj or {}).get("usage", {}) or {}
         usage = TokenUsage(
@@ -745,104 +815,9 @@ async def assemble_response_from_stream_json(
     return accum.finalize()
 
 
-# ---------------------------------------------------------------------------
-# Copilot CLI: prompt composition
-# ---------------------------------------------------------------------------
-
-
-def compose_copilot_prompt(system: Any, messages: List[Dict[str, Any]]) -> str:
-    """Flatten a canonical (system + messages) into one ``-p`` argument.
-
-    The Copilot CLI accepts a single prompt string. Conversation history
-    is encoded as Markdown-style turns so the model can still see prior
-    turns. The system prompt is prepended as a ``## System`` section
-    when present.
-    """
-    parts: List[str] = []
-    if system:
-        if isinstance(system, str):
-            sys_text = system
-        elif isinstance(system, list):
-            sys_text = "\n".join(
-                str(b.get("text", "")) for b in system if isinstance(b, dict) and b.get("type") == "text"
-            )
-        else:
-            sys_text = str(system)
-        if sys_text:
-            parts.append(f"## System\n{sys_text}")
-
-    for m in messages:
-        role = str(m.get("role", "user")).capitalize()
-        content = m.get("content", "")
-        if isinstance(content, list):
-            chunks: List[str] = []
-            for block in content:
-                if not isinstance(block, dict):
-                    continue
-                btype = block.get("type", "")
-                if btype == "text":
-                    chunks.append(str(block.get("text", "")))
-                elif btype == "tool_result":
-                    chunks.append(f"[tool_result]\n{block.get('content', '')}")
-            content_text = "\n".join(chunks)
-        else:
-            content_text = str(content)
-        if content_text:
-            parts.append(f"## {role}\n{content_text}")
-
-    return "\n\n".join(parts)
-
-
-# ---------------------------------------------------------------------------
-# Copilot CLI: argv builder
-# ---------------------------------------------------------------------------
-
-
-def copilot_argv(
-    *,
-    allow_tools: Sequence[str] = (),
-    extra_args: Sequence[str] = (),
-) -> List[str]:
-    """Build the argv list for ``gh copilot`` (excluding the binary).
-
-    The caller is expected to invoke the result as ``gh copilot ...`` —
-    i.e. ``argv[0]`` is *not* prepended here. ``-p <prompt>`` is appended
-    by the client after computing the prompt via
-    :func:`compose_copilot_prompt`.
-
-    Only the flags the CLI actually accepts are emitted:
-      - ``-p``: single prompt (added by the client, not here)
-      - ``--allow-tool '<scope>'``: repeated, one flag per scope
-      - any ``extra_args`` for escape-hatch use.
-    """
-    argv: List[str] = ["copilot"]
-    for scope in allow_tools:
-        if scope:
-            argv += ["--allow-tool", str(scope)]
-    if extra_args:
-        argv += list(extra_args)
-    return argv
-
-
-# ---------------------------------------------------------------------------
-# Copilot CLI: stdout → APIResponse
-# ---------------------------------------------------------------------------
-
-
-def parse_plain_text_to_response(text: str, *, model: str = "default") -> APIResponse:
-    """Wrap plain stdout text into a canonical :class:`APIResponse`.
-
-    Copilot CLI does not return JSON in print mode, so we cannot recover
-    structured usage / cost. The response carries the text in a single
-    block, ``stop_reason="end_turn"``, and an empty TokenUsage with
-    ``supports_token_usage=False`` advertised at the client level.
-    """
-    content_text = text.strip("\n")
-    return APIResponse(
-        content=[ContentBlock(type="text", text=content_text)],
-        stop_reason="end_turn",
-        usage=TokenUsage(),
-        model=model,
-        message_id="",
-        raw=text,
-    )
+# Copilot CLI helpers (compose_copilot_prompt / copilot_argv /
+# parse_plain_text_to_response) were removed in 2.0.6. ``gh copilot``
+# is one-shot text-in / text-out with no streaming, no tool round-trip,
+# and no MCP support, so it could not host the pipeline's Stage-10
+# dispatch loop. The ``CopilotCLIClient`` and its registry entry are
+# also gone — see the matching commit message.

{geny_executor-2.0.4 → geny_executor-2.0.6}/src/geny_executor/llm_client/types.py

@@ -42,6 +42,18 @@ class APIRequest:
     #:   {"session_id": "...", "resume": bool}
     session_hint: Optional[Dict[str, Any]] = None
 
+    #: Per-request MCP server configuration. CLI-based backends
+    #: (claude_code_cli) serialize this to ``--mcp-config <json>``;
+    #: SDK-based backends ignore it. Hosts use this to surface their
+    #: tool registry to the CLI's LLM without going through the
+    #: cumbersome per-client static ``mcp_config_path``. Shape::
+    #:
+    #:     {"mcpServers": {"<name>": {"type": "stdio",
+    #:                                "command": "...",
+    #:                                "args": [...],
+    #:                                "env": {...}}}}
+    mcp_config: Optional[Dict[str, Any]] = None
+
     metadata: Optional[Dict[str, Any]] = None
 
 

geny_executor-2.0.6/tests/_fixtures/__init__.py

@@ -0,0 +1,2 @@
+"""Test fixtures: fake CLI binaries used by _cli_runtime / claude_code
+suites. Each binary is a standalone Python script with a shebang."""

{geny_executor-2.0.4 → geny_executor-2.0.6}/tests/llm_client/conformance/test_claude_code_cli.py

@@ -110,16 +110,21 @@ class TestClaudeCodeCLIConformance(ConformanceTestSuite):
         assert resp.usage.duration_ms is not None
 
     @pytest.mark.asyncio
-    async def test_tool_use_round_trip(self) -> None:
+    async def test_tool_use_blocks_dropped(self) -> None:
+        """The CLI handles tool dispatch internally — ``tool_use``
+        blocks observed in its output are intentionally dropped from
+        the assembled response so host pipelines (Geny's Stage 10,
+        the canonical reference consumer) don't try to re-dispatch
+        them and ghost-error. ``stop_reason`` is preserved so callers
+        can still see the CLI ended in a tool turn. See
+        ``StreamJsonAccumulator.finalize`` for the full rationale."""
         client = self.make_client(scenario="ok_tool_use")
         resp = await client.create_message(
             model_config=ModelConfig(model="sonnet"),
             messages=[{"role": "user", "content": "read /tmp/x"}],
         )
-        assert resp.has_tool_calls is True
-        tu = resp.tool_calls[0]
-        assert tu.tool_name == "Read"
-        assert tu.tool_input == {"path": "/tmp/x"}
+        assert resp.tool_calls == []
+        assert resp.stop_reason == "tool_use"
 
     @pytest.mark.asyncio
     async def test_thinking_blocks_returned(self) -> None:

{geny_executor-2.0.4 → geny_executor-2.0.6}/tests/llm_client/unit/test_claude_code.py

@@ -151,13 +151,15 @@ async def test_send_oneshot_ok_text() -> None:
 
 
 @pytest.mark.asyncio
-async def test_send_oneshot_tool_use() -> None:
+async def test_send_oneshot_tool_use_blocks_dropped() -> None:
+    """``tool_use`` blocks are dropped from the response — the CLI
+    dispatched them internally. ``stop_reason`` is preserved
+    verbatim so callers can still tell the CLI ended in a tool turn
+    (e.g. CLI hit max-iter mid-loop with pending tool calls). See
+    ``StreamJsonAccumulator.finalize`` for the full rationale."""
     c = _client(scenario="ok_tool_use")
     resp = await c._send(_make_request())
-    assert resp.has_tool_calls is True
-    tools = resp.tool_calls
-    assert tools[0].tool_name == "Read"
-    assert tools[0].tool_input == {"path": "/tmp/x"}
+    assert resp.tool_calls == []
     assert resp.stop_reason == "tool_use"
 
 
@@ -323,7 +325,11 @@ async def test_send_streaming_message_form_text() -> None:
 
 
 @pytest.mark.asyncio
-async def test_argv_carries_bare_and_workspace() -> None:
+async def test_argv_carries_bare_and_workspace(monkeypatch) -> None:
+    # ``--bare`` is auto-stripped on the OAuth path (no
+    # ANTHROPIC_API_KEY in env). Pin the API-key env so this argv
+    # surface test exercises the API-key path.
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test")
     c = _client(scenario="echo_argv")
     resp = await c._send(_make_request(model="opus", system="rule X"))
     import json