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

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

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

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

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

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

@@ -77,6 +77,80 @@ _THINKING_INCOMPATIBLE_SAMPLING_KEYS: tuple[str, ...] = (
 )
 
 
+# ── Models that reject sampling params unconditionally ──────────────
+#
+# Some models (currently the Opus 4.7 family — the only one verified
+# against the live API in 2.1.2) reject ``temperature`` regardless of
+# whether ``thinking`` is set. The error reads
+# ``temperature is deprecated for this model.`` from
+# ``api.anthropic.com``. The model is designed around fixed-sampler
+# inference; the sampling kwargs become noise the API explicitly
+# refuses.
+#
+# The set is keyed by the **resolved** canonical ID (so aliases get
+# expanded first, see ``_resolve_anthropic_model``). Match is
+# prefix-based — ``"claude-opus-4-7"`` covers any future
+# ``claude-opus-4-7-20yyyymmdd`` pinned variant without needing an
+# update here.
+#
+# AdaptiveModelRouter auto-promotes to Opus when ``thinking_enabled``
+# is True (see ``stages/s06_api/artifact/default/router.py``), so an
+# env that never sees Opus in its config can still hit this code
+# path indirectly. The drop has to live at the boundary, not the
+# router.
+_TEMPERATURE_DEPRECATED_PREFIXES: tuple[str, ...] = (
+    "claude-opus-4-7",
+)
+
+
+def _model_rejects_sampling_params(model: str) -> bool:
+    """True iff ``model`` (canonical ID) belongs to a family that
+    unconditionally rejects ``temperature``/``top_p``/``top_k``."""
+    return any(
+        model.startswith(prefix) for prefix in _TEMPERATURE_DEPRECATED_PREFIXES
+    )
+
+
+# ── Last-line retry on a deprecation 400 ────────────────────────────
+#
+# Future Anthropic releases will deprecate more sampling params for
+# more models; the static prefix list above will go stale. When the
+# API surfaces the deprecation error we strip the offending field
+# and retry once. Captures the same exact 400 strings Anthropic emits
+# (sometimes wrapped in backticks, sometimes not).
+_DEPRECATION_MSG_TO_KWARG_KEY: Dict[str, str] = {
+    "temperature is deprecated": "temperature",
+    "`temperature` is deprecated": "temperature",
+    "top_p is deprecated": "top_p",
+    "`top_p` is deprecated": "top_p",
+    "top_k is deprecated": "top_k",
+    "`top_k` is deprecated": "top_k",
+}
+
+
+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.
+    """
+    msg = str(getattr(exc, "message", "") or exc)
+    msg_lower = msg.lower()
+    for needle, key in _DEPRECATION_MSG_TO_KWARG_KEY.items():
+        if needle in msg_lower and key in kwargs:
+            retry = dict(kwargs)
+            retry.pop(key, None)
+            return retry
+    return None
+
+
 class AnthropicClient(BaseClient):
     """Real Anthropic API client using the official SDK."""
 
@@ -138,6 +212,26 @@ class AnthropicClient(BaseClient):
             raw_response = await client.messages.create(**kwargs)
             return self._parse_response(raw_response)
         except Exception as e:
+            # Retry-on-deprecation safety net. The static prefix list
+            # in ``_TEMPERATURE_DEPRECATED_PREFIXES`` will go stale as
+            # Anthropic deprecates more sampling params for more
+            # models. When the API explicitly tells us a sampling
+            # param is the problem, strip it and retry once. Beats
+            # a hard error on a model whose prefix we don't know yet.
+            retry_kwargs = _retry_kwargs_after_deprecation(kwargs, e)
+            if retry_kwargs is not None:
+                logger.info(
+                    "anthropic: retrying %s after deprecation 400 with "
+                    "%r dropped (model=%r)",
+                    purpose or "messages.create",
+                    sorted(set(kwargs) - set(retry_kwargs)),
+                    retry_kwargs.get("model"),
+                )
+                try:
+                    raw_response = await client.messages.create(**retry_kwargs)
+                    return self._parse_response(raw_response)
+                except Exception as inner:
+                    raise self._classify_error(inner) from inner
             raise self._classify_error(e) from e
 
     async def create_message_stream(
@@ -176,6 +270,32 @@ class AnthropicClient(BaseClient):
                     "response": self._parse_response(final),
                 }
         except Exception as e:
+            # Same retry-on-deprecation safety net as ``_send``. The
+            # SDK validates kwargs eagerly inside the ``stream``
+            # context manager, so the deprecation 400 surfaces before
+            # any tokens reach the caller — safe to retry once with
+            # the offending field dropped.
+            retry_kwargs = _retry_kwargs_after_deprecation(kwargs, e)
+            if retry_kwargs is not None:
+                logger.info(
+                    "anthropic: retrying %s after deprecation 400 with "
+                    "%r dropped (model=%r)",
+                    purpose or "messages.stream",
+                    sorted(set(kwargs) - set(retry_kwargs)),
+                    retry_kwargs.get("model"),
+                )
+                try:
+                    async with client.messages.stream(**retry_kwargs) as stream:
+                        async for text in stream.text_stream:
+                            yield {"type": "text_delta", "text": text}
+                        final = await stream.get_final_message()
+                        yield {
+                            "type": "message_complete",
+                            "response": self._parse_response(final),
+                        }
+                    return
+                except Exception as inner:
+                    raise self._classify_error(inner) from inner
             raise self._classify_error(e) from e
 
     def _build_kwargs(self, request: APIRequest) -> Dict[str, Any]:
@@ -232,6 +352,21 @@ class AnthropicClient(BaseClient):
                         key, dropped,
                     )
 
+        # Model-level unconditional rejection — see
+        # ``_TEMPERATURE_DEPRECATED_PREFIXES`` at module top. Opus 4.7
+        # refuses ``temperature`` regardless of whether ``thinking`` is
+        # set; without this drop, ``AdaptiveModelRouter`` promoting a
+        # thinking-enabled call to Opus 4.7 would still 400.
+        if _model_rejects_sampling_params(resolved_model):
+            for key in _THINKING_INCOMPATIBLE_SAMPLING_KEYS:
+                if key in kwargs:
+                    dropped = kwargs.pop(key)
+                    logger.info(
+                        "anthropic: dropped %r=%r — model %r refuses "
+                        "this sampling param unconditionally",
+                        key, dropped, resolved_model,
+                    )
+
         return kwargs
 
     def _parse_response(self, raw: Any) -> APIResponse:

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

@@ -27,7 +27,10 @@ import pytest
 from geny_executor.llm_client.anthropic import (
     AnthropicClient,
     _ANTHROPIC_MODEL_ALIASES,
+    _TEMPERATURE_DEPRECATED_PREFIXES,
+    _model_rejects_sampling_params,
     _resolve_anthropic_model,
+    _retry_kwargs_after_deprecation,
 )
 from geny_executor.llm_client.types import APIRequest
 
@@ -173,3 +176,146 @@ 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
+
+
+# ── 2.1.2 — Opus 4.7 unconditional sampling-param rejection ───────
+
+
+def test_model_rejects_sampling_params_for_opus_4_7():
+    assert _model_rejects_sampling_params("claude-opus-4-7") is True
+
+
+def test_model_rejects_sampling_params_for_dated_opus_4_7_variant():
+    """Prefix match covers future pinned variants without a code
+    change — ``claude-opus-4-7-20yyyymmdd`` for any date."""
+    assert _model_rejects_sampling_params("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_rejects_sampling_params_false_for_non_opus_4_7(model: str) -> None:
+    assert _model_rejects_sampling_params(model) is False
+
+
+def test_build_kwargs_drops_temperature_for_opus_4_7_without_thinking() -> None:
+    """The big one for 2.1.2 — Opus 4.7 refuses temperature
+    regardless of whether ``thinking`` is set. AdaptiveModelRouter
+    auto-promotes thinking calls to Opus, but a plain call to Opus
+    (e.g. memory_distill) must also drop temperature."""
+    client = AnthropicClient(api_key="sk-mock")
+    kwargs = client._build_kwargs(_req(
+        model="claude-opus-4-7",
+        temperature=0.0,
+        # no thinking
+    ))
+    assert "temperature" not in kwargs
+    assert kwargs["model"] == "claude-opus-4-7"
+
+
+def test_build_kwargs_drops_all_three_for_opus_4_7() -> None:
+    client = AnthropicClient(api_key="sk-mock")
+    kwargs = client._build_kwargs(_req(
+        model="claude-opus-4-7",
+        temperature=0.5,
+        top_p=0.9,
+        top_k=20,
+    ))
+    for blocked in ("temperature", "top_p", "top_k"):
+        assert blocked not in kwargs
+
+
+def test_build_kwargs_drops_temperature_after_alias_resolves_to_opus_4_7() -> None:
+    """An env that pins ``opus`` (alias) should drop temperature
+    after resolution to the canonical ``claude-opus-4-7``."""
+    client = AnthropicClient(api_key="sk-mock")
+    kwargs = client._build_kwargs(_req(
+        model="opus",
+        temperature=0.2,
+    ))
+    assert kwargs["model"] == "claude-opus-4-7"
+    assert "temperature" not in kwargs
+
+
+def test_sonnet_4_6_keeps_temperature_when_no_thinking() -> None:
+    """Regression — only Opus 4.7 (and prefix variants) belong in
+    ``_TEMPERATURE_DEPRECATED_PREFIXES``. Sonnet / Haiku still accept
+    temperature."""
+    client = AnthropicClient(api_key="sk-mock")
+    kwargs = client._build_kwargs(_req(
+        model="claude-sonnet-4-6",
+        temperature=0.7,
+    ))
+    assert kwargs["temperature"] == 0.7
+
+
+# ── 2.1.2 — Retry-on-deprecation safety net ───────────────────────
+
+
+def test_retry_kwargs_strips_temperature_on_known_400_message() -> None:
+    """The exact phrasing Anthropic sent on 2026-06-04 for Opus 4.7."""
+    class _Fake400:
+        message = (
+            "Error code: 400 - {'type': 'error', 'error': {'type': "
+            "'invalid_request_error', 'message': "
+            "'temperature is deprecated for this model.'}}"
+        )
+
+    kwargs = {
+        "model": "claude-opus-4-7",
+        "messages": [{"role": "user", "content": "x"}],
+        "max_tokens": 1024,
+        "temperature": 0.0,
+    }
+    retry = _retry_kwargs_after_deprecation(kwargs, _Fake400())
+    assert retry is not None
+    assert "temperature" not in retry
+    # Other fields survive
+    assert retry["model"] == "claude-opus-4-7"
+    assert retry["max_tokens"] == 1024
+
+
+def test_retry_kwargs_strips_backticked_field_name() -> None:
+    """Some Anthropic error payloads wrap the field name in
+    backticks (``\`temperature\` is deprecated``)."""
+    class _Fake400:
+        message = "`temperature` is deprecated for this model."
+
+    kwargs = {"model": "claude-opus-4-7", "temperature": 0.5, "max_tokens": 100}
+    retry = _retry_kwargs_after_deprecation(kwargs, _Fake400())
+    assert retry is not None
+    assert "temperature" not in retry
+
+
+def test_retry_kwargs_strips_top_p_when_that_is_the_deprecation() -> None:
+    class _Fake400:
+        message = "top_p is deprecated for this model."
+
+    kwargs = {"model": "claude-x", "top_p": 0.9, "temperature": 0.5, "max_tokens": 100}
+    retry = _retry_kwargs_after_deprecation(kwargs, _Fake400())
+    assert retry is not None
+    assert "top_p" not in retry
+    # Other sampling params survive — only the field named in the
+    # error message gets stripped.
+    assert retry["temperature"] == 0.5
+
+
+def test_retry_kwargs_returns_none_for_unrelated_error() -> None:
+    """Non-deprecation errors must not trigger the retry path —
+    let the caller re-raise with the original classification."""
+    class _SomeOther:
+        message = "rate limit exceeded"
+
+    kwargs = {"model": "claude-x", "temperature": 0.5, "max_tokens": 100}
+    assert _retry_kwargs_after_deprecation(kwargs, _SomeOther()) is None
+
+
+def test_retry_kwargs_returns_none_when_field_already_absent() -> None:
+    """Deprecation said temperature, but kwargs doesn't have it —
+    nothing to strip, so don't loop."""
+    class _Fake400:
+        message = "temperature is deprecated for this model."
+
+    kwargs = {"model": "claude-x", "max_tokens": 100}
+    assert _retry_kwargs_after_deprecation(kwargs, _Fake400()) is None