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

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

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

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

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

{geny_executor-2.1.2 → geny_executor-2.1.3}/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.3}/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