@@ -79,45 +79,20 @@
 _openai_client_providers: Any = _OPENAI_CLIENT_PROVIDERS_UNRESOLVED
 
 
-def _openai_client_provider_set() -> frozenset[str] | None:
-    """Providers litellm dispatches over the ``openai`` client, or None if unknowable.
+def _over_openai_client(provider: str) -> bool:
+    """Would the OpenAI client instrumentor already have recorded this call?
 
-    Imported from ``litellm.constants``, which is where the list is defined, rather
-    than from the ``litellm`` top level, which is an incidental re-export: litellm
-    declares no ``__all__``, so a type checker treats the top-level name as private
-    and it carries no stability promise even informally.
+    Read from ``litellm.constants``, where the list is defined; the ``litellm``
+    top-level name is an incidental re-export (litellm declares no ``__all__``).
     """
     global _openai_client_providers
     if _openai_client_providers is _OPENAI_CLIENT_PROVIDERS_UNRESOLVED:
-        try:
-            from litellm.constants import openai_compatible_providers
-
-            _openai_client_providers = (
-                frozenset(openai_compatible_providers)
-                - _PREEMPTED_BY_OWN_HTTP_HANDLER
-            ) | _EXTRA_OPENAI_CLIENT_PROVIDERS
-        except Exception:  # pragma: no cover - litellm is a hard dependency
-            logger.warning(
-                "litellm.constants.openai_compatible_providers is unavailable, so "
-                "GenAI metrics cannot tell which calls the OpenAI client instrumentor "
-                "already records. Recording anyway would double-count every "
-                "openai-compatible provider, so litellm gateway metrics are off for "
-                "this process."
-            )
-            _openai_client_providers = None
-    return _openai_client_providers
-
+        from litellm.constants import openai_compatible_providers
 
-def _over_openai_client(provider: str) -> bool | None:
-    """Would the OpenAI client instrumentor already have recorded this call?
-
-    None means "cannot tell", which is NOT the same as False and must not collapse
-    into it: treating an unknown provider as native is what double-counts it.
-    """
-    known = _openai_client_provider_set()
-    if known is None:
-        return None
-    return provider in known
+        _openai_client_providers = (
+            frozenset(openai_compatible_providers) - _PREEMPTED_BY_OWN_HTTP_HANDLER
+        ) | _EXTRA_OPENAI_CLIENT_PROVIDERS
+    return provider in _openai_client_providers
 
 
 _GENAI_UNRESOLVED = object()
@@ -148,7 +123,7 @@ def _genai() -> Any | None:
     return _genai_module
 
 
-def _split_model(model: str) -> tuple[str, bool | None]:
+def _split_model(model: str) -> tuple[str, bool]:
     """``(provider, goes_out_over_the_openai_client)`` for a litellm model string.
 
     ``"litellm_proxy/anthropic/claude-sonnet-4"`` -> ``("anthropic", True)``
@@ -176,9 +151,6 @@ def _split_model(model: str) -> tuple[str, bool | None]:
     one thing the OpenAI client instrumentor cannot report, since from inside that
     client the call is simply "openai".
 
-    A second element of None means the routing table itself could not be read, so
-    whether this call is already recorded elsewhere is unknown. Callers must stand down
-    rather than guess; see :func:`inference_call`.
     """
     proxied = model.startswith(_PROXY_PREFIX)
     rest = model[len(_PROXY_PREFIX):] if proxied else model
@@ -272,13 +244,6 @@ def inference_call(kwargs: dict[str, Any], args: tuple[Any, ...] = ()) -> Any:
     try:
         model = resolve_model(args, kwargs)
         vendor, over_openai_client = _split_model(model)
-        if over_openai_client is None:
-            # The routing table could not be read, so we cannot tell whether the
-            # OpenAI client instrumentor is already recording this call. Recording
-            # would double-count every openai-compatible provider, and a doubled
-            # token or cost figure is worse than a missing one: the gap is visible
-            # and warned about, the doubling is silent and gets believed.
-            return _NULL_CALL
         return genai.call(
             provider=vendor,
             operation=genai.CHAT,
 
@@ -123,27 +123,20 @@ def test_the_proxy_vendor_survives_resolution(self):
             True,
         )
 
-    def test_the_provider_list_agrees_with_litellm(self):
-        """Pinned to litellm's own list rather than a copy of it, because the copy
-        would go stale every release."""
-        import litellm.constants
-
+    def test_the_preempted_providers_are_not_treated_as_openai_client(self):
+        """These eight are in litellm's `openai_compatible_providers` but litellm
+        serves them with its own HTTP client, so the OpenAI instrumentor never sees
+        them and this gateway must record them."""
         from agentex.lib.core.adapters.llm._genai_metrics import (
             _PREEMPTED_BY_OWN_HTTP_HANDLER,
             _over_openai_client,
         )
 
-        compatible = list(litellm.constants.openai_compatible_providers)
-        checked = 0
-        for provider in compatible:
-            if provider in _PREEMPTED_BY_OWN_HTTP_HANDLER:
-                # In the list, but litellm serves it with its own HTTP client.
-                assert not _over_openai_client(provider), provider
-            else:
-                assert _over_openai_client(provider), provider
-            checked += 1
-        assert checked > 20, "expected litellm to list many compatible providers"
-
+        for provider in _PREEMPTED_BY_OWN_HTTP_HANDLER:
+            assert not _over_openai_client(provider), provider
+        # ...while the rest of the list is genuinely over the openai client.
+        for provider in ("together_ai", "deepinfra", "openai", "azure"):
+            assert _over_openai_client(provider), provider
         # Natively routed: no openai client anywhere in the path.
         for provider in ("anthropic", "bedrock", "vertex_ai", "gemini"):
             assert not _over_openai_client(provider), provider
@@ -157,118 +150,6 @@ def test_groq_and_deepseek_are_recorded_here(self):
             provider, over_openai_client = _split_model(model)
             assert over_openai_client is False, f"{provider} would go unrecorded"
 
-    def test_the_preempted_set_still_matches_litellm(self):
-        """Drift guard. `openai_compatible_providers` describes API-format
-        compatibility, not which Python client litellm uses, so we subtract the
-        providers litellm intercepts earlier. That set is derived from litellm 1.87.0's
-        dispatch chain; if an upgrade moves a provider between branches this fails,
-        rather than silently double-counting it or silently losing it.
-
-        Re-derives from the installed litellm's source. If the shape of main.py changes
-        enough that the parse yields nothing, skip rather than fail: an unparseable
-        source is not evidence that the set is wrong.
-        """
-        import re
-
-        import litellm.main
-        from litellm.constants import openai_compatible_providers
-
-        from agentex.lib.core.adapters.llm._genai_metrics import (
-            _PREEMPTED_BY_OWN_HTTP_HANDLER,
-        )
-
-        with open(litellm.main.__file__) as handle:
-            src = handle.read().splitlines()
-        hits = [i for i, line in enumerate(src) if "openai_chat_completions.completion(" in line]
-        if not hits:
-            pytest.skip("litellm/main.py no longer dispatches the way this parse assumes")
-        guard = max(
-            i for i, line in enumerate(src[: hits[0]]) if re.match(r"^        (elif|if) ", line)
-        )
-
-        earlier: set[str] = set()
-        for line in src[:guard]:
-            if re.match(r"^        (elif|if) ", line) or re.match(
-                r"^\s+(or|and)?\s*custom_llm_provider", line
-            ):
-                earlier.update(re.findall(r'custom_llm_provider\s*==\s*"([a-z0-9_\-]+)"', line))
-        if not earlier:
-            pytest.skip("could not parse litellm's dispatch chain")
-
-        actually_preempted = set(openai_compatible_providers) & earlier
-        assert actually_preempted == set(_PREEMPTED_BY_OWN_HTTP_HANDLER), (
-            "litellm's dispatch chain changed. Providers newly intercepted by their own "
-            f"HTTP handler: {sorted(actually_preempted - set(_PREEMPTED_BY_OWN_HTTP_HANDLER))}; "
-            "no longer intercepted: "
-            f"{sorted(set(_PREEMPTED_BY_OWN_HTTP_HANDLER) - actually_preempted)}"
-        )
-
-    def test_an_unknown_routing_table_stands_down_rather_than_guessing(
-        self, monkeypatch, caplog
-    ):
-        """If the routing table cannot be read we do not know whether the OpenAI client
-        instrumentor is already recording a call. Recording anyway would double-count
-        every openai-compatible provider, and a doubled token or cost figure is worse
-        than a missing one: the gap is visible and warned about, the doubling is silent
-        and gets believed. So the recorder stands down entirely."""
-        import builtins
-
-        real_import = builtins.__import__
-
-        def no_constants(name, *args, **kwargs):
-            if name == "litellm.constants":
-                raise ImportError("litellm.constants is gone")
-            return real_import(name, *args, **kwargs)
-
-        monkeypatch.setattr(builtins, "__import__", no_constants)
-        _genai_metrics._reset_for_tests()
-
-        with caplog.at_level("WARNING", logger=_genai_metrics.logger.name):
-            assert _genai_metrics._over_openai_client("groq") is None
-            assert _genai_metrics._over_openai_client("anthropic") is None
-            assert _split_model("groq/llama3-8b-8192") == ("groq", None)
-
-        assert any(
-            "openai_compatible_providers is unavailable" in r.message
-            for r in caplog.records
-        ), [r.message for r in caplog.records]
-
-    def test_a_real_sgp_obs_is_not_started_when_routing_is_unknown(self, monkeypatch):
-        """The property that actually protects the data: no record is started at all,
-        rather than one started with a guessed transport."""
-        import sys
-        import builtins
-
-        started = []
-
-        class _Genai:
-            CHAT = "chat"
-            OPENAI_SPEC = "openai"
-            OPENAI = "openai"
-
-            @staticmethod
-            def call(**kwargs):
-                started.append(kwargs)
-                return object()
-
-        module = type(sys)("sgp_obs.metrics")
-        module.genai = _Genai
-        monkeypatch.setitem(sys.modules, "sgp_obs", type(sys)("sgp_obs"))
-        monkeypatch.setitem(sys.modules, "sgp_obs.metrics", module)
-
-        real_import = builtins.__import__
-
-        def no_constants(name, *args, **kwargs):
-            if name == "litellm.constants":
-                raise ImportError("litellm.constants is gone")
-            return real_import(name, *args, **kwargs)
-
-        monkeypatch.setattr(builtins, "__import__", no_constants)
-        _genai_metrics._reset_for_tests()
-
-        assert inference_call({"model": "groq/llama3-8b-8192"}) is _genai_metrics._NULL_CALL
-        assert started == [], "a record was started with an unknown routing table"
-
     def test_an_unresolvable_model_does_not_spam_stdout(self):
         """litellm prints a red "Provider List" banner to STDOUT (not logging, so it
         cannot be filtered) every time resolution fails. Uncached, an agent on a model
 
@@ -61,13 +61,6 @@
 logger = make_logger(__name__)
 
 _status: str | None = None
-
-# Which app, if any, was handed to ``sgp_obs.init()``. ``init()`` is process-wide and is
-# not meant to run twice, but the ASGI instrumentation it installs is per-APP — so a
-# second application arriving later silently gets none of it. Remembered so that case can
-# at least be named; see the warning in :func:`init_sgp_obs`.
-_wired_app: Any = None
-
 # sgp-obs' own truthy set (sgp_obs.env._TRUTHY), so "is the master switch on?" is
 # answered the same way here as in the library deciding whether to wire.
 _TRUTHY = {"1", "true", "yes", "on"}
@@ -88,20 +81,6 @@ def _master_switch_on() -> bool:
     return (os.getenv("SGP_OBS_ENABLED") or "").strip().lower() in _TRUTHY
 
 
-# Lets a deployment keep traces on while turning GenAI model spans off. The bridge is
-# installed by THIS package (sgp_obs.init does not install it, see
-# _install_openai_agents_bridge), so without a gate here there is no way to switch it
-# off short of disabling the traces signal entirely.
-#
-# Default ON: an unset variable must not change what any agent does today.
-_GENAI_SWITCH = "SGP_OBS_GENAI_ENABLED"
-
-
-def _genai_tracing_on() -> bool:
-    raw = (os.getenv(_GENAI_SWITCH) or "").strip().lower()
-    return raw == "" or raw in _TRUTHY
-
-
 def init_sgp_obs(app: Any = None) -> str:
     """Wire sgp-obs if it is installed and enabled. Returns a status; never raises.
 
@@ -113,24 +92,10 @@ def init_sgp_obs(app: Any = None) -> str:
     It is also what installs the trace-context ingress middleware, so an incoming
     ``traceparent`` continues into the agent's spans rather than starting a new trace.
     """
-    global _status, _wired_app
+    global _status
     if _status is not None:
         # init() is not meant to run twice, and a Temporal worker plus an ACP
         # server can both reach this in one process.
-        if _status.startswith("wired") and app is not None and app is not _wired_app:
-            # Everything init() set up process-wide (providers, exporters, the egress
-            # instrumentation) still applies to this app. What does NOT is the per-app
-            # ASGI layer, and that is the half nothing else would report.
-            logger.warning(
-                "sgp-obs was already initialized %s, so this application does not get "
-                "the ASGI instrumentation: no http.server.* for its own entry point, "
-                "and an incoming traceparent starts a new trace instead of continuing "
-                "one. Everything process-wide (model, egress, logs) is unaffected. "
-                "init() cannot safely run twice, so construct whichever application "
-                "serves agent traffic before anything else calls init_sgp_obs() — note "
-                "AgentexWorker.run() initializes without an app.",
-                "without an application" if _wired_app is None else "for a different application",
-            )
         return _status
 
     try:
@@ -190,18 +155,9 @@ def init_sgp_obs(app: Any = None) -> str:
         _hand_logging_to_the_pipeline()
 
     if "traces" in handles:
-        if _genai_tracing_on():
-            _install_openai_agents_bridge()
-        else:
-            logger.info(
-                "%s is set falsey, so the sgp-obs openai-agents bridge was not "
-                "installed; Runner turns will produce no model-operation spans. Other "
-                "traces are unaffected.",
-                _GENAI_SWITCH,
-            )
+        _install_openai_agents_bridge()
         _warn_if_correlation_backend_mismatched()
 
-    _wired_app = app
     _status = "wired:" + ",".join(sorted(handles))
     logger.info("sgp-obs wired (%s)", _status)
     return _status
@@ -387,19 +343,11 @@ async def shutdown_sgp_obs(budget_s: float = SGP_OBS_SHUTDOWN_BUDGET_S) -> None:
     delays nothing else — but it can still burn the grace period the runtime needs to
     exit cleanly, which is what the deadline is for.
 
-    KNOWN LIMIT: the budget bounds how long we *await*, not how long the process takes
-    to exit. If it expires, ``sgp_obs.shutdown()`` has not finished, so the providers it
-    built have not been shut down — and OpenTelemetry's ``TracerProvider`` and
-    ``MeterProvider`` both default to ``shutdown_on_exit=True``, which does
-    ``atexit.register(self.shutdown)``. Those hooks still run at interpreter exit and
-    can flush past this deadline.
-
-    Not fixable from here without reaching into providers this package does not own:
-    unregistering their atexit hooks would also strip the runtime-owned providers that
-    sgp-obs deliberately leaves alone (see the note above about operator injection).
-    The real fix belongs in sgp-obs — build its own providers with
-    ``shutdown_on_exit=False`` now that it offers an explicit ``shutdown()``, or have
-    that ``shutdown()`` take a deadline.
+    KNOWN LIMIT: this bounds how long we await, not how long the process takes to exit.
+    OTel providers default to ``shutdown_on_exit=True``, so on overrun their own atexit
+    hooks still flush. Fixing that belongs in sgp-obs (own providers with
+    ``shutdown_on_exit=False``, or a deadline on its ``shutdown()``); unregistering them
+    from here would also strip runtime-owned providers it deliberately leaves alone.
     """
     if _status is None or not _status.startswith("wired"):
         return
@@ -447,9 +395,8 @@ def _flush() -> None:
 
 
 def _reset_for_tests() -> None:
-    global _status, _wired_app
+    global _status
     _status = None
-    _wired_app = None
     # The logging hand-over is a process-wide latch too, and a test that wired the
     # logs signal would otherwise leave make_logger attaching nothing for the rest
     # of the session.