geny-executor 2.71.0__tar.gz → 2.72.1__tar.gz

{geny_executor-2.71.0 → geny_executor-2.72.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: geny-executor
-Version: 2.71.0
+Version: 2.72.1
 Summary: Harness-engineered agent pipeline library — one 21-stage architecture, many model accounts behind one conversation
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.71.0 → geny_executor-2.72.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.71.0"
+version = "2.72.1"
 description = "Harness-engineered agent pipeline library — one 21-stage architecture, many model accounts behind one conversation"
 readme = "README.md"
 license = "Apache-2.0"

{geny_executor-2.71.0 → geny_executor-2.72.1}/src/geny_executor/core/pipeline.py

@@ -148,6 +148,12 @@ def _creds_to_client_kwargs(provider: str, creds: ProviderCredentials) -> Dict[s
             kwargs["base_url"] = creds.base_url
         if creds.default_headers is not None:
             kwargs["default_headers"] = dict(creds.default_headers)
+        # vLLM's defaults are the safe floor (no tools, no vision) because
+        # those depend on the model the server loaded, which only the
+        # deployment knows. ``extras["capabilities"]`` is how it says.
+        overrides = (creds.extras or {}).get("capabilities")
+        if isinstance(overrides, Mapping):
+            kwargs["capabilities"] = dict(overrides)
         return kwargs
 
     # API providers (anthropic / openai / google)

{geny_executor-2.71.0 → geny_executor-2.72.1}/src/geny_executor/llm_client/base.py

@@ -25,8 +25,17 @@ from __future__ import annotations
 
 import logging
 from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional
+from dataclasses import dataclass, field, replace as _dc_replace
+from typing import (
+    Any,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+)
 
 from geny_executor.core.config import ModelConfig
 from geny_executor.core.errors import APIError, ErrorCategory
@@ -156,6 +165,62 @@ class BaseClient(ABC):
         self._default_headers = default_headers
         self._event_sink = event_sink
 
+    # ── Capability negotiation ──────────────────────────────────────────
+
+    def configure_capabilities(self, **overrides: Any) -> None:
+        """Amend this INSTANCE's capability flags for the model it reaches.
+
+        A class declares what its *wire format* can express; only the
+        deployment knows what the *served model* actually does. One vLLM
+        endpoint runs a tool-calling model and the next one does not; one
+        OpenAI-compatible base_url is a laptop's llama.cpp and the next is
+        an aggregator fronting frontier models. So the flags are settable
+        per instance rather than per class::
+
+            client.configure_capabilities(supports_tools=True,
+                                          supports_tool_choice=True)
+
+        ``capabilities.drops`` is read against these upgraded flags (see
+        :meth:`_apply_declared_drops`), so an upgrade really does let the
+        field reach the server — the drops tuple needs no rewriting.
+        """
+        # type-ignore: dataclasses.replace stubs cannot type heterogeneous
+        # **kwargs against the per-field types; the dataclass validates at
+        # construction.
+        self.capabilities = _dc_replace(self.capabilities, **overrides)  # type: ignore[arg-type]
+
+    def apply_capability_overrides(self, overrides: Optional[Mapping[str, Any]]) -> None:
+        """Apply a HOST-supplied capability declaration, ignoring unknowns.
+
+        Separate from :meth:`configure_capabilities` because the input is
+        untrusted: it arrives from an account row or a manifest, where a
+        typo or a flag from a newer library version must not take down the
+        turn. Unknown keys are dropped with a log line instead of raising.
+        """
+        if not overrides:
+            return
+        known: Dict[str, Any] = {}
+        unknown: List[str] = []
+        for key, value in overrides.items():
+            if not hasattr(self.capabilities, key):
+                unknown.append(str(key))
+                continue
+            # Coerce against the CURRENT value's type, not a hard-coded
+            # field list: the flags are overwhelmingly booleans (and a JSON
+            # account row spells one "true"/1), while ``streaming_granularity``
+            # and ``drops`` are not — and a new non-bool field must not start
+            # silently arriving as ``True``.
+            current = getattr(self.capabilities, key)
+            known[key] = bool(value) if isinstance(current, bool) else value
+        if unknown:
+            logger.warning(
+                "%s: ignoring unknown capability override(s): %s",
+                self.provider or type(self).__name__,
+                ", ".join(sorted(unknown)),
+            )
+        if known:
+            self.configure_capabilities(**known)
+
     # ── High-level surface used by stages ───────────────────────────────
 
     async def create_message(
@@ -270,8 +335,26 @@ class BaseClient(ABC):
         if model_config.top_k is not None and not self.capabilities.supports_top_k:
             self._emit_unsupported("top_k")
 
+        # Tools negotiation. Until 2.72.1 a client that declared
+        # ``supports_tools=False`` still sent them: stripping was left to the
+        # ``drops`` tuple, and every shipped client that says no to tools also
+        # lists them there — so the hole was invisible until a DEPLOYMENT said
+        # no through ``capabilities=`` on a class whose tuple says nothing.
+        # That is a setting that does nothing, which is the one outcome a
+        # settings page must never have. The capability is authoritative here,
+        # exactly as it already is for top_k and stop_sequences.
+        if tools and not self.capabilities.supports_tools:
+            self._emit_unsupported("tools")
+            request.tools = None
+
         if tool_choice and not self.capabilities.supports_tool_choice:
             self._emit_unsupported("tool_choice")
+            request.tool_choice = None
+
+        # A tool_choice with no tools is a 400 on every backend that checks,
+        # so the two travel together whichever of them was dropped.
+        if request.tool_choice is not None and not request.tools:
+            request.tool_choice = None
 
         # Stop-sequences negotiation — clients that drop stop_sequences
         # signal it explicitly. (Not silently honored by all CLI backends.)
@@ -290,6 +373,12 @@ class BaseClient(ABC):
         return request
 
     # ── images a backend cannot see ──────────────────────────────────
+
+    #: What a lowered image leaves behind. A sentence, not an empty slot:
+    #: the model has to be able to tell "there was a picture I cannot see"
+    #: from "there was nothing here".
+    _IMAGE_PLACEHOLDER = "[an image was attached here; this model cannot see images]"
+
     def _lower_unseeable_images(self, request: APIRequest) -> None:
         """Replace image blocks this client cannot see with a note saying so.
 
@@ -305,39 +394,67 @@ class BaseClient(ABC):
           * say an image was here and could not be shown, which is what this
             does, alongside a ``llm_client.field_dropped`` event so the host
             can say so too.
+
+        Two places carry images and they are gated separately: a block on
+        the message itself (the user attached it) and a block nested inside
+        a ``tool_result`` (a tool returned it — a screenshot, a rendered
+        chart). Some backends take the first and reject the second, so
+        ``supports_vision_tool_results`` decides the nested ones.
         """
         caps = self.capabilities
         if caps.supports_vision and caps.supports_vision_tool_results:
             return
-
+        tool_results_ok = caps.supports_vision and caps.supports_vision_tool_results
+
+        # Copy-on-write, all the way down. ``request.messages`` is a SHALLOW
+        # copy of the caller's list, so editing a block in place would edit
+        # the pipeline's canonical history — and one turn on a text-only hop
+        # would destroy the image for every later turn, including the ones on
+        # a model that could have seen it. The degradation ends with this
+        # request.
         lowered = 0
-        for message in request.messages:
+        for position, message in enumerate(request.messages):
             content = message.get("content")
             if not isinstance(content, list):
                 continue
-            in_tool_result = any(
-                isinstance(b, dict) and b.get("type") == "tool_result" for b in content
-            )
-            allowed = (
-                caps.supports_vision and caps.supports_vision_tool_results
-                if in_tool_result
-                else caps.supports_vision
-            )
-            if allowed:
-                continue
-            replaced: list[Any] = []
+            replaced: List[Any] = []
+            changed = False
             for block in content:
-                if isinstance(block, dict) and block.get("type") == "image":
+                if not isinstance(block, dict):
+                    replaced.append(block)
+                    continue
+                btype = block.get("type")
+                if btype == "image" and not caps.supports_vision:
+                    replaced.append({"type": "text", "text": self._IMAGE_PLACEHOLDER})
                     lowered += 1
-                    replaced.append(
-                        {
-                            "type": "text",
-                            "text": "[an image was attached here; this model cannot see images]",
-                        }
-                    )
+                    changed = True
+                elif btype == "tool_result" and not tool_results_ok:
+                    inner = block.get("content")
+                    if not isinstance(inner, list):
+                        replaced.append(block)
+                        continue
+                    # An image a TOOL returned lives one level down, inside
+                    # the tool_result's own content list — which is why the
+                    # top-level scan alone would have found nothing to lower
+                    # on exactly the turn that needed it (a screenshot).
+                    inner_replaced: List[Any] = []
+                    inner_changed = False
+                    for inner_block in inner:
+                        if isinstance(inner_block, dict) and inner_block.get("type") == "image":
+                            inner_replaced.append({"type": "text", "text": self._IMAGE_PLACEHOLDER})
+                            lowered += 1
+                            inner_changed = True
+                        else:
+                            inner_replaced.append(inner_block)
+                    if inner_changed:
+                        replaced.append({**block, "content": inner_replaced})
+                        changed = True
+                    else:
+                        replaced.append(block)
                 else:
                     replaced.append(block)
-            message["content"] = replaced
+            if changed:
+                request.messages[position] = {**message, "content": replaced}
 
         if lowered:
             self._emit_unsupported("image")

{geny_executor-2.71.0 → geny_executor-2.72.1}/src/geny_executor/llm_client/openai_compatible.py

@@ -24,8 +24,7 @@ from __future__ import annotations
 import json
 import logging
 import re
-from dataclasses import replace
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Mapping, Optional
 
 from geny_executor.llm_client.openai import OpenAIClient
 from geny_executor.llm_client.profiles import (
@@ -108,6 +107,7 @@ class OpenAICompatibleClient(OpenAIClient):
         event_sink: Optional[Any] = None,
         num_ctx: Optional[int] = None,
         think: Optional[bool] = None,
+        capabilities: Optional[Mapping[str, Any]] = None,
     ) -> None:
         profile = self._profile
         resolved_base_url = base_url or profile.default_base_url
@@ -126,23 +126,13 @@ class OpenAICompatibleClient(OpenAIClient):
         )
         self._num_ctx = num_ctx
         self._think = think
-
-    def configure_capabilities(self, **overrides: bool) -> None:
-        """Upgrade/downgrade capability flags for the deployed model.
-
-        A local endpoint serving a model without tool support opts out::
-
-            client.configure_capabilities(supports_tools=False,
-                                           supports_tool_choice=False)
-
-        ``capabilities.drops`` is interpreted against the upgraded flags
-        (see ``BaseClient._apply_declared_drops``), so toggling
-        ``supports_tools`` really does gate whether ``tools`` reach the
-        server — no need to rewrite the drops tuple here.
-        """
-        # type-ignore: dataclasses.replace stubs can't type heterogeneous
-        # **kwargs; the dataclass validates values at construction.
-        self.capabilities = replace(self.capabilities, **overrides)  # type: ignore[arg-type]
+        # What one OpenAI-compatible endpoint can do is not what another can:
+        # this class serves a keyless llama.cpp on a laptop AND a cloud
+        # aggregator routing to frontier models. Vision, tools and structured
+        # output are properties of the SERVED MODEL, so the account that knows
+        # which endpoint this is gets to say (see
+        # ``BaseClient.apply_capability_overrides``).
+        self.apply_capability_overrides(capabilities)
 
     def _parse_tool_arguments(self, raw: Any) -> Any:
         """Strict parse, then repair the malformed JSON local servers emit.

{geny_executor-2.71.0 → geny_executor-2.72.1}/src/geny_executor/llm_client/profiles.py

@@ -205,6 +205,9 @@ def profiled_client_kwargs(name: str, creds: Any) -> Dict[str, Any]:
       the requested context window.
     * ``think`` — from ``extras["think"]``; becomes ``extra_body.think``
       (Ollama's native reasoning toggle).
+    * ``capabilities`` — from ``extras["capabilities"]``; capability flags
+      the ACCOUNT declares about its endpoint (vision above all), because
+      one class serves both a laptop's llama.cpp and a cloud aggregator.
 
     Pure: imports nothing from the SDK path. ``creds`` is a
     ``ProviderCredentials`` (typed ``Any`` to avoid a circular import).
@@ -224,6 +227,13 @@ def profiled_client_kwargs(name: str, creds: Any) -> Dict[str, Any]:
     think = extras.get("think")
     if think is not None:
         kwargs["think"] = bool(think)
+    overrides = extras.get("capabilities")
+    if isinstance(overrides, Mapping):
+        # The account's own declaration of what its endpoint serves. An
+        # aggregator routing to frontier models can see images; the
+        # llama.cpp build on a laptop usually cannot, and only the account
+        # knows which one this is.
+        kwargs["capabilities"] = dict(overrides)
     return kwargs
 
 

{geny_executor-2.71.0 → geny_executor-2.72.1}/src/geny_executor/llm_client/responses_wire.py

@@ -22,6 +22,7 @@ a reasoning agent is not a trade worth making.
 from __future__ import annotations
 
 import hashlib
+import contextlib
 import json
 import time
 import uuid
@@ -358,13 +359,14 @@ class ResponsesClient(BaseClient):
                         continue
                     if resp.status_code != 200:
                         raw = (await resp.aread()).decode("utf-8", "replace")
-                        raise self._http_error(resp.status_code, raw)
+                        raise self._http_error(resp.status_code, raw, resp.headers)
                     async for chunk in self._consume(resp, started):
                         yield chunk
                     return
 
-    def _http_error(self, status: int, raw: str) -> APIError:
+    def _http_error(self, status: int, raw: str, headers: Any = None) -> APIError:
         detail = raw
+        retry_after: Optional[float] = None
         try:
             data = json.loads(raw)
             err = data.get("error") if isinstance(data, dict) else None
@@ -372,6 +374,11 @@ class ResponsesClient(BaseClient):
                 detail = str(err.get("message") or err.get("code") or raw)
                 if err.get("resets_in_seconds"):
                     self._notify_host({"kind": "rate_limit", "info": err})
+                    # …and keep it: this is the provider saying exactly when
+                    # the account is usable again, which beats benching it
+                    # for a flat fifteen minutes in both directions.
+                    with contextlib.suppress(TypeError, ValueError):
+                        retry_after = float(err["resets_in_seconds"])
             elif isinstance(data, dict) and data.get("detail"):
                 detail = str(data["detail"])
         except Exception:  # noqa: BLE001 — a non-JSON body is the message
@@ -380,11 +387,21 @@ class ResponsesClient(BaseClient):
         category = classify_text(detail, status)
         if status == 400 and "usage" in detail.lower() and "limit" in detail.lower():
             category = ErrorCategory.RATE_LIMITED
-        return APIError(
+        if retry_after is None and headers is not None:
+            with contextlib.suppress(AttributeError, TypeError, ValueError):
+                header = headers.get("retry-after")
+                if header is not None:
+                    retry_after = float(header)
+        error = APIError(
             f"{self.label}{label} HTTP {status}: {detail[:600]}",
             category=category,
             status_code=status,
         )
+        if retry_after is not None and retry_after > 0:
+            # Read by the router to size the bench. Carried on the error
+            # rather than only in the text so it survives re-wording.
+            error.retry_after = retry_after  # type: ignore[attr-defined]
+        return error
 
     async def _consume(self, resp: httpx.Response, started: float) -> AsyncIterator[Dict[str, Any]]:
         text_parts: list[str] = []

{geny_executor-2.71.0 → geny_executor-2.72.1}/src/geny_executor/llm_client/router.py

@@ -32,6 +32,24 @@ from geny_executor.llm_client.types import APIRequest, APIResponse
 _CONTENT = {"text_delta", "thinking_delta", "tool_use", "input_json_delta"}
 
 
+def _retry_fields(exc: BaseException) -> dict[str, Any]:
+    """What the provider said about coming back, off the exception.
+
+    Clients that get a machine-readable answer — Codex's
+    ``resets_in_seconds``, a ``Retry-After`` header — attach it here rather
+    than only wording it into the message, so re-wording the message cannot
+    quietly turn the hint back into a guess.
+    """
+    fields: dict[str, Any] = {}
+    retry_after = getattr(exc, "retry_after", None)
+    if retry_after is not None:
+        fields["retry_after"] = retry_after
+    reset_at = getattr(exc, "reset_at", None)
+    if reset_at is not None:
+        fields["reset_at"] = reset_at
+    return fields
+
+
 def _label(target: dict[str, Any]) -> str:
     return f"{target.get('label') or target.get('kind')}·{target.get('model')}"
 
@@ -241,7 +259,7 @@ class RouterClient(BaseClient):
         # When the provider says when to come back, believe it. A flat bench
         # is a guess in both directions: too short and the next turn walks
         # into the same wall, too long and a recovered account sits idle.
-        until = failover.reset_at_from(detail, fields=getattr(exc, "fields", None))
+        until = failover.reset_at_from(detail, fields=_retry_fields(exc))
 
         provider = str(target.get("engineProvider") or "")
         if (

{geny_executor-2.71.0 → geny_executor-2.72.1}/src/geny_executor/llm_client/vllm.py

@@ -6,14 +6,13 @@ adapter is identical; the differences are:
 - ``provider = "vllm"``
 - a required ``base_url`` (no public SaaS endpoint)
 - conservative default capabilities (tool-calling depends on the
-  serving model; override via :meth:`VLLMClient.configure_capabilities`
-  if the deployed model supports it)
+  serving model, so the deployment declares it: ``capabilities=`` at
+  construction, or :meth:`BaseClient.configure_capabilities` later)
 """
 
 from __future__ import annotations
 
-from dataclasses import replace
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Mapping, Optional
 
 from geny_executor.llm_client.base import ClientCapabilities
 from geny_executor.llm_client.openai import OpenAIClient
@@ -49,6 +48,7 @@ class VLLMClient(OpenAIClient):
         base_url: Optional[str] = None,
         default_headers: Optional[Dict[str, str]] = None,
         event_sink: Optional[Any] = None,
+        capabilities: Optional[Mapping[str, Any]] = None,
     ) -> None:
         if not base_url:
             raise ValueError(
@@ -61,23 +61,8 @@ class VLLMClient(OpenAIClient):
             default_headers=default_headers,
             event_sink=event_sink,
         )
-
-    def configure_capabilities(self, **overrides: bool) -> None:
-        """Upgrade the client's capability flags when the deployed model supports them.
-
-        Example: a vLLM instance running a tool-call-capable model can opt in::
-
-            client = VLLMClient(base_url=...)
-            client.configure_capabilities(supports_tools=True, supports_tool_choice=True)
-
-        The declared ``drops`` tuple is interpreted against the upgraded
-        flags: the drop application skips any field whose matching
-        ``supports_*`` flag is True on the instance (see
-        ``BaseClient._apply_declared_drops``), so the opt-in above
-        really does let ``tools`` / ``tool_choice`` reach the server —
-        no need to rewrite ``drops`` here.
-        """
-        # type-ignore: dataclasses.replace stubs can't type heterogeneous
-        # **kwargs against the per-field types; values are validated by
-        # the dataclass itself at construction.
-        self.capabilities = replace(self.capabilities, **overrides)  # type: ignore[arg-type]
+        # What a vLLM server can do is a property of the model it loaded,
+        # not of vLLM: the same endpoint class serves a tool-calling
+        # Qwen-Coder and a plain text completion model. The defaults above
+        # are the safe floor; the deployment that knows better says so.
+        self.apply_capability_overrides(capabilities)