fix(obs): read litellm's provider list defensively, and say so if it goes

CI's lint job runs pyright, which `ruff check` alone does not: two errors, both
mine — `"openai_compatible_providers" is not exported from module "litellm"`
(reportPrivateImportUsage). Pyright is right. The attribute is real at runtime
but is not in litellm's `__all__`, so it is not a promised export and a future
release may rename or drop it.

Read via `getattr` now, which fixes the lint and, more to the point, degrades
instead of raising if it does disappear.

But degrading quietly would silently re-introduce the exact double counting the
previous commit fixed: without litellm's list only five providers are known to
reach the model over the OpenAI client, so groq, deepseek, xai and ~50 others
would look native again and be recorded twice — once here and once by the
OpenAI client instrumentor. So the fallback warns and names what it can no
longer recognise. Covered by a test that deletes the attribute and asserts both
halves: azure still resolves, groq no longer does, and the warning fires.

Verified with the real CI entry points rather than a subset: `./scripts/lint`
(ruff over the whole tree, pyright, import check) and `./scripts/check-slim-deps`
both clean. Tests 34 in this file, 1714 repo-wide.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: stephen-wang24

src/agentex/lib/core/adapters/llm/_genai_metrics.py

@@ -62,14 +62,32 @@ def _over_openai_client(provider: str) -> bool:
     """
     global _openai_client_providers
     if _openai_client_providers is _OPENAI_CLIENT_PROVIDERS_UNRESOLVED:
+        compatible: Any = None
         try:
             import litellm
 
+            # Read via getattr: the attribute is not in litellm's __all__, so it is
+            # not a promised export and a future release may rename or drop it.
+            compatible = getattr(litellm, "openai_compatible_providers", None)
+        except Exception:  # pragma: no cover - litellm is a hard dependency
+            compatible = None
+
+        if compatible:
             _openai_client_providers = (
-                frozenset(litellm.openai_compatible_providers)
-                | _EXTRA_OPENAI_CLIENT_PROVIDERS
+                frozenset(compatible) | _EXTRA_OPENAI_CLIENT_PROVIDERS
+            )
+        else:
+            # Degrading quietly here would re-introduce the double counting this
+            # function exists to prevent: every openai-compatible provider would look
+            # native again and be recorded twice. Say so rather than drift.
+            logger.warning(
+                "litellm no longer exposes openai_compatible_providers, so GenAI "
+                "metrics can only recognise %d providers as reaching the model over "
+                "the OpenAI client. Calls to openai-compatible providers such as "
+                "groq or deepseek may now be counted twice, once here and once by "
+                "the OpenAI client instrumentor.",
+                len(_EXTRA_OPENAI_CLIENT_PROVIDERS),
             )
-        except Exception:  # pragma: no cover - litellm is a hard dependency
             _openai_client_providers = _EXTRA_OPENAI_CLIENT_PROVIDERS
     return provider in _openai_client_providers
 

src/agentex/lib/core/adapters/llm/tests/test_genai_metrics.py

@@ -123,11 +123,28 @@ def test_the_provider_list_agrees_with_litellm(self):
 
         from agentex.lib.core.adapters.llm._genai_metrics import _over_openai_client
 
-        for provider in list(litellm.openai_compatible_providers)[:20]:
+        for provider in list(getattr(litellm, "openai_compatible_providers", []))[:20]:
             assert _over_openai_client(provider), provider
         for provider in ("anthropic", "bedrock", "vertex_ai", "gemini"):
             assert not _over_openai_client(provider), provider
 
+    def test_losing_litellms_list_is_not_silent(self, monkeypatch, caplog):
+        """`openai_compatible_providers` is not in litellm's __all__, so it is read
+        defensively. But degrading quietly would re-introduce the double counting this
+        whole function exists to prevent, so the fallback has to be audible."""
+        import litellm
+
+        monkeypatch.delattr(litellm, "openai_compatible_providers", raising=False)
+        _genai_metrics._reset_for_tests()
+
+        with caplog.at_level("WARNING", logger=_genai_metrics.logger.name):
+            # The five explicit ones still work; the ~50 from litellm no longer do.
+            assert _genai_metrics._over_openai_client("azure") is True
+            assert _genai_metrics._over_openai_client("groq") is False
+        assert any("openai_compatible_providers" in r.message for r in caplog.records), [
+            r.message for r in caplog.records
+        ]
+
     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