geny-executor 2.7.2__tar.gz → 2.9.0__tar.gz

{geny_executor-2.7.2 → geny_executor-2.9.0}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.7.2"
+version = "2.9.0"
 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.7.2 → geny_executor-2.9.0}/src/geny_executor/core/pipeline.py

@@ -114,6 +114,17 @@ def _creds_to_client_kwargs(provider: str, creds: ProviderCredentials) -> Dict[s
     Each provider's client takes a slightly different constructor surface;
     this is the single place those shapes are encoded.
     """
+    # Branded local (OpenAI-compatible) providers — ollama / lmstudio /
+    # custom (+ aliases). Their constructor takes base_url + the
+    # num_ctx / think wire knobs; the mapping lives next to the profiles.
+    from geny_executor.llm_client.profiles import (
+        is_profiled_provider,
+        profiled_client_kwargs,
+    )
+
+    if is_profiled_provider(provider):
+        return profiled_client_kwargs(provider, creds)
+
     if provider == "vllm":
         kwargs: Dict[str, Any] = {}
         if creds.api_key:

{geny_executor-2.7.2 → geny_executor-2.9.0}/src/geny_executor/events/catalog.py

@@ -245,6 +245,7 @@ class EventTypes(str, Enum):
     LLM_CLIENT_PARAMETER_DROPPED = "llm_client.parameter_dropped"
     LLM_CLIENT_DRIFT_HEALED = "llm_client.drift_healed"
     LLM_CLIENT_UNKNOWN_WIRE_SHAPE = "llm_client.unknown_wire_shape"
+    LLM_CLIENT_TOOL_ARGS_REPAIRED = "llm_client.tool_args_repaired"
 
 
 #: Field-level payload documentation, one entry per :class:`EventTypes`
@@ -785,6 +786,10 @@ PAYLOADS: Dict[EventTypes, Dict[str, str]] = {
         "malformed_line_count": "int",
         "cli_version": "str",
     },
+    EventTypes.LLM_CLIENT_TOOL_ARGS_REPAIRED: {
+        "provider": "str — local provider whose tool-call JSON was repaired",
+        "raw_length": "int — length of the malformed arguments string",
+    },
 }
 
 

{geny_executor-2.7.2 → geny_executor-2.9.0}/src/geny_executor/llm_client/__init__.py

@@ -14,6 +14,15 @@ from geny_executor.llm_client.credentials import (
     CredentialBundle,
     ProviderCredentials,
 )
+from geny_executor.llm_client.local_probe import (
+    probe_ollama_num_ctx,
+    resolve_local_context_window,
+)
+from geny_executor.llm_client.profiles import (
+    BUILTIN_PROFILES,
+    ProviderProfile,
+    builtin_profiles,
+)
 from geny_executor.llm_client.registry import ClientRegistry
 from geny_executor.llm_client.types import APIRequest, APIResponse, ContentBlock
 
@@ -22,6 +31,7 @@ __all__ = [
     "APIResponse",
     "AnthropicClient",
     "BaseClient",
+    "BUILTIN_PROFILES",
     "ClaudeCodeCLIClient",
     "ClientCapabilities",
     "ClientRegistry",
@@ -29,4 +39,8 @@ __all__ = [
     "ContentBlock",
     "CredentialBundle",
     "ProviderCredentials",
+    "ProviderProfile",
+    "builtin_profiles",
+    "probe_ollama_num_ctx",
+    "resolve_local_context_window",
 ]

geny_executor-2.9.0/src/geny_executor/llm_client/local_probe.py

@@ -0,0 +1,167 @@
+"""Context-window discovery for local LLM endpoints.
+
+The pipeline's ``context_window_budget`` (Stage-2 proactive compaction +
+Stage-4 ``TokenBudgetGuard``) defaults to 200_000 — correct for the frontier
+cloud models but disastrous for a local 8K-context model, where it means
+compaction never fires and the request overflows the server.
+
+This module discovers a local model's real context window so a host can set
+``context_window_budget`` to match. It is an explicit, host-driven utility
+(NOT auto-run during pipeline build): pipeline construction stays free of
+implicit network I/O, and the host decides when to pay the probe.
+
+Ollama exposes the window via its native ``/api/show`` endpoint (the
+OpenAI-compatible ``/v1`` surface does not), so the probe targets that.
+Everything here is best-effort: any failure (server down, unexpected shape,
+timeout) resolves to ``None`` and the caller keeps its existing budget.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Awaitable, Callable, Optional
+
+from geny_executor.llm_client.profiles import resolve_profile
+
+
+logger = logging.getLogger(__name__)
+
+#: ``async def transport(url, json_body) -> Optional[dict]`` — test hook to
+#: stub HTTP without a live server (mirrors the embedding clients' pattern).
+Transport = Callable[[str, dict], Awaitable[Optional[dict]]]
+
+_DEFAULT_TIMEOUT_S = 5.0
+
+
+def _ollama_native_root(base_url: str) -> str:
+    """``http://host:11434/v1`` → ``http://host:11434`` (native API root)."""
+    root = base_url.rstrip("/")
+    if root.endswith("/v1"):
+        root = root[: -len("/v1")].rstrip("/")
+    return root
+
+
+def _extract_num_ctx(body: Any) -> Optional[int]:
+    """Pull the context window out of an Ollama ``/api/show`` response.
+
+    Precedence mirrors Ollama itself: a Modelfile ``num_ctx`` parameter (the
+    window the model is actually *loaded* with) wins over the GGUF's trained
+    ``*.context_length`` (the maximum the weights support).
+    """
+    if not isinstance(body, dict):
+        return None
+
+    # 1) Modelfile parameter: ``parameters`` is a newline-delimited string
+    #    like ``"num_ctx 8192\nstop \"<|im_end|>\""``.
+    params = body.get("parameters")
+    if isinstance(params, str):
+        for line in params.splitlines():
+            parts = line.split()
+            if len(parts) >= 2 and parts[0] == "num_ctx":
+                try:
+                    return int(parts[1])
+                except ValueError:
+                    pass
+
+    # 2) GGUF metadata: ``model_info["<arch>.context_length"]``.
+    info = body.get("model_info")
+    if isinstance(info, dict):
+        arch = info.get("general.architecture")
+        if isinstance(arch, str):
+            val = info.get(f"{arch}.context_length")
+            if isinstance(val, int):
+                return val
+        # Architecture key absent/odd — accept any ``*.context_length`` int.
+        for key, val in info.items():
+            if key.endswith(".context_length") and isinstance(val, int):
+                return val
+
+    return None
+
+
+async def _post(
+    url: str, body: dict, transport: Optional[Transport], timeout: float
+) -> Optional[dict]:
+    if transport is not None:
+        return await transport(url, body)
+    try:
+        import httpx  # transitive via anthropic>=0.52
+    except ImportError:
+        logger.debug("local context probe: httpx unavailable; skipping")
+        return None
+    try:
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            resp = await client.post(url, json=body)
+    except httpx.HTTPError as exc:
+        logger.debug("local context probe: transport failure for %s: %s", url, exc)
+        return None
+    if resp.status_code != 200:
+        logger.debug("local context probe: HTTP %s from %s", resp.status_code, url)
+        return None
+    try:
+        return resp.json()
+    except ValueError:
+        return None
+
+
+async def probe_ollama_num_ctx(
+    base_url: str,
+    model: str,
+    *,
+    transport: Optional[Transport] = None,
+    timeout: float = _DEFAULT_TIMEOUT_S,
+) -> Optional[int]:
+    """Context window for *model* on an Ollama server, or ``None``.
+
+    Hits ``<base_url without /v1>/api/show`` with ``{"model": model}``.
+    Best-effort: returns ``None`` on any error so the caller falls back to
+    its configured ``context_window_budget``.
+    """
+    if not base_url or not model:
+        return None
+    url = f"{_ollama_native_root(base_url)}/api/show"
+    body = await _post(url, {"model": model}, transport, timeout)
+    num_ctx = _extract_num_ctx(body)
+    if num_ctx:
+        logger.debug("local context probe: %s @ %s → num_ctx=%d", model, url, num_ctx)
+    return num_ctx
+
+
+async def resolve_local_context_window(
+    provider: str,
+    base_url: str,
+    model: str,
+    *,
+    transport: Optional[Transport] = None,
+    timeout: float = _DEFAULT_TIMEOUT_S,
+) -> Optional[int]:
+    """Discover the context window for a profiled local *provider*, or ``None``.
+
+    Dispatches by profile: ``ollama`` (incl. a ``custom``/``local`` endpoint
+    the host knows points at Ollama — pass ``provider="ollama"`` for those)
+    probes ``/api/show``. Non-Ollama profiles return ``None`` today (LM Studio
+    has no comparable metadata endpoint); the signature is the stable
+    extension point as more probes are added.
+
+    Hosts use the result to set ``PipelineConfig.context_window_budget`` so a
+    small local model gets correctly-sized compaction instead of the 200_000
+    cloud default.
+    """
+    if not provider:
+        return None
+    try:
+        profile = resolve_profile(provider)
+    except ValueError:
+        return None
+    if not profile.is_local:
+        return None
+    if profile.name == "ollama":
+        return await probe_ollama_num_ctx(base_url, model, transport=transport, timeout=timeout)
+    return None
+
+
+__all__ = [
+    "Transport",
+    "probe_ollama_num_ctx",
+    "resolve_local_context_window",
+]

{geny_executor-2.7.2 → geny_executor-2.9.0}/src/geny_executor/llm_client/openai.py

@@ -254,10 +254,7 @@ class OpenAIClient(BaseClient):
                 )
             )
         for tc in accumulated_tool_calls.values():
-            try:
-                tool_input = json.loads(tc["arguments"])
-            except (json.JSONDecodeError, TypeError):
-                tool_input = {}
+            tool_input = self._parse_tool_arguments(tc["arguments"])
             blocks.append(
                 ContentBlock(
                     type="tool_use",
@@ -339,10 +336,7 @@ class OpenAIClient(BaseClient):
 
         if choice.message.tool_calls:
             for tc in choice.message.tool_calls:
-                try:
-                    tool_input = json.loads(tc.function.arguments)
-                except (json.JSONDecodeError, TypeError):
-                    tool_input = {}
+                tool_input = self._parse_tool_arguments(tc.function.arguments)
                 blocks.append(
                     ContentBlock(
                         type="tool_use",
@@ -373,6 +367,22 @@ class OpenAIClient(BaseClient):
             raw=provenance,
         )
 
+    def _parse_tool_arguments(self, raw: Any) -> Any:
+        """Parse a tool-call ``arguments`` JSON string into Python.
+
+        Default: strict ``json.loads`` with a ``{}`` fallback — the OpenAI
+        SDK emits well-formed JSON, so nothing fancier is warranted. The
+        OpenAI-compatible *local* clients (Ollama / LM Studio / custom)
+        override this to repair the malformed JSON that local servers
+        commonly emit (trailing commas, ``None``/``True`` literals,
+        markdown fences) before giving up. Shared by the streaming and
+        non-streaming parse paths so the two can't drift.
+        """
+        try:
+            return json.loads(raw)
+        except (json.JSONDecodeError, TypeError):
+            return {}
+
     def _parse_usage(self, usage_data: Any) -> TokenUsage:
         """OpenAI usage object → canonical :class:`TokenUsage`.
 

geny_executor-2.9.0/src/geny_executor/llm_client/openai_compatible.py

@@ -0,0 +1,252 @@
+"""OpenAI-compatible (local) clients generated from :class:`ProviderProfile`.
+
+Each branded local backend (``ollama`` / ``lmstudio`` / ``custom``) is a
+thin :class:`~geny_executor.llm_client.openai.OpenAIClient` subclass that
+pulls its provider name + capabilities from a profile and adds the
+local-backend quirks:
+
+* resolve ``base_url`` from the profile default when the host gives none
+  (and raise when the profile requires one and none is resolvable);
+* default the API key to ``"EMPTY"`` so ``AsyncOpenAI`` constructs against
+  a keyless local server;
+* send a ``max_tokens`` floor so Ollama doesn't collapse to
+  ``num_predict=128`` and truncate;
+* thread ``num_ctx`` / ``think`` into ``extra_body`` (Ollama's native
+  context-window + reasoning toggles).
+
+This module is imported lazily (see
+:func:`geny_executor.llm_client.profiles.get_profiled_client_class`) so the
+SDK path is not pulled merely by registering these providers.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import replace
+from typing import Any, Dict, Optional
+
+from geny_executor.llm_client.openai import OpenAIClient
+from geny_executor.llm_client.profiles import (
+    CUSTOM_PROFILE,
+    LMSTUDIO_PROFILE,
+    OLLAMA_PROFILE,
+    ProviderProfile,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+# Trailing comma before a closing brace/bracket: ``{"a": 1,}`` / ``[1,]``.
+_TRAILING_COMMA_RE = re.compile(r",(\s*[}\]])")
+# Bare Python literals a non-OpenAI server may emit instead of JSON ones.
+# Word-boundaried so ``None``/``True``/``False`` inside string values are
+# left alone as much as a regex can manage (this is a last-resort repair,
+# only reached after strict parsing already failed).
+_PY_LITERALS_RE = re.compile(r"\b(None|True|False)\b")
+_PY_TO_JSON = {"None": "null", "True": "true", "False": "false"}
+
+
+def _repair_json(raw: str) -> Optional[Dict[str, Any]]:
+    """Best-effort repair of malformed tool-call argument JSON.
+
+    Handles the failure modes seen from local OpenAI-compatible servers
+    (Ollama / llama.cpp / GLM-family): markdown code fences, leading or
+    trailing prose around the object, trailing commas, and bare Python
+    literals (``None`` / ``True`` / ``False``). Returns the parsed object
+    on success or ``None`` when it still cannot be salvaged — never raises.
+    Only object (``dict``) results are accepted; a repaired scalar/list is
+    treated as unsalvageable for a tool-argument slot.
+    """
+    s = raw.strip()
+    if not s:
+        return None
+
+    # Strip a ```json … ``` (or bare ```) fence.
+    if s.startswith("```"):
+        s = re.sub(r"^```[a-zA-Z0-9_]*\s*", "", s)
+        s = re.sub(r"\s*```$", "", s).strip()
+
+    # If prose surrounds the object, isolate the outermost {...}.
+    first, last = s.find("{"), s.rfind("}")
+    candidate = s[first : last + 1] if 0 <= first < last else s
+
+    attempts = [
+        candidate,
+        _TRAILING_COMMA_RE.sub(r"\1", candidate),
+    ]
+    # Python-literal fix applied on top of the comma-stripped form.
+    attempts.append(_PY_LITERALS_RE.sub(lambda m: _PY_TO_JSON[m.group(0)], attempts[1]))
+
+    for attempt in attempts:
+        try:
+            parsed = json.loads(attempt)
+        except (json.JSONDecodeError, TypeError):
+            continue
+        if isinstance(parsed, dict):
+            return parsed
+    return None
+
+
+class OpenAICompatibleClient(OpenAIClient):
+    """Profile-driven OpenAI-compatible client. Subclasses bind ``_profile``."""
+
+    #: Bound by each concrete subclass below. The base class is never
+    #: registered/instantiated directly.
+    _profile: ProviderProfile
+
+    def __init__(
+        self,
+        api_key: str = "",
+        base_url: Optional[str] = None,
+        default_headers: Optional[Dict[str, str]] = None,
+        event_sink: Optional[Any] = None,
+        num_ctx: Optional[int] = None,
+        think: Optional[bool] = None,
+    ) -> None:
+        profile = self._profile
+        resolved_base_url = base_url or profile.default_base_url
+        if not resolved_base_url and profile.requires_base_url:
+            raise ValueError(
+                f"{profile.name!r} requires base_url (the OpenAI-compatible "
+                "server endpoint). Example: "
+                "base_url='http://localhost:8080/v1'"
+            )
+        # AsyncOpenAI rejects an empty api_key; local servers are keyless.
+        super().__init__(
+            api_key=api_key or "EMPTY",
+            base_url=resolved_base_url,
+            default_headers=default_headers,
+            event_sink=event_sink,
+        )
+        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]
+
+    def _parse_tool_arguments(self, raw: Any) -> Any:
+        """Strict parse, then repair the malformed JSON local servers emit.
+
+        Local OpenAI-compatible backends frequently return tool-call
+        arguments that ``json.loads`` rejects (trailing commas, ``None`` /
+        ``True`` literals, markdown fences). Rather than silently collapse
+        those to ``{}`` — which drops the model's real tool arguments and
+        looks like the model "called the tool with nothing" — try a
+        conservative repair first. A successful repair is reported (WARNING
+        + ``llm_client.tool_args_repaired`` event) so it stays visible
+        instead of masking a flaky server.
+        """
+        try:
+            return json.loads(raw)
+        except (json.JSONDecodeError, TypeError):
+            pass
+        if isinstance(raw, str):
+            repaired = _repair_json(raw)
+            if repaired is not None:
+                self._report_tool_args_repaired(raw)
+                return repaired
+        return {}
+
+    def _report_tool_args_repaired(self, raw: str) -> None:
+        logger.warning(
+            "%s: repaired malformed tool-call arguments from a local "
+            "server (%d chars). The model's JSON was not strictly valid; "
+            "a conservative repair recovered it.",
+            self.provider,
+            len(raw),
+        )
+        if self._event_sink is not None:
+            self._event_sink(
+                {
+                    "type": "llm_client.tool_args_repaired",
+                    "provider": self.provider,
+                    "raw_length": len(raw),
+                }
+            )
+
+    def _build_kwargs(self, request: Any) -> Dict[str, Any]:
+        """OpenAI kwargs + local quirks (token-cap floor, num_ctx, think)."""
+        kwargs = super()._build_kwargs(request)
+
+        # Token-cap floor: a missing/zero cap makes Ollama fall back to
+        # num_predict=128 and silently truncate. Only fills when neither
+        # token kwarg carries a positive value — an explicit small cap is
+        # the operator's choice and is honoured.
+        floor = self._profile.default_max_tokens
+        if floor and not kwargs.get("max_tokens") and not kwargs.get("max_completion_tokens"):
+            kwargs["max_tokens"] = floor
+
+        # num_ctx / think → extra_body (Ollama options + reasoning toggle).
+        # Emitted only when explicitly configured, so the default request
+        # is byte-identical to a plain OpenAI-compatible call and servers
+        # that don't read these fields are never sent surprising body keys.
+        extra_body: Dict[str, Any] = dict(kwargs.get("extra_body") or {})
+        if self._num_ctx is not None:
+            options = dict(extra_body.get("options") or {})
+            options.setdefault("num_ctx", self._num_ctx)
+            extra_body["options"] = options
+        if self._think is not None:
+            extra_body["think"] = self._think
+        if extra_body:
+            kwargs["extra_body"] = extra_body
+
+        return kwargs
+
+
+class OllamaClient(OpenAICompatibleClient):
+    """Ollama via its OpenAI-compatible ``/v1`` endpoint."""
+
+    _profile = OLLAMA_PROFILE
+    provider = OLLAMA_PROFILE.name
+    capabilities = OLLAMA_PROFILE.capabilities
+
+
+class LMStudioClient(OpenAICompatibleClient):
+    """LM Studio local OpenAI-compatible server."""
+
+    _profile = LMSTUDIO_PROFILE
+    provider = LMSTUDIO_PROFILE.name
+    capabilities = LMSTUDIO_PROFILE.capabilities
+
+
+class CustomOpenAIClient(OpenAICompatibleClient):
+    """Generic OpenAI-compatible endpoint (requires ``base_url``)."""
+
+    _profile = CUSTOM_PROFILE
+    provider = CUSTOM_PROFILE.name
+    capabilities = CUSTOM_PROFILE.capabilities
+
+
+#: Primary profile name → generated client class. ``get_profiled_client_class``
+#: resolves aliases to a primary name before indexing this map.
+CLIENT_CLASSES: Dict[str, type] = {
+    OLLAMA_PROFILE.name: OllamaClient,
+    LMSTUDIO_PROFILE.name: LMStudioClient,
+    CUSTOM_PROFILE.name: CustomOpenAIClient,
+}
+
+
+__all__ = [
+    "OpenAICompatibleClient",
+    "OllamaClient",
+    "LMStudioClient",
+    "CustomOpenAIClient",
+    "CLIENT_CLASSES",
+]