remove patcher config for now

Author: AbhiPrasad

.agents/skills/sdk-integrations/SKILL.md

@@ -92,7 +92,7 @@ Patchers must provide:
 - existence checks
 - idempotence through the base patcher marker
 
-Use `IntegrationPatchConfig` only when users need patcher-level selection. Let `BaseIntegration.resolve_patchers()` reject unknown patcher ids instead of silently ignoring them.
+Let `BaseIntegration.resolve_patchers()` reject duplicate patcher ids instead of silently ignoring them.
 
 ## Patching Patterns
 
@@ -116,14 +116,11 @@ Use:
 
 Update `py/src/braintrust/auto.py` only if the integration should be auto-patched.
 
-Use `InstrumentOption` (i.e. `bool | IntegrationPatchConfig`) for all integrations, including those that do not yet use the integrations API. This keeps the signature uniform and avoids a breaking change when the integration is later migrated.
-
-Use `_normalize_instrument_option()` and `_instrument_integration(...)` instead of adding a custom `_instrument_*` function:
+All `auto_instrument()` parameters are plain `bool` flags. Use `_instrument_integration(...)` instead of adding a custom `_instrument_*` function:
 
 ```python
-enabled, config = _normalize_instrument_option("provider", provider)
-if enabled:
-    results["provider"] = _instrument_integration(ProviderIntegration, patch_config=config)
+if provider:
+    results["provider"] = _instrument_integration(ProviderIntegration)
 ```
 
 Add the integration import near the other integration imports in `auto.py`.
@@ -147,7 +144,7 @@ Cover the surfaces that changed:
 - streaming behavior
 - idempotence
 - failure and error logging
-- patcher selection when using `IntegrationPatchConfig`
+- patcher resolution and duplicate detection
 
 Keep VCR cassettes in `py/src/braintrust/integrations/<provider>/cassettes/`. Re-record them only for intentional behavior changes.
 
@@ -173,8 +170,6 @@ cd py && make lint
 - Moving provider-specific behavior into shared integration code.
 - Combining unrelated targets into one patcher.
 - Forgetting async or streaming coverage.
-- Adding patcher selection without tests for enabled and disabled cases.
 - Re-recording cassettes when behavior did not intentionally change.
-- Using `_normalize_bool_option()` instead of `_normalize_instrument_option()` — all integrations should accept `InstrumentOption`.
 - Adding a custom `_instrument_*` helper where `_instrument_integration()` already fits.
 - Forgetting `target_module` for deep or optional submodule patch targets.

py/src/braintrust/__init__.py

@@ -63,7 +63,6 @@ def is_equal(expected, output):
 
 from .audit import *
 from .auto import (
-    IntegrationPatchConfig,  # noqa: F401 # type: ignore[reportUnusedImport]
     auto_instrument,  # noqa: F401 # type: ignore[reportUnusedImport]
 )
 from .framework import *

py/src/braintrust/auto.py

@@ -4,18 +4,15 @@
 Provides one-line instrumentation for supported libraries.
 """
 
-from __future__ import annotations
-
 import logging
 from contextlib import contextmanager
 
-from braintrust.integrations import ADKIntegration, AnthropicIntegration, IntegrationPatchConfig
+from braintrust.integrations import ADKIntegration, AnthropicIntegration
 
 
 __all__ = ["auto_instrument"]
 
 logger = logging.getLogger(__name__)
-InstrumentOption = bool | IntegrationPatchConfig
 
 
 @contextmanager
@@ -32,14 +29,14 @@ def _try_patch():
 def auto_instrument(
     *,
     openai: bool = True,
-    anthropic: InstrumentOption = True,
+    anthropic: bool = True,
     litellm: bool = True,
     pydantic_ai: bool = True,
     google_genai: bool = True,
     agno: bool = True,
     claude_agent_sdk: bool = True,
     dspy: bool = True,
-    adk: InstrumentOption = True,
+    adk: bool = True,
 ) -> dict[str, bool]:
     """
     Auto-instrument supported AI/ML libraries for Braintrust tracing.
@@ -52,8 +49,7 @@ def auto_instrument(
 
     Args:
         openai: Enable OpenAI instrumentation (default: True)
-        anthropic: Enable Anthropic instrumentation (default: True), or pass an
-            IntegrationPatchConfig to select Anthropic patchers explicitly.
+        anthropic: Enable Anthropic instrumentation (default: True)
         litellm: Enable LiteLLM instrumentation (default: True)
         pydantic_ai: Enable Pydantic AI instrumentation (default: True)
         google_genai: Enable Google GenAI instrumentation (default: True)
@@ -108,34 +104,24 @@ def auto_instrument(
     """
     results = {}
 
-    openai_enabled = _normalize_bool_option("openai", openai)
-    anthropic_enabled, anthropic_config = _normalize_instrument_option("anthropic", anthropic)
-    litellm_enabled = _normalize_bool_option("litellm", litellm)
-    pydantic_ai_enabled = _normalize_bool_option("pydantic_ai", pydantic_ai)
-    google_genai_enabled = _normalize_bool_option("google_genai", google_genai)
-    agno_enabled = _normalize_bool_option("agno", agno)
-    claude_agent_sdk_enabled = _normalize_bool_option("claude_agent_sdk", claude_agent_sdk)
-    dspy_enabled = _normalize_bool_option("dspy", dspy)
-    adk_enabled, adk_config = _normalize_instrument_option("adk", adk)
-
-    if openai_enabled:
+    if openai:
         results["openai"] = _instrument_openai()
-    if anthropic_enabled:
-        results["anthropic"] = _instrument_integration(AnthropicIntegration, patch_config=anthropic_config)
-    if litellm_enabled:
+    if anthropic:
+        results["anthropic"] = _instrument_integration(AnthropicIntegration)
+    if litellm:
         results["litellm"] = _instrument_litellm()
-    if pydantic_ai_enabled:
+    if pydantic_ai:
         results["pydantic_ai"] = _instrument_pydantic_ai()
-    if google_genai_enabled:
+    if google_genai:
         results["google_genai"] = _instrument_google_genai()
-    if agno_enabled:
+    if agno:
         results["agno"] = _instrument_agno()
-    if claude_agent_sdk_enabled:
+    if claude_agent_sdk:
         results["claude_agent_sdk"] = _instrument_claude_agent_sdk()
-    if dspy_enabled:
+    if dspy:
         results["dspy"] = _instrument_dspy()
-    if adk_enabled:
-        results["adk"] = _instrument_integration(ADKIntegration, patch_config=adk_config)
+    if adk:
+        results["adk"] = _instrument_integration(ADKIntegration)
 
     return results
 
@@ -148,34 +134,12 @@ def _instrument_openai() -> bool:
     return False
 
 
-def _instrument_integration(integration, *, patch_config: IntegrationPatchConfig | None = None) -> bool:
+def _instrument_integration(integration) -> bool:
     with _try_patch():
-        return integration.setup(
-            enabled_patchers=patch_config.enabled_patchers if patch_config is not None else None,
-            disabled_patchers=patch_config.disabled_patchers if patch_config is not None else None,
-        )
+        return integration.setup()
     return False
 
 
-def _normalize_bool_option(name: str, option: bool) -> bool:
-    if isinstance(option, bool):
-        return option
-
-    raise TypeError(f"auto_instrument option {name!r} must be a bool, got {type(option).__name__}")
-
-
-def _normalize_instrument_option(name: str, option: InstrumentOption) -> tuple[bool, IntegrationPatchConfig | None]:
-    if isinstance(option, bool):
-        return option, None
-
-    if isinstance(option, IntegrationPatchConfig):
-        return True, option
-
-    raise TypeError(
-        f"auto_instrument option {name} must be a bool or IntegrationPatchConfig, got {type(option).__name__}"
-    )
-
-
 def _instrument_litellm() -> bool:
     with _try_patch():
         from braintrust.wrappers.litellm import patch_litellm

py/src/braintrust/integrations/__init__.py

@@ -1,6 +1,5 @@
 from .adk import ADKIntegration
 from .anthropic import AnthropicIntegration
-from .base import IntegrationPatchConfig
 
 
-__all__ = ["ADKIntegration", "AnthropicIntegration", "IntegrationPatchConfig"]
+__all__ = ["ADKIntegration", "AnthropicIntegration"]

py/src/braintrust/integrations/anthropic/test_anthropic.py

@@ -512,18 +512,6 @@ def test_available_patchers(self):
             "anthropic.init.async",
         )
 
-    def test_resolve_patchers_honors_enable_disable_filters(self):
-        selected = AnthropicIntegration.resolve_patchers(
-            enabled_patchers={"anthropic.init.sync", "anthropic.init.async"},
-            disabled_patchers={"anthropic.init.async"},
-        )
-
-        assert tuple(patcher.identifier() for patcher in selected) == ("anthropic.init.sync",)
-
-    def test_resolve_patchers_rejects_unknown_patchers(self):
-        with pytest.raises(ValueError, match="Unknown patchers"):
-            AnthropicIntegration.resolve_patchers(enabled_patchers={"anthropic.init.unknown"})
-
     def test_setup_rejects_unsupported_versions(self):
         spec = make_specifier(
             min_version=AnthropicIntegration.min_version, max_version=AnthropicIntegration.max_version

py/src/braintrust/integrations/auto_test_scripts/test_auto_anthropic_patch_config.py

@@ -4,23 +4,14 @@
 import inspect
 import re
 from abc import ABC, abstractmethod
-from collections.abc import Collection, Iterable
-from dataclasses import dataclass
+from collections.abc import Iterable
 from typing import Any, ClassVar
 
 from wrapt import wrap_function_wrapper
 
 from .versioning import detect_module_version, make_specifier, version_satisfies
 
 
-@dataclass(frozen=True)
-class IntegrationPatchConfig:
-    """Per-integration patch selection for instrumentation setup."""
-
-    enabled_patchers: Collection[str] | None = None
-    disabled_patchers: Collection[str] | None = None
-
-
 class BasePatcher(ABC):
     """Base class for one concrete integration patch strategy."""
 
@@ -229,13 +220,8 @@ def available_patchers(cls) -> tuple[str, ...]:
         return tuple(patcher.identifier() for patcher in cls.patchers)
 
     @classmethod
-    def resolve_patchers(
-        cls,
-        *,
-        enabled_patchers: Collection[str] | None = None,
-        disabled_patchers: Collection[str] | None = None,
-    ) -> tuple[type[BasePatcher], ...]:
-        """Return the selected patchers after validating explicit selectors."""
+    def resolve_patchers(cls) -> tuple[type[BasePatcher], ...]:
+        """Return all patchers after validating there are no duplicate identifiers."""
         patchers_by_id: dict[str, type[BasePatcher]] = {}
         for patcher in cls.patchers:
             patcher_id = patcher.identifier()
@@ -244,30 +230,13 @@ def resolve_patchers(
                 raise ValueError(f"Duplicate patcher identifier {patcher_id!r} for integration {cls.name!r}")
             patchers_by_id[patcher_id] = patcher
 
-        enabled = set(enabled_patchers) if enabled_patchers is not None else None
-        disabled = set(disabled_patchers or ())
-        requested = disabled if enabled is None else enabled | disabled
-        unknown = requested - set(patchers_by_id)
-        if unknown:
-            available = ", ".join(sorted(patchers_by_id))
-            unknown_display = ", ".join(sorted(unknown))
-            raise ValueError(
-                f"Unknown patchers for integration {cls.name!r}: {unknown_display}. Available patchers: {available}"
-            )
-
-        return tuple(
-            patcher
-            for patcher in cls.patchers
-            if (enabled is None or patcher.identifier() in enabled) and patcher.identifier() not in disabled
-        )
+        return cls.patchers
 
     @classmethod
     def setup(
         cls,
         *,
         target: Any | None = None,
-        enabled_patchers: Collection[str] | None = None,
-        disabled_patchers: Collection[str] | None = None,
     ) -> bool:
         """Apply all applicable patchers for this integration."""
         module = _import_first_available(cls.import_names)
@@ -278,10 +247,7 @@ def setup(
             return False
 
         success = False
-        selected_patchers = cls.resolve_patchers(
-            enabled_patchers=enabled_patchers,
-            disabled_patchers=disabled_patchers,
-        )
+        selected_patchers = cls.resolve_patchers()
         for patcher in sorted(selected_patchers, key=lambda patcher: patcher.priority):
             if not patcher.applies(module, version, target=target):
                 continue

py/src/braintrust/integrations/base.py

@@ -58,45 +58,10 @@ def test_anthropic_integration_setup_is_idempotent(self):
         assert result.returncode == 0, f"Failed: {result.stderr}"
         assert "SUCCESS" in result.stdout
 
-    def test_anthropic_integration_setup_can_disable_specific_patchers(self):
-        result = run_in_subprocess("""
-            from braintrust.integrations.anthropic import AnthropicIntegration
-            import anthropic
-
-            AnthropicIntegration.setup(disabled_patchers={"anthropic.init.async"})
-            patched_sync = anthropic.Anthropic(api_key="test-key")
-            unpatched_async = anthropic.AsyncAnthropic(api_key="test-key")
-
-            assert type(patched_sync.messages).__module__ == "braintrust.integrations.anthropic.tracing"
-            assert type(unpatched_async.messages).__module__.startswith("anthropic.")
-            print("SUCCESS")
-        """)
-        assert result.returncode == 0, f"Failed: {result.stderr}"
-        assert "SUCCESS" in result.stdout
-
 
 class TestAutoInstrumentAnthropic:
     """Tests for auto_instrument() with Anthropic."""
 
     def test_auto_instrument_anthropic(self):
         """Test auto_instrument patches Anthropic, creates spans, and uninstrument works."""
         verify_autoinstrument_script("test_auto_anthropic.py")
-
-    def test_auto_instrument_anthropic_patch_config(self):
-        verify_autoinstrument_script("test_auto_anthropic_patch_config.py")
-
-    def test_auto_instrument_rejects_non_bool_option_for_openai(self):
-        result = run_in_subprocess("""
-            from braintrust.auto import auto_instrument
-            from braintrust.integrations import IntegrationPatchConfig
-
-            try:
-                auto_instrument(openai=IntegrationPatchConfig())
-            except TypeError as exc:
-                assert "must be a bool" in str(exc)
-                print("SUCCESS")
-            else:
-                raise AssertionError("Expected TypeError")
-        """)
-        assert result.returncode == 0, f"Failed: {result.stderr}"
-        assert "SUCCESS" in result.stdout