steerable-agent-runtime 0.7.4__tar.gz → 0.8.1__tar.gz

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.7.4
+Version: 0.8.1
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 License: Apache-2.0
 Requires-Python: >=3.10
@@ -10,7 +10,7 @@ Requires-Dist: mcp<2.0.0,>=1.13.0
 Requires-Dist: pydantic>=2.10.0
 Requires-Dist: steerable-agent-protocol<1.0.0,>=0.1.0
 Requires-Dist: steerable-agent-harness<1.0.0,>=0.1.0
-Requires-Dist: steerable-agent-runtime-native==1.0.5
+Requires-Dist: steerable-agent-runtime-native==1.0.7
 Provides-Extra: sqlalchemy
 Requires-Dist: sqlalchemy>=2.0; extra == "sqlalchemy"
 Provides-Extra: fastapi

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.7.4"
+version = "0.8.1"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 license = { text = "Apache-2.0" }
 readme = "README.md"
@@ -21,7 +21,7 @@ dependencies = [
   "pydantic>=2.10.0",
   "steerable-agent-protocol>=0.1.0,<1.0.0",
   "steerable-agent-harness>=0.1.0,<1.0.0",
-  "steerable-agent-runtime-native==1.0.5",
+  "steerable-agent-runtime-native==1.0.7",
 ]
 
 [project.optional-dependencies]

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/__init__.py

@@ -193,7 +193,14 @@ from .orchestration import (
     OrchestrationExecutor,
     orchestration_tool_descriptors,
 )
-from .otel import PrivacyMode, export_otlp_http, export_trace, to_otlp_json
+from .otel import (
+    PrivacyMode,
+    export_metrics,
+    export_otlp_http,
+    export_trace,
+    to_otlp_json,
+    to_otlp_metrics_json,
+)
 from .pricing import (
     MODEL_PRICES,
     ModelPrice,
@@ -462,6 +469,8 @@ __all__ = [
     "estimate_tokens",
     "export_otlp_http",
     "export_trace",
+    "export_metrics",
+    "to_otlp_metrics_json",
     "extract_inline_tool_calls",
     "factor_for_model",
     "family_tree",

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/default.harness.json

@@ -14,7 +14,11 @@
     {
       "impl": "simple",
       "params": {
-        "max_attempts": 3
+        "max_attempts": 3,
+        "transport_max_attempts": 5,
+        "transport_base_delay_ms": 1000,
+        "transport_max_delay_ms": 8000,
+        "transport_deadline_ms": 60000
       }
     }
   ],

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/default.harness.yaml

@@ -13,8 +13,16 @@ retry:
   - impl: informed_backtrack
   # max_attempts 3 pins the production default (RetryHooks()); the strategy
   # default of 4 would silently diverge the spec from the sidecar chat path.
+  # transport_* is the connection-failure policy: seconds-scale backoff under
+  # a wall-clock deadline, so a proxy or link outage is retried long enough to
+  # ride out a blip and fails within the deadline instead of after minutes.
   - impl: simple
-    params: {max_attempts: 3}
+    params:
+      max_attempts: 3
+      transport_max_attempts: 5
+      transport_base_delay_ms: 1000
+      transport_max_delay_ms: 8000
+      transport_deadline_ms: 60000
 # Quoted: bare `null` is YAML's null literal, not the implementation name.
 validator: "null"
 tools: full

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/harness.py

@@ -27,7 +27,7 @@ from .compaction import CompactionHooks
 from .history import ContextFragment
 from .hooks import LoopHooks, NoopHooks
 from .llm import LLMProvider
-from .retry import RetryHooks
+from .retry import RetryHooks, TransportRetryPolicy
 from .storage import InMemoryStorage, StorageAdapter
 from .tool_search import DEFAULT_MAX_RESULTS
 from .tools import ToolRouter
@@ -329,11 +329,20 @@ class NoRetry:
 
 @dataclass(frozen=True, slots=True)
 class SimpleRetry:
-    """The existing bounded exponential backoff (RetryHooks)."""
+    """Bounded exponential backoff (RetryHooks).
+
+    The ``transport_*`` fields configure the connection-failure policy, which
+    is deliberately more patient than the shared one and stops at a deadline:
+    see :class:`TransportRetryPolicy`.
+    """
 
     max_attempts: int = 4
     base_delay_ms: int = 200
     max_delay_ms: int = 5000
+    transport_max_attempts: int = 5
+    transport_base_delay_ms: int = 1000
+    transport_max_delay_ms: int = 8000
+    transport_deadline_ms: int = 60_000
     name: str = "simple"
     assumes: str = (
         "failures are dominated by transient transport/rate-limit/server "
@@ -350,7 +359,13 @@ class SimpleRetry:
                     max_attempts=self.max_attempts,
                     base_delay_ms=self.base_delay_ms,
                     max_delay_ms=self.max_delay_ms,
-                )
+                ),
+                transport_policy=TransportRetryPolicy(
+                    max_attempts=self.transport_max_attempts,
+                    base_delay_ms=self.transport_base_delay_ms,
+                    max_delay_ms=self.transport_max_delay_ms,
+                    deadline_ms=self.transport_deadline_ms,
+                ),
             )
         )
 

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/llm/anthropic_native.py

@@ -20,16 +20,19 @@ from typing import Any
 from steerable_agent_protocol.generated import ToolCall
 
 from . import LLMMessage, LLMStreamChunk, LLMUsage
-from .errors import LLMError, classify_http_status
+from .errors import LLMError, classify_http_status, describe_transport_error
 from .parts import ImagePart, TextPart
 
 
-def _classify_anthropic_error(exc: Exception, *, provider: str) -> Exception:
+def _classify_anthropic_error(
+    exc: Exception, *, provider: str, proxy: str | None = None
+) -> Exception:
     """Normalize anthropic SDK exceptions into the ``LLMError`` taxonomy.
 
     The SDK raises ``APIStatusError`` (has ``status_code``) for HTTP failures
     and ``APIConnectionError`` for transport problems; anything already
-    classified (or unrecognized) passes through with ``unknown``.
+    classified (or unrecognized) passes through with ``unknown``. `proxy` is
+    the hop the SDK client used, reported on transport failures.
     """
     if isinstance(exc, LLMError):
         return exc
@@ -45,7 +48,10 @@ def _classify_anthropic_error(exc: Exception, *, provider: str) -> Exception:
     # APIConnectionError / APITimeoutError have no status_code.
     if exc.__class__.__name__ in ("APIConnectionError", "APITimeoutError"):
         return LLMError(
-            f"{provider}: transport error: {exc}", kind="transport", provider=provider
+            f"{provider}: transport error: {describe_transport_error(exc)}",
+            kind="transport",
+            provider=provider,
+            proxy=proxy,
         )
     return LLMError(f"{provider}: {exc}", kind="unknown", provider=provider)
 
@@ -79,7 +85,9 @@ class AnthropicProvider:
         try:
             message = await client.messages.create(**body)
         except Exception as exc:  # noqa: BLE001 - normalized into the taxonomy
-            raise _classify_anthropic_error(exc, provider=self.name) from exc
+            raise _classify_anthropic_error(
+                exc, provider=self.name, proxy=self._egress_proxy()
+            ) from exc
         text_chunks: list[str] = []
         tool_calls: list[ToolCall] = []
         for block in message.content or []:
@@ -134,12 +142,20 @@ class AnthropicProvider:
                         finish_reason="stop",
                     )
         except Exception as exc:  # noqa: BLE001 - normalized into the taxonomy
-            raise _classify_anthropic_error(exc, provider=self.name) from exc
+            raise _classify_anthropic_error(
+                exc, provider=self.name, proxy=self._egress_proxy()
+            ) from exc
 
     # ------------------------------------------------------------------
     # Helpers
     # ------------------------------------------------------------------
 
+    def _egress_proxy(self) -> str | None:
+        """Proxy the SDK client reaches `base_url` through, for failure reports."""
+        from .system_proxy import egress_path
+
+        return egress_path(self.base_url or "https://api.anthropic.com").proxy
+
     def _client(self) -> Any:
         from anthropic import AsyncAnthropic  # local import keeps optional dep optional
 

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/llm/errors.py

@@ -54,6 +54,7 @@ class LLMError(Exception):
         provider: str | None = None,
         raw: Any | None = None,
         retry_after_ms: int | None = None,
+        proxy: str | None = None,
     ) -> None:
         super().__init__(message)
         self.kind = kind
@@ -61,12 +62,61 @@ class LLMError(Exception):
         self.provider = provider
         self.raw = raw
         self.retry_after_ms = retry_after_ms
+        #: Proxy the request went through, credentials stripped; None means
+        #: the request went direct. A failure report shows this so the reader
+        #: knows which hop failed without having to reproduce the settings.
+        self.proxy = proxy
 
     @property
     def retryable(self) -> bool:
         return self.kind in RETRYABLE_KINDS
 
 
+#: Cause-chain walk depth for :func:`describe_transport_error`. httpx →
+#: httpcore → anyio → ssl/socket is four; a little headroom costs nothing.
+_MAX_CAUSE_DEPTH = 6
+
+
+def describe_transport_error(exc: BaseException) -> str:
+    """Flatten a transport exception into one diagnosable string.
+
+    httpx reports a proxy that accepted ``CONNECT`` and then dropped the
+    tunnel as ``ConnectError('')`` — the empty message is httpcore's, and the
+    ``ssl.SSLEOFError`` or ``socket.gaierror`` that explains it is three
+    ``__cause__`` hops down. Logging ``str(exc)`` alone therefore produced
+    ``transport error: `` with nothing after it. This walks the chain and
+    keeps every hop that names something, outermost first.
+
+    The walk follows ``__cause__``; it falls back to ``__context__`` only
+    when the raiser did not set ``__cause__`` and did not ask for the
+    context to be suppressed (``raise ... from None``), so an explicit
+    suppression does not leak the exception it hid.
+
+    Consecutive hops of the same class with no message each collapse into
+    one: httpcore re-wraps its own ``ConnectError`` on the proxy path, and
+    ``ConnectError <- ConnectError`` names nothing the first hop did not.
+
+    A chain with no message at all still returns the class names, so the
+    line never ends in silence.
+    """
+    parts: list[tuple[str, str]] = []
+    seen: set[int] = set()
+    current: BaseException | None = exc
+    while current is not None and len(seen) < _MAX_CAUSE_DEPTH:
+        if id(current) in seen:
+            break
+        seen.add(id(current))
+        name = type(current).__name__
+        text = str(current).strip()
+        if text or not parts or parts[-1] != (name, ""):
+            parts.append((name, text))
+        cause = current.__cause__
+        if cause is None and not current.__suppress_context__:
+            cause = current.__context__
+        current = cause if cause is not None and cause is not current else None
+    return " <- ".join(f"{name}: {text}" if text else name for name, text in parts)
+
+
 #: Body substrings that mark a 400/413 as a context-window overflow rather
 #: than a generic invalid request. Covers OpenAI, Ollama, vLLM, DeepSeek,
 #: and Anthropic phrasings (matched case-insensitively).

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/llm/google_genai.py

@@ -23,10 +23,15 @@ from typing import Any, Literal
 from steerable_agent_protocol.generated import ToolCall
 
 from . import LLMMessage, LLMStreamChunk, LLMUsage
-from .errors import LLMError, classify_http_status, parse_retry_after_ms
+from .errors import (
+    LLMError,
+    classify_http_status,
+    describe_transport_error,
+    parse_retry_after_ms,
+)
 from .parts import ImagePart, TextPart
 from .presets import ProviderPreset, preset_for
-from .system_proxy import client_env_kwargs
+from .system_proxy import client_env_kwargs, egress_path
 
 logger = logging.getLogger(__name__)
 
@@ -79,6 +84,9 @@ class GoogleGenAIProvider:
     base_url: str = "https://generativelanguage.googleapis.com"
     api_key: str | None = None
     default_temperature: float | None = None
+    #: Send this endpoint's requests direct even when the host declares a
+    #: proxy (see `OpenAICompatProvider.force_direct`).
+    force_direct: bool = False
     preset: ProviderPreset | Literal["auto", "off"] = "auto"
 
     def __post_init__(self) -> None:
@@ -110,7 +118,7 @@ class GoogleGenAIProvider:
         try:
             async with httpx.AsyncClient(
                 timeout=httpx.Timeout(60.0),
-                **client_env_kwargs(self.base_url),
+                **client_env_kwargs(self.base_url, force_direct=self.force_direct),
             ) as client:
                 response = await client.post(
                     self._url(stream=False),
@@ -124,9 +132,10 @@ class GoogleGenAIProvider:
                 payload = response.json()
         except httpx.TransportError as exc:
             raise LLMError(
-                f"{self.name}: transport error: {exc}",
+                f"{self.name}: transport error: {describe_transport_error(exc)}",
                 kind="transport",
                 provider=self.name,
+                proxy=None if self.force_direct else egress_path(self.base_url).proxy,
             ) from exc
 
         return _decode_response(payload)
@@ -153,7 +162,7 @@ class GoogleGenAIProvider:
             async with (
                 httpx.AsyncClient(
                     timeout=_stream_timeout(),
-                    **client_env_kwargs(self.base_url),
+                    **client_env_kwargs(self.base_url, force_direct=self.force_direct),
                 ) as client,
                 client.stream(
                     "POST",
@@ -185,9 +194,10 @@ class GoogleGenAIProvider:
                         yield parsed
         except httpx.TransportError as exc:
             raise LLMError(
-                f"{self.name}: transport error: {exc}",
+                f"{self.name}: transport error: {describe_transport_error(exc)}",
                 kind="transport",
                 provider=self.name,
+                proxy=None if self.force_direct else egress_path(self.base_url).proxy,
             ) from exc
 
     # ------------------------------------------------------------------

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/llm/openai_compat.py

@@ -30,10 +30,15 @@ from ..model_info import (
 )
 from . import LLMMessage, LLMStreamChunk, LLMUsage
 from .compat import OpenAICompatFlags
-from .errors import LLMError, classify_http_status, parse_retry_after_ms
+from .errors import (
+    LLMError,
+    classify_http_status,
+    describe_transport_error,
+    parse_retry_after_ms,
+)
 from .parts import ImagePart, TextPart
 from .presets import ProviderPreset, preset_for
-from .system_proxy import client_env_kwargs
+from .system_proxy import client_env_kwargs, egress_path
 
 logger = logging.getLogger(__name__)
 
@@ -145,6 +150,11 @@ class OpenAICompatProvider:
     #: a ``ProviderPreset`` instance pins that preset regardless of the
     #: registry (host settings UIs send an explicit choice this way).
     preset: ProviderPreset | Literal["auto", "off"] = "auto"
+    #: Send this endpoint's requests direct even when the host declares a
+    #: proxy. Set for a model service the user redirected after a proxy turned
+    #: a working connection into a timeout; the proxy stays configured for
+    #: everything else.
+    force_direct: bool = False
     #: Per-request reasoning effort from the host's model picker; wins over
     #: ``STEERABLE_REASONING_EFFORT`` and the preset default. Explicitly
     #: requested effort is validated strict (``clamp_reasoning_effort``) —
@@ -197,7 +207,7 @@ class OpenAICompatProvider:
         try:
             async with httpx.AsyncClient(
                 timeout=httpx.Timeout(60.0),
-                **client_env_kwargs(self.base_url),
+                **client_env_kwargs(self.base_url, force_direct=self.force_direct),
             ) as client:
                 response = await client.post(
                     f"{self.base_url.rstrip('/')}/chat/completions",
@@ -211,9 +221,10 @@ class OpenAICompatProvider:
                 payload = response.json()
         except httpx.TransportError as exc:
             raise LLMError(
-                f"{self.name}: transport error: {exc}",
+                f"{self.name}: transport error: {describe_transport_error(exc)}",
                 kind="transport",
                 provider=self.name,
+                proxy=None if self.force_direct else egress_path(self.base_url).proxy,
             ) from exc
 
         choice = payload["choices"][0]
@@ -250,7 +261,7 @@ class OpenAICompatProvider:
             async with (
                 httpx.AsyncClient(
                     timeout=_stream_timeout(),
-                    **client_env_kwargs(self.base_url),
+                    **client_env_kwargs(self.base_url, force_direct=self.force_direct),
                 ) as client,
                 client.stream(
                     "POST",
@@ -306,9 +317,10 @@ class OpenAICompatProvider:
                     yield LLMStreamChunk(tool_call_delta=call)
         except httpx.TransportError as exc:
             raise LLMError(
-                f"{self.name}: transport error: {exc}",
+                f"{self.name}: transport error: {describe_transport_error(exc)}",
                 kind="transport",
                 provider=self.name,
+                proxy=None if self.force_direct else egress_path(self.base_url).proxy,
             ) from exc
 
     # ------------------------------------------------------------------

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/llm/openai_responses.py

@@ -25,10 +25,15 @@ from steerable_agent_protocol.generated import ToolCall
 
 from ..model_info import ReasoningEffortUnsupported, clamp_reasoning_effort
 from . import LLMMessage, LLMStreamChunk, LLMUsage
-from .errors import LLMError, classify_http_status, parse_retry_after_ms
+from .errors import (
+    LLMError,
+    classify_http_status,
+    describe_transport_error,
+    parse_retry_after_ms,
+)
 from .parts import ImagePart, TextPart
 from .presets import ProviderPreset, preset_for
-from .system_proxy import client_env_kwargs
+from .system_proxy import client_env_kwargs, egress_path
 
 logger = logging.getLogger(__name__)
 
@@ -75,6 +80,9 @@ class OpenAIResponsesProvider:
     api_key: str | None = None
     default_temperature: float | None = None
     preset: ProviderPreset | Literal["auto", "off"] = "auto"
+    #: Send this endpoint's requests direct even when the host declares a
+    #: proxy (see `OpenAICompatProvider.force_direct`).
+    force_direct: bool = False
     #: Per-request reasoning effort from the host's model picker; wins over
     #: ``STEERABLE_REASONING_EFFORT`` and the preset default. Explicitly
     #: requested effort is validated strict (``clamp_reasoning_effort``) —
@@ -112,7 +120,7 @@ class OpenAIResponsesProvider:
         try:
             async with httpx.AsyncClient(
                 timeout=httpx.Timeout(60.0),
-                **client_env_kwargs(self.base_url),
+                **client_env_kwargs(self.base_url, force_direct=self.force_direct),
             ) as client:
                 response = await client.post(
                     f"{self.base_url.rstrip('/')}/responses",
@@ -126,9 +134,10 @@ class OpenAIResponsesProvider:
                 payload = response.json()
         except httpx.TransportError as exc:
             raise LLMError(
-                f"{self.name}: transport error: {exc}",
+                f"{self.name}: transport error: {describe_transport_error(exc)}",
                 kind="transport",
                 provider=self.name,
+                proxy=None if self.force_direct else egress_path(self.base_url).proxy,
             ) from exc
 
         if payload.get("status") == "failed" or payload.get("error"):
@@ -163,7 +172,7 @@ class OpenAIResponsesProvider:
             async with (
                 httpx.AsyncClient(
                     timeout=_stream_timeout(),
-                    **client_env_kwargs(self.base_url),
+                    **client_env_kwargs(self.base_url, force_direct=self.force_direct),
                 ) as client,
                 client.stream(
                     "POST",
@@ -207,9 +216,10 @@ class OpenAIResponsesProvider:
                     yield LLMStreamChunk(tool_call_delta=call)
         except httpx.TransportError as exc:
             raise LLMError(
-                f"{self.name}: transport error: {exc}",
+                f"{self.name}: transport error: {describe_transport_error(exc)}",
                 kind="transport",
                 provider=self.name,
+                proxy=None if self.force_direct else egress_path(self.base_url).proxy,
             ) from exc
 
     # ------------------------------------------------------------------

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/llm/system_proxy.py

@@ -46,7 +46,8 @@ import os
 import urllib.request
 from collections.abc import Callable, Mapping
 from functools import lru_cache
-from urllib.parse import urlsplit
+from typing import NamedTuple
+from urllib.parse import urlsplit, urlunsplit
 
 #: The desktop sets this alongside the proxy variables when it confines the
 #: sidecar's egress to its per-host proxy, and never on the startup-failure
@@ -117,6 +118,22 @@ def direct_mounts(
     return _pin_direct(host)
 
 
+@lru_cache(maxsize=1)
+def _platform_proxies() -> tuple[tuple[str, str], ...]:
+    """The platform's own proxy map, read once per process.
+
+    `urllib.request.getproxies` reaches System Configuration on macOS and the
+    registry on Windows; a failure report must not pay that round trip on
+    every request.
+    """
+    try:
+        return tuple(
+            (key, value) for key, value in urllib.request.getproxies().items() if value
+        )
+    except Exception:
+        return ()
+
+
 def _egress_is_confined() -> bool:
     return (os.environ.get(_EGRESS_CONFINED_ENV) or "").strip() == "1"
 
@@ -136,9 +153,114 @@ def _unbuildable_proxy_schemes(
     return missing
 
 
+class EgressPath(NamedTuple):
+    """How a provider request to `base_url` leaves this process.
+
+    `proxy` is the client-side proxy address without credentials, or None for a
+    direct connection. It is what a failure report shows: the address alone
+    tells the reader which hop to inspect, while credentials would leak into
+    logs and copied diagnostics.
+    """
+
+    proxy: str | None
+
+    @property
+    def uses_proxy(self) -> bool:
+        return self.proxy is not None
+
+
+def _redacted_proxy_url(value: str) -> str:
+    """Proxy URL without userinfo; a bare `host:port` is returned as written."""
+    candidate = value if "://" in value else f"http://{value}"
+    parts = urlsplit(candidate)
+    host = parts.netloc.rpartition("@")[2]
+    return urlunsplit((parts.scheme, host, parts.path, "", ""))
+
+
+def _proxy_for_scheme(
+    proxies: Mapping[str, str],
+    *,
+    scheme: str,
+    env_bypass: Callable[[str], bool],
+    platform_list_bypass: Callable[[str], bool],
+    host: str | None,
+) -> str | None:
+    """The declared proxy `host` would use, or None when it is exempt."""
+    if host and (env_bypass(host) or platform_list_bypass(host)):
+        return None
+    for key in (scheme, "all"):
+        declared = proxies.get(key)
+        if declared:
+            return _redacted_proxy_url(declared)
+    return None
+
+
+def egress_path(
+    base_url: str,
+    *,
+    env_proxies: Callable[[], Mapping[str, str]] = urllib.request.getproxies_environment,
+    platform_proxies: Callable[[], Mapping[str, str]] = lambda: dict(_platform_proxies()),
+    platform_bypass: Callable[[str], bool] = _platform_says_direct,
+    env_bypass: Callable[[str], bool] = urllib.request.proxy_bypass_environment,
+    platform_list_bypass: Callable[[str], bool] = _platform_list_says_direct,
+    confined: Callable[[], bool] = _egress_is_confined,
+) -> EgressPath:
+    """Which hop a request to `base_url` takes, for failure reports.
+
+    Mirrors `client_env_kwargs` rather than re-deciding: environment proxies
+    first, the platform's own proxy map when the environment declares none
+    (httpx reads `getproxies()` under `trust_env`), the confinement marker,
+    and the two bypass lists. It answers only what a report should show.
+    """
+    host = urlsplit(base_url).hostname
+    scheme = urlsplit(base_url).scheme or "https"
+    proxies = env_proxies()
+    if not proxies:
+        if direct_mounts(
+            base_url, env_proxies=lambda: proxies, platform_bypass=platform_bypass
+        ):
+            return EgressPath(proxy=None)
+        proxies = platform_proxies()
+    if confined():
+        declared = next(iter(proxies.values()), "")
+        return EgressPath(proxy=_redacted_proxy_url(declared) if declared else None)
+    return EgressPath(
+        proxy=_proxy_for_scheme(
+            proxies,
+            scheme=scheme,
+            env_bypass=env_bypass,
+            platform_list_bypass=platform_list_bypass,
+            host=host,
+        )
+    )
+
+
+def _direct_pin_or_trust_env(
+    base_url: str,
+    proxies: Mapping[str, str],
+    *,
+    has_module: Callable[[str], bool],
+) -> dict[str, None] | None:
+    """A direct pin for `base_url`, or None when the pin cannot be built.
+
+    httpx builds a transport for every declared proxy while constructing the
+    client, so one unbuildable scheme fails the whole client no matter which
+    pattern the request matches. When that happens the caller must fall back to
+    `trust_env=False`, which is the only way to keep this host out of a proxy
+    map that cannot be assembled.
+    """
+    host = urlsplit(base_url).hostname
+    if not host:
+        return None
+    if proxies and _unbuildable_proxy_schemes(proxies, has_module=has_module):
+        return None
+    return _pin_direct(host)
+
+
 def client_env_kwargs(
     base_url: str,
     *,
+    force_direct: bool = False,
     env_proxies: Callable[[], Mapping[str, str]] = urllib.request.getproxies_environment,
     platform_bypass: Callable[[str], bool] = _platform_says_direct,
     env_bypass: Callable[[str], bool] = urllib.request.proxy_bypass_environment,
@@ -157,7 +279,17 @@ def client_env_kwargs(
 
     An empty dict leaves httpx's own environment handling untouched: the endpoint
     is proxied as declared, or confined egress owns every host.
+
+    `force_direct` overrides all of that for one endpoint: the user asked this
+    model service to connect directly, typically after a proxy turned a working
+    connection into a timeout. It cannot override confined egress — that
+    declaration owns every host, and the host's own sandbox decides reachability
+    — so it resolves to `trust_env=False` there, which is what keeps the
+    per-host egress proxy out of the request.
     """
+    if force_direct:
+        pinned = _direct_pin_or_trust_env(base_url, env_proxies(), has_module=has_module)
+        return {"trust_env": False} if pinned is None else {"mounts": pinned}
     proxies = env_proxies()
     if not proxies:
         mounts = direct_mounts(

{steerable_agent_runtime-0.7.4 → steerable_agent_runtime-0.8.1}/src/steerable_agent_runtime/native_bridge.py

@@ -308,6 +308,7 @@ async def _collect_stream(
             status_code=getattr(exc, "status_code", None),
             provider=getattr(exc, "provider", None),
             retry_after_ms=getattr(exc, "retry_after_ms", None),
+            proxy=getattr(exc, "proxy", None),
         )
         return
     display_tail = stripper.feed(content_carry) + stripper.flush()
@@ -470,6 +471,7 @@ async def _on_request_error(
         status_code=error_raw.get("status_code"),
         provider=error_raw.get("provider"),
         retry_after_ms=error_raw.get("retry_after_ms"),
+        proxy=error_raw.get("proxy"),
     )
     transcript = [_msg_from_json(item) for item in raw.get("transcript", [])]
     loop._run_context.round_index = int(raw.get("round_index") or 0)