steerable-agent-runtime 0.6.4__tar.gz → 0.6.6__tar.gz

{steerable_agent_runtime-0.6.4 → steerable_agent_runtime-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.4
+Version: 0.6.6
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{steerable_agent_runtime-0.6.4 → steerable_agent_runtime-0.6.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.4"
+version = "0.6.6"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 readme = "README.md"
 requires-python = ">=3.10"

{steerable_agent_runtime-0.6.4 → steerable_agent_runtime-0.6.6}/src/steerable_agent_runtime/__init__.py

@@ -38,6 +38,7 @@ from .ask_user import (
 from .todo import (
     TODO_SCHEMA,
     TODO_TOOL_NAME,
+    TodoCompletionGate,
     TodoStore,
     make_todo_write_tool,
     todo_write_tool_descriptor,
@@ -156,7 +157,10 @@ from .model_info import (
     MODEL_INFOS,
     REASONING_EFFORT_ORDER,
     ModelInfo,
+    ReasoningEffortUnsupported,
     clamp_reasoning_effort,
+    clear_gateway_models,
+    register_gateway_models,
     register_model_info,
     resolve_model_info,
 )
@@ -266,6 +270,7 @@ __all__ = [
     "MODEL_TOKEN_FACTORS",
     "REASONING_EFFORT_ORDER",
     "RECORD_FORMAT_VERSION",
+    "ReasoningEffortUnsupported",
     "TOOL_SEARCH_NAME",
     "ASK_USER_SCHEMA",
     "ASK_USER_TOOL_NAME",
@@ -391,6 +396,7 @@ __all__ = [
     "ToolExecutor",
     "ToolExposure",
     "ToolRouter",
+    "TodoCompletionGate",
     "TodoStore",
     "TraceRecorder",
     "TranscriptAppend",
@@ -408,6 +414,7 @@ __all__ = [
     "branch_label",
     "build_step_decision_event",
     "clamp_reasoning_effort",
+    "clear_gateway_models",
     "close_dangling_tool_calls",
     "detect_claimed_execution",
     "detect_deferred_execution",
@@ -449,6 +456,7 @@ __all__ = [
     "qualify_mcp_name",
     "reduce_execution_state",
     "register_mcp_catalog",
+    "register_gateway_models",
     "register_model_factor",
     "register_model_info",
     "register_model_price",

{steerable_agent_runtime-0.6.4 → steerable_agent_runtime-0.6.6}/src/steerable_agent_runtime/ask_user.py

@@ -71,9 +71,16 @@ ASK_USER_SCHEMA: dict[str, Any] = {
                         ),
                     },
                     "placeholder": {"type": "string"},
-                    "multiSelect": {"type": "boolean"},
+                    "multiSelect": {
+                        "type": "boolean",
+                        "description": (
+                            "Whether the user may pick several options. "
+                            "Required (CC parity): commit to single vs multi "
+                            "explicitly — pass false for a single-select."
+                        ),
+                    },
                 },
-                "required": ["id", "text"],
+                "required": ["id", "text", "multiSelect"],
             },
         },
     },
@@ -170,12 +177,15 @@ def _normalize_questions(questions: list[dict[str, Any]]) -> list[dict[str, Any]
                 f"ask_user: questions[{index}].header is {len(header)} chars; "
                 f"the chip label must be <= {_MAX_HEADER_LEN}."
             )
-        # multiSelect: CC requires the model to commit to single vs multi.
-        # Default to False when absent so existing single-select calls keep
-        # working, but stamp it so hosts always read an explicit boolean.
+        # multiSelect: CC requires the model to commit to single vs multi —
+        # the field is required, so an omission is a model error to fix, not
+        # a default to assume.
         if "multiSelect" not in q or q["multiSelect"] is None:
-            q["multiSelect"] = False
-        elif not isinstance(q["multiSelect"], bool):
+            raise ToolDispatchError(
+                f"ask_user: questions[{index}].multiSelect is required "
+                "(CC parity) — pass false for a single-select question."
+            )
+        if not isinstance(q["multiSelect"], bool):
             raise ToolDispatchError(
                 f"ask_user: questions[{index}].multiSelect must be a boolean, "
                 f"got {type(q['multiSelect']).__name__}."

{steerable_agent_runtime-0.6.4 → steerable_agent_runtime-0.6.6}/src/steerable_agent_runtime/compaction.py

@@ -57,6 +57,14 @@ Two safety rails share the machinery:
   the turn still fails loud (bounded retries, then a named error) instead
   of spinning. A round that lands under threshold — or any successful
   compaction — resets the count.
+- A **rapid-refill breaker** (CC parity): a compaction that lands under
+  threshold but refills within ``rapid_refill_window_rounds`` rounds of the
+  previous one counts as a refill; ``max_rapid_refills`` consecutive
+  refills open the same circuit — the transcript is churning faster than
+  compaction can help, so further rewrites only kill the prompt cache.
+  The tripping round appends a ``CompactionThrashingReminder`` (model- and
+  UI-visible) with an actionable converge notice. ``circuit_reason``
+  records which breaker tripped.
 """
 
 from __future__ import annotations
@@ -64,9 +72,10 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import Any
 
-from .hooks import NoopHooks, PreStepAction, RetryAction, RewriteRequest
+from .hooks import NoopHooks, PreStepAction, RetryAction, RewriteRequest, TranscriptAppend
 from .llm import LLMMessage, LLMProvider
 from .llm.errors import classify_error
+from .reminders import CompactionThrashingReminder
 from .tokens import estimate_tokens
 
 _SUMMARY_MARKER = "[context compacted: earlier conversation summarized]"
@@ -108,6 +117,8 @@ class CompactionHooks(NoopHooks):
         recompact_margin_ratio: float = 0.1,
         fold_excerpt_chars: int = _FOLD_EXCERPT_CHARS,
         micro_compact_interval_rounds: int = 0,
+        rapid_refill_window_rounds: int = 3,
+        max_rapid_refills: int = 3,
     ) -> None:
         if not 0 < threshold_ratio <= 1:
             raise ValueError("threshold_ratio must be in (0, 1]")
@@ -115,6 +126,10 @@ class CompactionHooks(NoopHooks):
             raise ValueError("recompact_margin_ratio must be >= 0")
         if not 0 <= micro_compact_interval_rounds:
             raise ValueError("micro_compact_interval_rounds must be >= 0")
+        if not 1 <= rapid_refill_window_rounds:
+            raise ValueError("rapid_refill_window_rounds must be >= 1")
+        if not 1 <= max_rapid_refills:
+            raise ValueError("max_rapid_refills must be >= 1")
         self._max_tokens = max_context_tokens
         self._threshold = threshold_ratio
         self._keep_last = keep_last_messages
@@ -155,9 +170,22 @@ class CompactionHooks(NoopHooks):
         #: parity). The overflow path is bounded separately and unaffected.
         self.max_consecutive_failures = 3
         self._consecutive_failures = 0
+        #: Rapid-refill breaker (CC parity): a compaction that *worked* but
+        #: whose freed space refills within ``rapid_refill_window_rounds``
+        #: rounds counts as a refill; ``max_rapid_refills`` consecutive
+        #: refills open the circuit — the transcript is churning faster than
+        #: compaction can help, and each rewrite only kills the prompt-cache
+        #: prefix. Distinct from the failure breaker above, which catches
+        #: compactions that never get under threshold at all.
+        self.rapid_refill_window_rounds = rapid_refill_window_rounds
+        self.max_rapid_refills = max_rapid_refills
+        self._rapid_refills = 0
+        self._last_compact_round: int | None = None
         # Observability: True once the breaker tripped; the pressure path
         # stops firing for the rest of the session.
         self.circuit_open = False
+        #: Which breaker tripped: "consecutive_failures" | "rapid_refill".
+        self.circuit_reason: str | None = None
 
     def _estimate(self, transcript: Sequence[LLMMessage]) -> int:
         return estimate_tokens(transcript, model=self._model)
@@ -214,9 +242,10 @@ class CompactionHooks(NoopHooks):
                 )
         pressure = self._pressure(transcript, ctx)
         if pressure < self._threshold * self._max_tokens:
-            # A healthy round resets the breaker count — the pathology (or
-            # the transcript that caused it) is gone.
+            # A healthy round resets both breaker counts — the pathology
+            # (or the transcript that caused it) is gone.
             self._consecutive_failures = 0
+            self._rapid_refills = 0
             return PreStepAction(kind="proceed")
         if self.circuit_open:
             # Breaker tripped: further pressure rewrites only invalidate the
@@ -234,6 +263,7 @@ class CompactionHooks(NoopHooks):
         if self._estimate(compacted) < threshold:
             self.compactions += 1
             self._consecutive_failures = 0
+            notice = self._note_successful_compaction(round_index)
             self._last_compaction_pressure = pressure
             self._reset_observed(ctx)
             return PreStepAction(
@@ -245,13 +275,17 @@ class CompactionHooks(NoopHooks):
                     pre_tokens=pressure,
                     post_tokens=self._estimate(compacted),
                 ),
+                appends=[notice] if notice is not None else None,
+                append_action="reminder" if notice is not None else None,
             )
 
         compacted = await self._summarize_middle(compacted)
         post = self._estimate(compacted)
         self.compactions += 1
+        notice: TranscriptAppend | None = None
         if post < threshold:
             self._consecutive_failures = 0
+            notice = self._note_successful_compaction(round_index)
         else:
             # Ineffective: even fold+summarize stayed over threshold (e.g. a
             # single kept tool result bigger than the window). Three in a
@@ -259,6 +293,7 @@ class CompactionHooks(NoopHooks):
             self._consecutive_failures += 1
             if self._consecutive_failures >= self.max_consecutive_failures:
                 self.circuit_open = True
+                self.circuit_reason = "consecutive_failures"
         self._last_compaction_pressure = pressure
         self._reset_observed(ctx)
         return PreStepAction(
@@ -270,20 +305,52 @@ class CompactionHooks(NoopHooks):
                 pre_tokens=pressure,
                 post_tokens=post,
             ),
+            appends=[notice] if notice is not None else None,
+            append_action="reminder" if notice is not None else None,
         )
 
+    def _note_successful_compaction(self, round_index: int) -> TranscriptAppend | None:
+        """Rapid-refill bookkeeping for a compaction that landed under
+        threshold. A refill is a successful compaction within
+        ``rapid_refill_window_rounds`` of the previous one; on the
+        ``max_rapid_refills``-th consecutive refill the circuit opens and
+        the round carries the thrashing reminder so both the model and the
+        host UI see the actionable notice."""
+        if (
+            self._last_compact_round is not None
+            and round_index - self._last_compact_round <= self.rapid_refill_window_rounds
+        ):
+            self._rapid_refills += 1
+        else:
+            self._rapid_refills = 0
+        self._last_compact_round = round_index
+        if self._rapid_refills >= self.max_rapid_refills and not self.circuit_open:
+            self.circuit_open = True
+            self.circuit_reason = "rapid_refill"
+            reminder = CompactionThrashingReminder(
+                self._rapid_refills, self.rapid_refill_window_rounds
+            )
+            return TranscriptAppend(
+                message=LLMMessage.text_of(reminder.role, reminder.render()),
+                kind=reminder.content_kind,
+                fragment=reminder,
+            )
+        return None
+
     async def compact_now(self, transcript: list[LLMMessage], ctx: Any) -> PreStepAction:
         """Manual compaction (CC ``/compact`` parity): fold old tool results,
         then summarize the middle, regardless of pressure, hysteresis, or the
         circuit breaker — the user asked for it. Returns a ``proceed`` action
         carrying the rewrite; when neither stage changes anything the action
         carries no rewrite (nothing was worth invalidating the cache for).
-        A manual pass resets the breaker count: the user has taken over.
+        A manual pass resets both breaker counts: the user has taken over.
         """
         pre = self._estimate(transcript)
         compacted = self._fold_old_tool_results(transcript)
         compacted = await self._summarize_middle(compacted)
         self._consecutive_failures = 0
+        self._rapid_refills = 0
+        self._last_compact_round = None
         if compacted is transcript or compacted == transcript:
             return PreStepAction(kind="proceed", reason="compact: nothing to fold")
         self.compactions += 1

steerable_agent_runtime-0.6.6/src/steerable_agent_runtime/gateway_catalog.py

@@ -0,0 +1,319 @@
+"""Live gateway model listing — the discovery half of the model catalog.
+
+The bundled catalog (``model_catalog.py``) is a models.dev snapshot, stale by
+construction; the gateway's own ``GET /models`` is the live list of ids the
+endpoint actually accepts. This module fetches and parses that listing into
+``GatewayModel`` rows, tolerating the two listing shapes in the wild
+(OpenAI-style ``data`` array, models.dev-style ``models`` object) and the
+field variants each uses for window / max-output / pricing — the tolerance
+dsh's ``readListing`` (llm-pi-ai ``discovery.ts``) implements, verified
+against its recorded provider-listing fixtures.
+
+Discovery, not routing: a gateway id absent from every catalog still appears
+in the listing with empty capability fields and ``joined_from=None``; the
+listing never gates whether a request may be sent.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Iterable
+
+if TYPE_CHECKING:
+    from .model_info import ModelInfo
+
+_log = logging.getLogger(__name__)
+
+#: Default freshness window for the in-process listing cache. The gateway
+#: listing changes on deployment boundaries, not per request; 60s keeps a
+#: settings UI snappy without hammering the endpoint.
+DEFAULT_TTL_SEC = 60.0
+
+#: Default timeout for the listing request itself.
+DEFAULT_TIMEOUT_SEC = 10.0
+
+
+class GatewayCatalogError(Exception):
+    """The gateway listing could not be fetched and no cache survives."""
+
+    def __init__(self, base_url: str, reason: str) -> None:
+        self.base_url = base_url
+        self.reason = reason
+        super().__init__(f"gateway catalog fetch failed for {base_url!r}: {reason}")
+
+
+@dataclass(frozen=True, slots=True)
+class GatewayModel:
+    """One row of the gateway's live listing, normalized across shapes.
+
+    Capability fields are ``None``/empty when the gateway does not advertise
+    them — the catalog join (``merge_with_catalog``) fills what models.dev
+    knows, and what neither knows stays unknown.
+    """
+
+    id: str
+    name: str
+    context_window: int | None
+    max_output_tokens: int | None
+    input_modalities: tuple[str, ...]
+    #: USD per million tokens, parsed from OpenRouter-style ``pricing``
+    #: strings; ``None`` when the gateway does not advertise pricing.
+    prompt_price_per_mtok: float | None
+    completion_price_per_mtok: float | None
+    #: OpenRouter-style ``supported_parameters`` (``"reasoning"`` present
+    #: means the endpoint accepts a reasoning knob, levels unknown).
+    supported_parameters: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class GatewayListing:
+    """A fetched listing plus its freshness provenance."""
+
+    entries: tuple[GatewayModel, ...]
+    #: Epoch seconds of the successful fetch (a stale listing keeps the
+    #: timestamp of the fetch that produced it, not of the failed refresh).
+    fetched_at: float
+    #: True when the last refresh failed and this is the previous listing.
+    stale: bool
+
+
+@dataclass(frozen=True, slots=True)
+class GatewayCatalogRow:
+    """A gateway id joined with catalog capabilities, ready for the wire.
+
+    ``joined_from`` names the catalog key that supplied capability fields
+    (``None`` when no catalog tier matched — the "capabilities unknown"
+    case the UI marks). ``info`` is the merged capability descriptor:
+    gateway-advertised fields win where the gateway provides them, catalog
+    fields (reasoning levels above all) fill the rest.
+    """
+
+    id: str
+    name: str
+    info: ModelInfo
+    joined_from: str | None
+    prompt_price_per_mtok: float | None
+    completion_price_per_mtok: float | None
+
+
+# ---------------------------------------------------------------------------
+# Parsing (pure)
+# ---------------------------------------------------------------------------
+
+
+def _first_int(*values: Any) -> int | None:
+    for value in values:
+        if isinstance(value, bool):
+            continue
+        if isinstance(value, (int, float)) and value > 0:
+            return int(value)
+    return None
+
+
+def _first_str_list(value: Any) -> tuple[str, ...]:
+    if isinstance(value, (list, tuple)):
+        return tuple(str(v) for v in value if isinstance(v, str))
+    return ()
+
+
+def _price_per_mtok(pricing: Any, key: str) -> float | None:
+    """OpenRouter ``pricing`` values are USD-per-token strings."""
+    if not isinstance(pricing, dict):
+        return None
+    raw = pricing.get(key)
+    if not isinstance(raw, (str, int, float)) or isinstance(raw, bool):
+        return None
+    try:
+        return float(raw) * 1_000_000
+    except (TypeError, ValueError):
+        return None
+
+
+def _parse_entry(entry: Any, *, key_hint: str | None) -> GatewayModel | None:
+    if not isinstance(entry, dict):
+        return None
+    model_id = entry.get("id") or key_hint
+    if not isinstance(model_id, str) or not model_id:
+        return None
+    name = entry.get("name") or entry.get("display_name") or entry.get("displayName")
+    limit = entry.get("limit") if isinstance(entry.get("limit"), dict) else {}
+    top_provider = (
+        entry.get("top_provider") if isinstance(entry.get("top_provider"), dict) else {}
+    )
+    architecture = (
+        entry.get("architecture") if isinstance(entry.get("architecture"), dict) else {}
+    )
+    return GatewayModel(
+        id=model_id,
+        name=str(name) if isinstance(name, str) and name else model_id,
+        context_window=_first_int(
+            entry.get("context_length"),
+            entry.get("context_window"),
+            entry.get("contextWindow"),
+            entry.get("max_input_tokens"),
+            limit.get("context"),
+        ),
+        max_output_tokens=_first_int(
+            top_provider.get("max_completion_tokens"),
+            entry.get("max_completion_tokens"),
+            entry.get("max_output_tokens"),
+            entry.get("maxOutputTokens"),
+            entry.get("maxTokens"),
+            entry.get("max_tokens"),
+            limit.get("output"),
+        ),
+        input_modalities=_first_str_list(architecture.get("input_modalities")),
+        prompt_price_per_mtok=_price_per_mtok(entry.get("pricing"), "prompt"),
+        completion_price_per_mtok=_price_per_mtok(entry.get("pricing"), "completion"),
+        supported_parameters=_first_str_list(entry.get("supported_parameters")),
+    )
+
+
+def parse_models_listing(payload: Any) -> list[GatewayModel]:
+    """Parse a ``GET /models`` body into normalized rows.
+
+    Two shapes are in the wild: OpenAI-style ``{"data": [...]}`` (the common
+    case, OpenRouter's enriched variant included) and models.dev-style
+    ``{"models": {...}}`` where the property key is the id. Anything else is
+    a parse error the caller surfaces as ``GatewayCatalogError``.
+    """
+    if not isinstance(payload, dict):
+        raise ValueError("listing payload is not a JSON object")
+    data = payload.get("data")
+    if isinstance(data, list):
+        rows = [_parse_entry(entry, key_hint=None) for entry in data]
+        return [row for row in rows if row is not None]
+    models = payload.get("models")
+    if isinstance(models, dict):
+        rows = [_parse_entry(entry, key_hint=key) for key, entry in models.items()]
+        return [row for row in rows if row is not None]
+    if isinstance(models, list):
+        rows = [_parse_entry(entry, key_hint=None) for entry in models]
+        return [row for row in rows if row is not None]
+    raise ValueError("listing has neither a 'data' array nor a 'models' map")
+
+
+# ---------------------------------------------------------------------------
+# Catalog join (pure)
+# ---------------------------------------------------------------------------
+
+
+def merge_with_catalog(models: Iterable[GatewayModel]) -> list[GatewayCatalogRow]:
+    """Join gateway rows with catalog capabilities (cross-provider leaf).
+
+    The gateway's own fields (window, modalities) win where advertised —
+    they describe this deployment. Capability fields come from
+    ``resolve_model_info`` itself — the very resolution the request path's
+    ``clamp_reasoning_effort`` uses, legacy-union rule included — so
+    ``models.list`` and the request path never disagree about a model's
+    knob (a picker that hides a level the backend would accept is the same
+    class of drift as silently dropping one). ``joined_from`` keeps the
+    leaf-join provenance: ``None`` when no catalog tier matched, even if
+    the hand-owned legacy table knows the model.
+    """
+    from .model_info import (
+        TOOL_FORMAT_OPENAI,
+        ModelInfo,
+        resolve_model_info,
+    )
+    from .model_resolve import resolve_leaf_cross_provider
+
+    rows: list[GatewayCatalogRow] = []
+    for model in models:
+        hit = resolve_leaf_cross_provider(model.id)
+        base = resolve_model_info(model.id)
+        context_window = (
+            model.context_window
+            if model.context_window is not None
+            else base.context_window
+        )
+        modalities = (
+            frozenset(model.input_modalities)
+            if model.input_modalities
+            else base.modalities
+        )
+        rows.append(
+            GatewayCatalogRow(
+                id=model.id,
+                name=model.name,
+                info=ModelInfo(
+                    pattern=model.id.lower(),
+                    context_window=context_window,
+                    modalities=modalities,
+                    tool_format=TOOL_FORMAT_OPENAI,
+                    reasoning_levels=base.reasoning_levels,
+                ),
+                joined_from=hit.key if hit is not None else None,
+                prompt_price_per_mtok=model.prompt_price_per_mtok,
+                completion_price_per_mtok=model.completion_price_per_mtok,
+            )
+        )
+    return rows
+
+
+# ---------------------------------------------------------------------------
+# Fetch (network, TTL-cached, stale-on-error)
+# ---------------------------------------------------------------------------
+
+#: base_url (normalized) -> (time.monotonic() at fetch, listing). The wall
+#: clock ``listing.fetched_at`` is for display; the monotonic clock drives
+#: TTL so a clock jump cannot expire or resurrect a listing.
+_cache: dict[str, tuple[float, GatewayListing]] = {}
+
+
+def _cache_key(base_url: str) -> str:
+    return base_url.rstrip("/").lower()
+
+
+def clear_gateway_cache() -> None:
+    """Drop every cached listing (tests, forced refresh)."""
+    _cache.clear()
+
+
+async def fetch_gateway_models(
+    base_url: str,
+    api_key: str | None = None,
+    *,
+    timeout_sec: float = DEFAULT_TIMEOUT_SEC,
+    ttl_sec: float = DEFAULT_TTL_SEC,
+) -> GatewayListing:
+    """Fetch the gateway's live model listing, with a process-local cache.
+
+    A fresh-enough cached listing is served without network. On refresh
+    failure the previous listing is returned marked ``stale`` — the catalog
+    degrades instead of disappearing when the gateway flaps. With no cache
+    to fall back on, ``GatewayCatalogError`` is raised and the caller
+    decides (the sidecar answers ``catalog_status: "offline"``).
+    """
+    import httpx  # local import — keeps the runtime importable without httpx
+
+    from .llm.system_proxy import client_env_kwargs
+
+    key = _cache_key(base_url)
+    cached = _cache.get(key)
+    if cached is not None and (time.monotonic() - cached[0]) < ttl_sec:
+        return cached[1]
+
+    url = f"{base_url.rstrip('/')}/models"
+    headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
+    try:
+        async with httpx.AsyncClient(
+            timeout=httpx.Timeout(timeout_sec),
+            **client_env_kwargs(base_url),
+        ) as client:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            entries = tuple(parse_models_listing(response.json()))
+    except Exception as exc:
+        if cached is not None:
+            _log.info("gateway listing refresh failed (%s); serving stale", exc)
+            return GatewayListing(
+                entries=cached[1].entries, fetched_at=cached[1].fetched_at, stale=True
+            )
+        raise GatewayCatalogError(base_url, str(exc)) from exc
+
+    listing = GatewayListing(entries=entries, fetched_at=time.time(), stale=False)
+    _cache[key] = (time.monotonic(), listing)
+    return listing

{steerable_agent_runtime-0.6.4 → steerable_agent_runtime-0.6.6}/src/steerable_agent_runtime/harness.py

@@ -209,6 +209,11 @@ class PressureCompaction:
     # trades cache hits for a bounded transcript. R16 found compaction does not
     # move the eval score, so this stays opt-in capability, not a default.
     micro_compact_interval_rounds: int = 0
+    # Rapid-refill breaker (CC parity): a successful compaction whose freed
+    # space refills within this many rounds of the previous one counts as a
+    # refill; max_rapid_refills consecutive refills open the circuit.
+    rapid_refill_window_rounds: int = 3
+    max_rapid_refills: int = 3
     name: str = "pressure_compaction"
     assumes: str = (
         "long trajectories exceed the window; older detail is expendable "
@@ -231,6 +236,8 @@ class PressureCompaction:
                 summarizer=provider,
                 model=self.model,
                 micro_compact_interval_rounds=self.micro_compact_interval_rounds,
+                rapid_refill_window_rounds=self.rapid_refill_window_rounds,
+                max_rapid_refills=self.max_rapid_refills,
                 **extra,
             ),
             forward=("compact_now",),

{steerable_agent_runtime-0.6.4 → steerable_agent_runtime-0.6.6}/src/steerable_agent_runtime/llm/__init__.py

@@ -158,7 +158,9 @@ from .errors import (
     classify_http_status,
     is_retryable,
 )
+from .google_genai import GoogleGenAIProvider
 from .openai_compat import OpenAICompatProvider
+from .openai_responses import OpenAIResponsesProvider
 from .presets import (
     PROVIDER_PRESETS,
     PresetEntry,
@@ -174,6 +176,7 @@ __all__ = [
     "RETRYABLE_KINDS",
     "AnthropicProvider",
     "ContentPart",
+    "GoogleGenAIProvider",
     "ImagePart",
     "LLMError",
     "LLMErrorKind",
@@ -188,6 +191,7 @@ __all__ = [
     "describe_compat_flags",
     "describe_provider_presets",
     "OpenAICompatProvider",
+    "OpenAIResponsesProvider",
     "TextPart",
     "classify_error",
     "classify_http_status",