fix(dspy): keep LiteLLM's 3MB price map out of the cassette

CI failed test_dspy(latest) on Windows across 3.11-3.14. Two separate
problems, both from the LiteLLM 1.100.1 -> 1.102.0 bump.

1.102.0 fetches model_prices_and_context_window.json from GitHub on import.
My earlier re-record captured it, which both bloated the cassette by ~3MB and
displaced the tiktoken cl100k_base download that CI needs and my machine
(warm tiktoken cache) never makes. Setting LITELLM_LOCAL_MODEL_COST_MAP keeps
the fetch off the wire entirely, so the cassette goes back to being about the
traffic under test -- it is now byte-identical to main again.

The env var is scoped to the DSPy session on purpose: an older LiteLLM's
bundled map does not know newer model names, and test_litellm(1.74.0) fails
provider resolution for gpt-image-1-mini under it.

Also make patcher module resolution consult sys.modules before importlib.
Separately, test_mistral(latest) failed on ubuntu/3.10 with
`KeyError: <thread id>` raised from importlib._bootstrap while resolve_root()
imported mistralai.client.chat -- CPython 3.10's re-entrancy bookkeeping
tripping over our own lock traffic. We call import_module for every patcher on
every setup(), almost always for a module that is already imported, so the
sys.modules fast path removes nearly all of it. That failure does not
reproduce locally (3/3 green on 3.10), so this is a mitigation rather than a
proven cure; it is a worthwhile change on its own merits either way.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: AbhiPrasad

py/noxfile.py

@@ -363,6 +363,15 @@ def test_openai_agents(session, version):
 
 LITELLM_VERSIONS = _get_matrix_versions("litellm")
 
+# LiteLLM >= 1.102.0 fetches model_prices_and_context_window.json from GitHub on
+# import. Recording that lands a ~3MB blob in the cassette, so force the bundled
+# copy instead and keep the fetch off the wire.
+#
+# Only safe where the tests stick to chat completions: the bundled map of an
+# older LiteLLM does not know newer model names, and test_litellm(1.74.0) fails
+# provider resolution for gpt-image-1-mini under it. Scoped to DSPy for now.
+_LITELLM_LOCAL_COST_MAP = {"LITELLM_LOCAL_MODEL_COST_MAP": "True"}
+
 
 @nox.session()
 @nox.parametrize("version", LITELLM_VERSIONS, ids=LITELLM_VERSIONS)
@@ -597,7 +606,7 @@ def test_dspy(session, version):
         # dependency resolution does not select that incompatible release.
         _install_matrix_dep(session, "litellm", LATEST)
     _install_matrix_dep(session, "dspy", version)
-    _run_tests(session, f"{INTEGRATION_DIR}/dspy/test_dspy.py", version=version)
+    _run_tests(session, f"{INTEGRATION_DIR}/dspy/test_dspy.py", version=version, env=_LITELLM_LOCAL_COST_MAP)
 
 
 CREWAI_VERSIONS = _get_matrix_versions("crewai")

py/src/braintrust/integrations/base.py

@@ -93,10 +93,7 @@ def resolve_root(cls, module: Any | None, version: str | None, *, target: Any |
         if target is not None:
             return target
         if cls.target_module is not None:
-            try:
-                return importlib.import_module(cls.target_module)
-            except ImportError:
-                return None
+            return _import_optional_module(cls.target_module)
         return module
 
     @classmethod
@@ -147,10 +144,7 @@ def resolve_scan_root(cls, module: Any | None, version: str | None, *, target: A
         if target is not None:
             return target
         if cls.target_module is not None:
-            try:
-                return importlib.import_module(cls.target_module)
-            except ImportError:
-                return None
+            return _import_optional_module(cls.target_module)
         return module
 
     @classmethod
@@ -274,10 +268,7 @@ def resolve_root(cls, module: Any | None, version: str | None, *, target: Any |
         if target is not None:
             return target
         if cls.target_module is not None:
-            try:
-                return importlib.import_module(cls.target_module)
-            except ImportError:
-                return None
+            return _import_optional_module(cls.target_module)
         return module
 
     @classmethod
@@ -636,13 +627,30 @@ def detect_version(cls, module: Any) -> str | None:
         return detect_module_version(module, cls.import_names)
 
 
+def _import_optional_module(name: str) -> Any | None:
+    """Return the named module, or ``None`` when it cannot be imported.
+
+    ``sys.modules`` is consulted first so an already-imported module never
+    reacquires the import lock. Patcher resolution calls this for every
+    patcher on every ``setup()``, and on CPython 3.10 that lock traffic can
+    trip the interpreter's own re-entrancy bookkeeping, surfacing as
+    ``KeyError: <thread id>`` from ``importlib._bootstrap``.
+    """
+    module = sys.modules.get(name)
+    if module is not None:
+        return module
+    try:
+        return importlib.import_module(name)
+    except ImportError:
+        return None
+
+
 def _import_first_available(import_names: Iterable[str]) -> Any | None:
     """Import and return the first available module from the given names."""
     for import_name in import_names:
-        try:
-            return importlib.import_module(import_name)
-        except ImportError:
-            continue
+        module = _import_optional_module(import_name)
+        if module is not None:
+            return module
     return None