geny-executor 2.0.3__tar.gz → 2.0.5__tar.gz

{geny_executor-2.0.3 → geny_executor-2.0.5}/PKG-INFO

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

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

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

{geny_executor-2.0.3 → geny_executor-2.0.5}/src/geny_executor/llm_client/translators/_cli.py

@@ -139,12 +139,40 @@ 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),
+            ]
+        # When the host exposes its own tool surface via MCP, disable
+        # the CLI's built-in tool palette so the LLM cannot hallucinate
+        # against ``Bash`` / ``Read`` / ``ToolSearch`` / etc. The CLI's
+        # ``--tools ""`` literal disables the entire built-in set per
+        # ``claude --help``. Caller-supplied ``allow_tools`` /
+        # ``disallow_tools`` (legacy CLI-built-in filters) are also
+        # forwarded earlier so a host that wants a mixed surface — MCP
+        # tools + a curated subset of CLI built-ins — can opt back in.
+        # ``--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.
+        if not allow_tools:
+            argv += ["--tools", ""]
+        argv += ["--strict-mcp-config"]
 
     # JSON schema (structured output).
     if request.response_format:
@@ -173,29 +201,147 @@ def claude_code_argv(
 # ---------------------------------------------------------------------------
 
 
-def build_stream_json_stdin(messages: List[Dict[str, Any]]) -> bytes:
-    """Render canonical messages as Claude Code stream-json stdin.
-
-    Claude Code's ``--input-format stream-json`` expects newline-delimited
-    JSON envelopes of the shape::
+def _render_block_for_history(block: Any) -> str:
+    """Render one Anthropic-style content block as readable text.
+
+    Used by ``build_stream_json_stdin`` when collapsing multi-turn
+    history into a single synthetic user envelope. Preserves enough
+    fidelity (tool name + input, tool result text) for the LLM to
+    reconstruct the conversation, while dropping shapes the CLI
+    cannot ingest (thinking blocks, images→placeholder)."""
+    if isinstance(block, str):
+        return block
+    if not isinstance(block, dict):
+        return str(block)
+    btype = str(block.get("type", ""))
+    if btype == "text":
+        return str(block.get("text", ""))
+    if btype == "thinking":
+        # Thinking traces from a prior provider don't replay on the
+        # CLI — drop them. The CLI does its own ``--effort`` thinking
+        # on the new turn.
+        return ""
+    if btype == "tool_use":
+        name = block.get("name", "tool")
+        try:
+            input_json = json.dumps(
+                block.get("input") or {}, ensure_ascii=False,
+            )
+        except (TypeError, ValueError):
+            input_json = str(block.get("input"))
+        return f"[Tool call: {name}({input_json})]"
+    if btype == "tool_result":
+        body = block.get("content")
+        if isinstance(body, list):
+            body = "\n".join(
+                _render_block_for_history(b) for b in body
+            ).strip()
+        elif body is None:
+            body = ""
+        is_error = bool(block.get("is_error"))
+        tag = "Tool error" if is_error else "Tool result"
+        return f"[{tag}] {body}"
+    if btype == "image":
+        return "[image attachment]"
+    return ""
+
+
+def _render_content_for_history(content: Any) -> str:
+    """Flatten a canonical ``content`` field (string or block list)
+    into one display-ready text run for history-preamble use."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        rendered = [
+            _render_block_for_history(b) for b in content
+        ]
+        return "\n".join(s for s in rendered if s).strip()
+    return str(content)
 
-        {"type": "user", "message": {"role": "user", "content": [...]}}
 
-    Tool-results / assistant turns from prior multi-turn history flow as
-    additional ``user``-typed entries with their original role embedded —
-    the CLI reconstructs the conversation from the envelopes.
+def build_stream_json_stdin(messages: List[Dict[str, Any]]) -> bytes:
+    """Render canonical Anthropic-style messages as Claude Code
+    stream-json stdin — **always as a single ``type:user`` envelope**.
+
+    Claude Code CLI's ``--input-format stream-json`` strictly requires
+    each envelope's ``message.role`` to be ``"user"``. The previous
+    implementation forwarded the canonical role through (assistant /
+    tool turns embedded in ``type:user`` envelopes with their original
+    role kept) which the CLI rejects with::
+
+        Error: Expected message role 'user', got 'assistant'
+
+    For multi-turn pipelines (Geny's s06_api accumulates conversation
+    history across loop iterations) we collapse the whole history into
+    a single synthetic user envelope:
+
+      - The latest user message becomes the bulk of the prompt.
+      - All prior turns are rendered as a markdown preamble
+        (``### User`` / ``### Assistant`` / tool calls + results).
+      - The CLI receives one cohesive single-turn prompt with all
+        relevant context — same input contract whether the host is
+        running Geny's iterative loop or sending a one-shot query.
+
+    The single-turn fast-path (one user message only) emits the
+    canonical envelope unchanged so simple invocations stay byte-for-
+    byte identical to the legacy path.
     """
-    out_lines: List[str] = []
-    for m in messages:
-        role = str(m.get("role", "user"))
-        content = m.get("content", "")
+    if not messages:
+        return b""
+
+    # Single-turn fast path — preserve the canonical envelope shape.
+    if len(messages) == 1 and str(messages[0].get("role", "")) == "user":
         envelope = {
             "type": "user",
-            "message": {"role": role, "content": content},
+            "message": {"role": "user", "content": messages[0].get("content", "")},
         }
-        out_lines.append(json.dumps(envelope))
-    blob = "\n".join(out_lines)
-    return (blob + "\n").encode("utf-8") if blob else b""
+        return (json.dumps(envelope, ensure_ascii=False) + "\n").encode("utf-8")
+
+    # Multi-turn: flatten into a single synthetic user message. The
+    # CLI's ``--bare`` mode treats this as a regular prompt; the LLM
+    # reconstructs the conversation from the markdown structure.
+    parts: List[str] = []
+    last_user_idx = -1
+    for i, m in enumerate(messages):
+        if str(m.get("role", "")) == "user":
+            last_user_idx = i
+
+    for i, m in enumerate(messages):
+        role = str(m.get("role", "user"))
+        text = _render_content_for_history(m.get("content", ""))
+        if not text and role != "assistant":
+            continue
+        if role == "user":
+            # The final user turn is the "current input" — render it
+            # without a header so it reads as the actual question.
+            if i == last_user_idx:
+                parts.append(text)
+            else:
+                parts.append(f"### User\n{text}")
+        elif role == "assistant":
+            if text:
+                parts.append(f"### Assistant\n{text}")
+        elif role == "tool":
+            parts.append(f"### Tool result\n{text}")
+        else:
+            parts.append(f"### {role.capitalize()}\n{text}")
+
+    preamble = ""
+    current_input = parts[-1] if parts else ""
+    if len(parts) > 1:
+        preamble_parts = parts[:-1]
+        preamble = (
+            "## Conversation so far\n\n"
+            + "\n\n".join(preamble_parts)
+            + "\n\n## Current input\n"
+        )
+
+    flat = (preamble + current_input).strip()
+    envelope = {
+        "type": "user",
+        "message": {"role": "user", "content": flat},
+    }
+    return (json.dumps(envelope, ensure_ascii=False) + "\n").encode("utf-8")
 
 
 # ---------------------------------------------------------------------------

{geny_executor-2.0.3 → geny_executor-2.0.5}/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.3 → geny_executor-2.0.5}/tests/llm_client/unit/test_translators_cli_claude_code.py

@@ -137,6 +137,57 @@ def test_argv_mcp_config_path_passed_through() -> None:
     assert blob == "/tmp/mcp.json"
 
 
+def test_argv_request_mcp_config_overrides_kwarg() -> None:
+    """``APIRequest.mcp_config`` (per-request) wins over the
+    constructor kwarg (per-client static). Phase I uses this to
+    inject the per-session Geny tools bridge alongside any
+    settings-card-configured MCP servers."""
+    per_request = {"mcpServers": {"geny": {"type": "stdio", "command": "py"}}}
+    per_client = {"mcpServers": {"legacy": {"command": "x"}}}
+    argv = claude_code_argv(_req(mcp_config=per_request), mcp_config=per_client)
+    blob = argv[argv.index("--mcp-config") + 1]
+    assert json.loads(blob) == per_request  # per-request wins
+
+
+def test_argv_host_mcp_disables_cli_builtins_and_strict() -> None:
+    """When the host registers MCP servers, the CLI's built-in tool
+    palette is disabled (``--tools ""``) so the LLM only ever sees
+    MCP-advertised tools. ``--strict-mcp-config`` ignores any other
+    MCP configuration sources so the per-session bridge is the sole
+    surface. Together these eliminate the hallucination path where
+    the LLM tries to use ``Bash``/``ToolSearch``/etc. that the host
+    has no executor for."""
+    cfg = {"mcpServers": {"geny": {"type": "stdio", "command": "py"}}}
+    argv = claude_code_argv(_req(mcp_config=cfg))
+    # Disable built-ins.
+    idx = argv.index("--tools")
+    assert argv[idx + 1] == ""
+    # Strict mode.
+    assert "--strict-mcp-config" in argv
+
+
+def test_argv_host_mcp_with_explicit_allow_tools_keeps_builtins() -> None:
+    """``--allowedTools`` is the legacy whitelist of CLI built-ins.
+    If a caller explicitly supplies one alongside an MCP config they
+    want a mixed surface (custom MCP tools + a curated subset of CLI
+    built-ins). Don't override their choice."""
+    cfg = {"mcpServers": {"geny": {"type": "stdio", "command": "py"}}}
+    argv = claude_code_argv(_req(mcp_config=cfg), allow_tools=["Read"])
+    # No --tools "" disabler — caller picked allowedTools explicitly.
+    assert "--tools" not in argv
+    assert "--allowedTools" in argv
+
+
+def test_argv_no_mcp_no_tools_flag() -> None:
+    """Legacy callers without any MCP config keep today's behaviour:
+    CLI built-ins available, no ``--tools ""`` disable, no
+    ``--strict-mcp-config``."""
+    argv = claude_code_argv(_req())
+    assert "--tools" not in argv
+    assert "--strict-mcp-config" not in argv
+    assert "--mcp-config" not in argv
+
+
 def test_argv_response_format_json_schema_emits_flag() -> None:
     schema = {"type": "object", "properties": {"x": {"type": "string"}}}
     argv = claude_code_argv(
@@ -189,17 +240,97 @@ def test_stdin_envelope_one_user_message() -> None:
     ]
 
 
-def test_stdin_envelope_multi_turn() -> None:
+def test_stdin_envelope_multi_turn_always_user_role() -> None:
+    """Regression: every envelope's ``message.role`` MUST be ``"user"``.
+
+    Claude Code CLI 2.x rejects ``type:user`` envelopes that carry an
+    embedded ``message.role: assistant`` with::
+
+        Error: Expected message role 'user', got 'assistant'
+
+    The pre-fix builder forwarded canonical roles through and broke
+    every multi-turn iteration of an env that pinned ``claude_code_cli``
+    as the Stage 6 provider.
+    """
     out = build_stream_json_stdin([
         {"role": "user", "content": "q1"},
         {"role": "assistant", "content": "a1"},
         {"role": "user", "content": [{"type": "tool_result", "content": "ok"}]},
     ])
     envs = [json.loads(l) for l in out.strip().split(b"\n")]
+    # ONE synthetic envelope — multi-turn collapses to a single user
+    # message; the CLI reconstructs the conversation from its content.
+    assert len(envs) == 1
+    assert envs[0]["type"] == "user"
     assert envs[0]["message"]["role"] == "user"
-    assert envs[1]["message"]["role"] == "assistant"
-    assert envs[2]["message"]["role"] == "user"
-    assert envs[2]["message"]["content"][0]["type"] == "tool_result"
+
+
+def test_stdin_envelope_multi_turn_preserves_history_in_content() -> None:
+    """The collapsed envelope must carry enough fidelity that the LLM
+    can reconstruct the prior conversation: text turns, tool calls
+    (name + input), and tool results all show up in the flattened
+    content under markdown headers."""
+    out = build_stream_json_stdin([
+        {"role": "user", "content": "find the README"},
+        {
+            "role": "assistant",
+            "content": [
+                {"type": "text", "text": "Let me check."},
+                {
+                    "type": "tool_use",
+                    "id": "tu_1",
+                    "name": "Read",
+                    "input": {"path": "/repo/README.md"},
+                },
+            ],
+        },
+        {
+            "role": "user",
+            "content": [
+                {"type": "tool_result", "tool_use_id": "tu_1", "content": "# Hello"},
+            ],
+        },
+        {"role": "user", "content": "summarize it"},
+    ])
+    env = json.loads(out.strip())
+    text = env["message"]["content"]
+    assert "## Conversation so far" in text
+    assert "find the README" in text
+    assert "[Tool call: Read({" in text
+    assert "/repo/README.md" in text
+    assert "[Tool result] # Hello" in text
+    # The final user turn ("summarize it") is the "current input" and
+    # appears under "## Current input" without the per-turn header.
+    assert "## Current input" in text
+    assert text.rstrip().endswith("summarize it")
+
+
+def test_stdin_envelope_drops_thinking_and_handles_tool_errors() -> None:
+    """Thinking blocks from a prior provider don't replay on the CLI
+    — drop them. ``is_error: True`` tool_results render under a
+    "Tool error" tag so the LLM sees the failure semantics."""
+    out = build_stream_json_stdin([
+        {"role": "user", "content": "do X"},
+        {
+            "role": "assistant",
+            "content": [
+                {"type": "thinking", "thinking": "secret reasoning"},
+                {"type": "text", "text": "trying X..."},
+                {"type": "tool_use", "id": "t1", "name": "Bash", "input": {"cmd": "x"}},
+            ],
+        },
+        {
+            "role": "user",
+            "content": [
+                {"type": "tool_result", "tool_use_id": "t1", "is_error": True, "content": "command failed"},
+            ],
+        },
+    ])
+    env = json.loads(out.strip())
+    text = env["message"]["content"]
+    assert "secret reasoning" not in text  # thinking dropped
+    assert "trying X..." in text
+    assert "[Tool error] command failed" in text
 
 
 def test_stdin_empty_messages_returns_empty_bytes() -> None: