geny-executor 2.1.2__tar.gz → 2.1.4__tar.gz

{geny_executor-2.1.2 → geny_executor-2.1.4}/PKG-INFO

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

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

@@ -96,7 +96,7 @@ from geny_executor.memory import (
     ProviderDrivenStrategy,
 )
 
-__version__ = "2.1.2"
+__version__ = "2.1.4"
 
 __all__ = [
     # Core

{geny_executor-2.1.2 → geny_executor-2.1.4}/src/geny_executor/llm_client/anthropic.py

@@ -111,6 +111,56 @@ def _model_rejects_sampling_params(model: str) -> bool:
     )
 
 
+# ── ``thinking.type=enabled`` → ``adaptive`` migration ──────────────
+#
+# Opus 4.7 (verified 2026-06-04) rejects ``thinking.type=enabled``
+# and requires ``thinking.type=adaptive`` instead — the old
+# enabled-with-fixed-budget shape isn't valid for the new generation
+# of thinking-native models. The API error reads:
+#
+#   ``"thinking.type.enabled" is not supported for this model.
+#     Use "thinking.type.adaptive" and "output_config.effort"``.
+#
+# Under ``adaptive``, the model picks its own budget; the legacy
+# ``budget_tokens`` field is rejected as an extra input
+# (``thinking.adaptive.budget_tokens: Extra inputs are not permitted``).
+# Effort is *optional* — calls with bare ``{"type":"adaptive"}`` work.
+# Translate at the boundary so callers that ship the v1 thinking
+# shape continue to work against v2 models.
+_THINKING_ADAPTIVE_ONLY_PREFIXES: tuple[str, ...] = (
+    "claude-opus-4-7",
+)
+
+
+def _model_requires_adaptive_thinking(model: str) -> bool:
+    """True iff ``model`` only accepts ``thinking.type=adaptive``."""
+    return any(
+        model.startswith(prefix) for prefix in _THINKING_ADAPTIVE_ONLY_PREFIXES
+    )
+
+
+def _translate_thinking_to_adaptive(thinking: Dict[str, Any]) -> Dict[str, Any]:
+    """Migrate a v1 (``type=enabled``) thinking dict to the v2
+    (``type=adaptive``) shape Opus 4.7 demands.
+
+      * ``type`` flips to ``"adaptive"``.
+      * ``budget_tokens`` is dropped — the API rejects it under
+        adaptive (``thinking.adaptive.budget_tokens: Extra inputs are
+        not permitted``).
+      * Any other unrelated keys (``display`` etc.) pass through.
+
+    The kwarg ``output_config.effort`` is *not* added — bare
+    ``{"type":"adaptive"}`` works against the live API; the API
+    picks a default effort. Hosts that want to pin effort can do so
+    explicitly by setting it on ``model_config`` and threading it
+    through future plumbing.
+    """
+    out = dict(thinking)
+    out["type"] = "adaptive"
+    out.pop("budget_tokens", None)
+    return out
+
+
 # ── Last-line retry on a deprecation 400 ────────────────────────────
 #
 # Future Anthropic releases will deprecate more sampling params for
@@ -131,18 +181,42 @@ _DEPRECATION_MSG_TO_KWARG_KEY: Dict[str, str] = {
 def _retry_kwargs_after_deprecation(
     kwargs: Dict[str, Any], exc: BaseException,
 ) -> Optional[Dict[str, Any]]:
-    """If ``exc`` is the Anthropic deprecation 400 for a sampling
-    field we recognise, return a copy of ``kwargs`` with that field
-    removed. ``None`` means *don't retry* — let the caller re-raise.
-
-    Defends against future model deprecations the static prefix list
-    in ``_TEMPERATURE_DEPRECATED_PREFIXES`` doesn't know about yet.
-    Only retries once per send (the caller guarantees this by not
-    calling us recursively); if the retry also 400s the outer
-    handler classifies and raises.
+    """If ``exc`` is an Anthropic 400 we can self-heal, return a
+    rebuilt kwargs. ``None`` means *don't retry* — let the caller
+    re-raise.
+
+    Two recognised classes today:
+
+      1. **Sampling-param deprecation** — the API message names a
+         specific field (``temperature``, ``top_p``, ``top_k``) as
+         deprecated. Strip the field and retry.
+      2. **Thinking v1 → v2 migration** — the API rejects
+         ``thinking.type=enabled`` and asks for
+         ``thinking.type.adaptive``. Translate via
+         :func:`_translate_thinking_to_adaptive` and retry.
+
+    Defends against future model rollouts our static prefix lists
+    don't know about yet. Caller guarantees one retry per send (we
+    never recurse); a retry that also 400s gets classified + raised
+    by the outer handler.
     """
     msg = str(getattr(exc, "message", "") or exc)
     msg_lower = msg.lower()
+
+    # Class 2 — thinking v1→v2 migration. Run first because the
+    # diagnostic is structural (the request shape, not just one
+    # missing field).
+    if (
+        "thinking.type.enabled" in msg_lower
+        or "thinking.type.adaptive" in msg_lower
+    ) and isinstance(kwargs.get("thinking"), dict):
+        thinking = kwargs["thinking"]
+        if thinking.get("type") == "enabled":
+            retry = dict(kwargs)
+            retry["thinking"] = _translate_thinking_to_adaptive(thinking)
+            return retry
+
+    # Class 1 — sampling-param deprecation.
     for needle, key in _DEPRECATION_MSG_TO_KWARG_KEY.items():
         if needle in msg_lower and key in kwargs:
             retry = dict(kwargs)
@@ -367,6 +441,26 @@ class AnthropicClient(BaseClient):
                         key, dropped, resolved_model,
                     )
 
+        # Thinking-shape migration — see
+        # ``_THINKING_ADAPTIVE_ONLY_PREFIXES`` at module top. Opus 4.7
+        # rejects ``thinking.type=enabled``; flip to ``adaptive`` (and
+        # drop the now-invalid ``budget_tokens``) at the boundary so
+        # ``ModelConfig`` callers that still emit the v1 shape
+        # continue to work against v2 models.
+        if (
+            "thinking" in kwargs
+            and isinstance(kwargs["thinking"], dict)
+            and kwargs["thinking"].get("type") == "enabled"
+            and _model_requires_adaptive_thinking(resolved_model)
+        ):
+            before = kwargs["thinking"]
+            kwargs["thinking"] = _translate_thinking_to_adaptive(before)
+            logger.info(
+                "anthropic: translated thinking.type=enabled → adaptive "
+                "(model=%r, dropped legacy budget_tokens=%r)",
+                resolved_model, before.get("budget_tokens"),
+            )
+
         return kwargs
 
     def _parse_response(self, raw: Any) -> APIResponse:

{geny_executor-2.1.2 → geny_executor-2.1.4}/src/geny_executor/llm_client/translators/_cli.py

@@ -438,6 +438,48 @@ def stream_json_line_to_canonical_event(line_obj: Dict[str, Any]) -> Optional[Di
                 return {"type": "text_delta", "text": "".join(parts)}
         return None
 
+    if ltype == "stream_event":
+        # Claude Code CLI 2.1.x wrapper around the Anthropic Messages SSE
+        # event shape. Each ``stream_event`` line carries a single
+        # ``event`` dict whose ``type`` is one of message_start /
+        # content_block_start / content_block_delta / content_block_stop
+        # / message_delta / message_stop. This is the *only* form that
+        # actually streams token-by-token under
+        # ``--include-partial-messages``; without handling it, the
+        # parser falls through to the terminal ``assistant`` envelope
+        # (full-message form) which collapses everything into a single
+        # delta — exactly the "no streaming visible in the UI" bug.
+        ev = line_obj.get("event") or {}
+        if not isinstance(ev, dict):
+            return None
+        etype = str(ev.get("type", ""))
+        if etype == "content_block_delta":
+            delta = ev.get("delta") or {}
+            dtype = str(delta.get("type", ""))
+            if dtype == "text_delta":
+                return {"type": "text_delta", "text": delta.get("text", "")}
+            if dtype == "thinking_delta":
+                return {"type": "thinking_delta", "text": delta.get("text", "")}
+            if dtype == "input_json_delta":
+                return {"type": "input_json_delta", "delta": delta.get("partial_json", "")}
+            return None
+        if etype == "content_block_start":
+            cb = ev.get("content_block") or {}
+            if isinstance(cb, dict) and cb.get("type") == "tool_use":
+                return {
+                    "type": "tool_use",
+                    "id": cb.get("id"),
+                    "name": cb.get("name"),
+                    "input": cb.get("input") or {},
+                }
+            return None
+        if etype == "content_block_stop":
+            return {"type": "content_block_stop"}
+        # message_start / message_delta / message_stop carry usage +
+        # stop_reason metadata. Not text-bearing; let the accumulator
+        # record them silently.
+        return None
+
     if ltype == "content_block_stop":
         return {"type": "content_block_stop"}
     if ltype == "message_stop":
@@ -579,6 +621,9 @@ class StreamJsonAccumulator:
         if ltype == "assistant":
             return self._feed_assistant(line)
 
+        if ltype == "stream_event":
+            return self._feed_stream_event(line)
+
         if ltype == "content_block_stop":
             self._close_current_tool()
             return [{"type": "content_block_stop"}]
@@ -709,12 +754,125 @@ class StreamJsonAccumulator:
 
         return []
 
+    def _feed_stream_event(self, line: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Process a single Claude Code CLI ``stream_event`` line.
+
+        Claude Code CLI 2.1.x wraps the Anthropic Messages SSE event
+        shape inside a ``{"type":"stream_event","event":{...}}`` envelope
+        when ``--include-partial-messages`` is on. The accumulator turns
+        each one into the same canonical UI event the legacy ``assistant``
+        delta form produced, so downstream consumers (Geny's session
+        logger streaming pipe, Stage 10's tool dispatch, anything else
+        that reads ``feed()`` output) get token-level deltas without
+        having to learn the new wire format.
+
+        Mappings:
+          - ``message_start``        → record id + usage; no UI event
+          - ``content_block_start``  → tool_use carries the tool record
+          - ``content_block_delta``  → text_delta / thinking_delta /
+                                       input_json_delta
+          - ``content_block_stop``   → close current tool; emit stop
+          - ``message_delta``        → record stop_reason; no UI event
+          - ``message_stop``         → no UI event (caller emits the
+                                       final ``message_complete`` after
+                                       ``finalize()``)
+        """
+        ev = line.get("event") or {}
+        if not isinstance(ev, dict):
+            return []
+        etype = str(ev.get("type", ""))
+
+        if etype == "message_start":
+            msg = ev.get("message") or {}
+            if isinstance(msg, dict):
+                self._message_id = str(msg.get("id") or self._message_id)
+                self._resolved_model = str(msg.get("model") or self._resolved_model)
+                usage = msg.get("usage")
+                if isinstance(usage, dict) and self._final_obj is None:
+                    self._final_obj = {"usage": usage}
+            return []
+
+        if etype == "content_block_start":
+            cb = ev.get("content_block") or {}
+            if isinstance(cb, dict) and cb.get("type") == "tool_use":
+                self._current_tool = {
+                    "id": cb.get("id"),
+                    "name": cb.get("name"),
+                    "input": cb.get("input") or {},
+                }
+                return [
+                    {
+                        "type": "tool_use",
+                        "id": cb.get("id"),
+                        "name": cb.get("name"),
+                        "input": cb.get("input") or {},
+                    }
+                ]
+            return []
+
+        if etype == "content_block_delta":
+            delta = ev.get("delta") or {}
+            dtype = str(delta.get("type", ""))
+            if dtype == "text_delta":
+                text = str(delta.get("text", ""))
+                if text:
+                    self._text_buf.append(text)
+                    return [{"type": "text_delta", "text": text}]
+                return []
+            if dtype == "thinking_delta":
+                text = str(delta.get("text", ""))
+                if text:
+                    self._thinking_buf.append(text)
+                    return [{"type": "thinking_delta", "text": text}]
+                return []
+            if dtype == "input_json_delta":
+                partial = str(delta.get("partial_json", ""))
+                if self._current_tool is not None:
+                    self._current_tool.setdefault("_partial_json", "")
+                    self._current_tool["_partial_json"] += partial
+                return [{"type": "input_json_delta", "delta": partial}]
+            return []
+
+        if etype == "content_block_stop":
+            self._close_current_tool()
+            return [{"type": "content_block_stop"}]
+
+        if etype == "message_delta":
+            delta = ev.get("delta") or {}
+            if isinstance(delta, dict):
+                sr = delta.get("stop_reason")
+                if sr:
+                    self._stop_reason = str(sr)
+            # Some emitters tag usage on the message_delta event too.
+            usage = ev.get("usage")
+            if isinstance(usage, dict):
+                if self._final_obj is None:
+                    self._final_obj = {"usage": usage}
+                else:
+                    self._final_obj.setdefault("usage", usage)
+            return []
+
+        if etype == "message_stop":
+            return []
+
+        return []
+
     def _feed_message(self, message: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Process a full assistant message envelope's content array.
 
         Emits synthetic per-block delta events so UI consumers see the
         same canonical shape they would with true streaming, then
         records the blocks for the eventual :class:`APIResponse`.
+
+        ``stream_event``-form coexistence — Claude Code CLI 2.1.x with
+        ``--include-partial-messages`` emits BOTH per-token
+        ``stream_event`` lines AND a terminal ``assistant`` envelope
+        containing the same text in full. If we've already accumulated
+        text/thinking via the ``stream_event`` deltas, the envelope is
+        a duplicate and re-recording it would double every assistant
+        message. ``tool_use`` blocks are kept either way — tool calls
+        arrive via ``content_block_start``, not via deltas, so the
+        envelope is the canonical record for them.
         """
         # Capture stop_reason / usage off the envelope if present —
         # the ``message`` form lets the assistant frame carry these
@@ -725,12 +883,8 @@ class StreamJsonAccumulator:
         usage = message.get("usage")
         if isinstance(usage, dict) and self._final_obj is None:
             self._final_obj = {"usage": usage}
-        # Skip synthetic "Not logged in" messages — Claude Code emits
-        # them with ``error=authentication_failed`` and a placeholder
-        # text block. Surface as an APIError-friendly error event so
-        # callers raise instead of returning empty output.
-        # (Detected on the outer ``line``, but ``message`` is the
-        # carrier so we pass it through unchanged here.)
+
+        already_streamed = bool(self._text_buf) or bool(self._thinking_buf)
 
         events: List[Dict[str, Any]] = []
         content = message.get("content") or []
@@ -741,11 +895,15 @@ class StreamJsonAccumulator:
                 continue
             btype = str(block.get("type", ""))
             if btype == "text":
+                if already_streamed:
+                    continue
                 text = str(block.get("text", ""))
                 if text:
                     self._text_buf.append(text)
                     events.append({"type": "text_delta", "text": text})
             elif btype == "thinking":
+                if already_streamed:
+                    continue
                 # Anthropic uses ``thinking`` field; some shims use ``text``.
                 text = str(block.get("thinking") or block.get("text") or "")
                 if text:

{geny_executor-2.1.2 → geny_executor-2.1.4}/tests/llm_client/unit/test_anthropic_build_kwargs.py

@@ -165,8 +165,11 @@ def test_build_kwargs_keeps_sampling_params_when_thinking_absent() -> None:
 
 
 def test_build_kwargs_alias_resolution_and_thinking_drop_together() -> None:
-    """The two fixes are independent — combining them shouldn't trip
-    either path. This is the configuration Geny's VTuber env hits."""
+    """All three fixes layered: alias → canonical (2.1.1),
+    unconditional temperature drop (2.1.2), thinking shape migration
+    (2.1.3). This is the exact configuration Geny's VTuber env hits —
+    pinning ``opus`` with thinking enabled, the legacy v1
+    budget_tokens shape, and an explicit ``temperature``."""
     client = AnthropicClient(api_key="sk-mock")
     kwargs = client._build_kwargs(_req(
         model="opus",
@@ -175,7 +178,11 @@ def test_build_kwargs_alias_resolution_and_thinking_drop_together() -> None:
     ))
     assert kwargs["model"] == "claude-opus-4-7"
     assert "temperature" not in kwargs
-    assert kwargs["thinking"]["budget_tokens"] == 12000
+    # Opus 4.7 demands ``adaptive``; the migration drops the now-
+    # invalid ``budget_tokens`` (the API rejects it under adaptive
+    # as ``thinking.adaptive.budget_tokens: Extra inputs are not
+    # permitted``).
+    assert kwargs["thinking"] == {"type": "adaptive"}
 
 
 # ── 2.1.2 — Opus 4.7 unconditional sampling-param rejection ───────
@@ -319,3 +326,135 @@ def test_retry_kwargs_returns_none_when_field_already_absent() -> None:
 
     kwargs = {"model": "claude-x", "max_tokens": 100}
     assert _retry_kwargs_after_deprecation(kwargs, _Fake400()) is None
+
+
+# ── 2.1.3 — Opus 4.7 thinking.type=enabled → adaptive migration ───
+
+
+from geny_executor.llm_client.anthropic import (
+    _model_requires_adaptive_thinking,
+    _translate_thinking_to_adaptive,
+)
+
+
+def test_model_requires_adaptive_thinking_for_opus_4_7():
+    assert _model_requires_adaptive_thinking("claude-opus-4-7") is True
+    assert _model_requires_adaptive_thinking("claude-opus-4-7-20260101") is True
+
+
+@pytest.mark.parametrize(
+    "model",
+    ["claude-sonnet-4-6", "claude-haiku-4-5-20251001", "claude-opus-4-6"],
+)
+def test_model_requires_adaptive_thinking_false_for_v1_models(model: str) -> None:
+    assert _model_requires_adaptive_thinking(model) is False
+
+
+def test_translate_thinking_to_adaptive_flips_type_and_drops_budget():
+    out = _translate_thinking_to_adaptive(
+        {"type": "enabled", "budget_tokens": 4096},
+    )
+    assert out == {"type": "adaptive"}
+
+
+def test_translate_thinking_to_adaptive_preserves_unrelated_keys():
+    out = _translate_thinking_to_adaptive(
+        {"type": "enabled", "budget_tokens": 4096, "display": "summarized"},
+    )
+    assert out == {"type": "adaptive", "display": "summarized"}
+
+
+def test_build_kwargs_translates_thinking_for_opus_4_7() -> None:
+    """The exact failure we hit on 2026-06-04: VTuber's memory stage
+    pinned Opus 4.7 via the router with the legacy enabled-shape
+    thinking dict, and Anthropic returned
+    ``thinking.type.enabled is not supported for this model``."""
+    client = AnthropicClient(api_key="sk-mock")
+    kwargs = client._build_kwargs(_req(
+        model="claude-opus-4-7",
+        thinking={"type": "enabled", "budget_tokens": 8192},
+    ))
+    assert kwargs["thinking"] == {"type": "adaptive"}
+
+
+def test_build_kwargs_translates_thinking_after_alias_resolution() -> None:
+    """An env pinning the ``opus`` alias should also hit the
+    translation after the alias resolves to ``claude-opus-4-7``."""
+    client = AnthropicClient(api_key="sk-mock")
+    kwargs = client._build_kwargs(_req(
+        model="opus",
+        thinking={"type": "enabled", "budget_tokens": 4096},
+    ))
+    assert kwargs["model"] == "claude-opus-4-7"
+    assert kwargs["thinking"] == {"type": "adaptive"}
+
+
+def test_build_kwargs_does_not_translate_for_sonnet_4_6() -> None:
+    """Regression — only Opus 4.7 (and prefix variants) demand
+    ``adaptive``. Sonnet / Haiku still accept ``enabled``."""
+    client = AnthropicClient(api_key="sk-mock")
+    kwargs = client._build_kwargs(_req(
+        model="claude-sonnet-4-6",
+        thinking={"type": "enabled", "budget_tokens": 4096},
+    ))
+    assert kwargs["thinking"] == {"type": "enabled", "budget_tokens": 4096}
+
+
+def test_build_kwargs_leaves_adaptive_thinking_alone() -> None:
+    """If the caller already shipped ``adaptive``, don't reshape it."""
+    client = AnthropicClient(api_key="sk-mock")
+    kwargs = client._build_kwargs(_req(
+        model="claude-opus-4-7",
+        thinking={"type": "adaptive"},
+    ))
+    assert kwargs["thinking"] == {"type": "adaptive"}
+
+
+def test_build_kwargs_full_opus_combo() -> None:
+    """The full failure path the VTuber session hit: Opus 4.7 +
+    temperature + thinking.type=enabled + budget_tokens. All three
+    fixes (alias, sampling-param drop, thinking migration) layer
+    cleanly on the same call."""
+    client = AnthropicClient(api_key="sk-mock")
+    kwargs = client._build_kwargs(_req(
+        model="opus",
+        temperature=0.0,
+        thinking={"type": "enabled", "budget_tokens": 4096},
+    ))
+    assert kwargs["model"] == "claude-opus-4-7"
+    assert "temperature" not in kwargs
+    assert kwargs["thinking"] == {"type": "adaptive"}
+
+
+# ── 2.1.3 — Retry self-heals the thinking migration too ───────────
+
+
+def test_retry_kwargs_self_heals_thinking_enabled_400() -> None:
+    """An env shipping ``thinking.type=enabled`` against a future
+    adaptive-only model the prefix list doesn't know yet — the API
+    will tell us via the 400, and the retry path self-heals."""
+    class _Fake400:
+        message = (
+            '"thinking.type.enabled" is not supported for this model. '
+            'Use "thinking.type.adaptive" and "output_config.effort"'
+        )
+
+    kwargs = {
+        "model": "claude-future-thinking-v2",
+        "messages": [{"role": "user", "content": "x"}],
+        "max_tokens": 1024,
+        "thinking": {"type": "enabled", "budget_tokens": 2048},
+    }
+    retry = _retry_kwargs_after_deprecation(kwargs, _Fake400())
+    assert retry is not None
+    assert retry["thinking"] == {"type": "adaptive"}
+
+
+def test_retry_kwargs_returns_none_when_thinking_already_adaptive() -> None:
+    """If the request was already adaptive, the 400 message about
+    enabled must not trigger a useless retry."""
+    class _Fake400:
+        message = '"thinking.type.enabled" is not supported for this model.'
+
+    kwargs = {"model": "claude-x", "thinking": {"type": "adaptive"}, "max_tokens": 100}
+    assert _retry_kwargs_after_deprecation(kwargs, _Fake400()) is None