braintrust 0.4.1__tar.gz → 0.4.2__tar.gz

{braintrust-0.4.1 → braintrust-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braintrust
-Version: 0.4.1
+Version: 0.4.2
 Summary: SDK for integrating Braintrust
 Home-page: https://www.braintrust.dev
 Author: Braintrust

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/db_fields.py

@@ -5,6 +5,7 @@ ID_FIELD = "id"
 
 IS_MERGE_FIELD = "_is_merge"
 MERGE_PATHS_FIELD = "_merge_paths"
+ARRAY_DELETE_FIELD = "_array_delete"
 
 AUDIT_SOURCE_FIELD = "_audit_source"
 AUDIT_METADATA_FIELD = "_audit_metadata"

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/framework.py

@@ -1559,9 +1559,9 @@ def build_local_summary(
     scores_by_name = defaultdict(lambda: (0, 0))
     for result in results:
         for name, score in result.scores.items():
-            curr = scores_by_name[name]
-            if curr is None:
+            if score is None:
                 continue
+            curr = scores_by_name[name]
             scores_by_name[name] = (curr[0] + score, curr[1] + 1)
     longest_score_name = max(len(name) for name in scores_by_name) if scores_by_name else 0
     avg_scores = {

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/logger.py

@@ -3856,9 +3856,6 @@ class SpanImpl(Span):
         if serializable_partial_record.get("metrics", {}).get("end") is not None:
             self._logged_end_time = serializable_partial_record["metrics"]["end"]
 
-        if len(serializable_partial_record.get("tags", [])) > 0 and self.span_parents:
-            raise Exception("Tags can only be logged to the root span")
-
         def compute_record() -> dict[str, Any]:
             exporter = _get_exporter()
             return dict(

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/otel/__init__.py

@@ -90,18 +90,13 @@ class AISpanProcessor:
     def _should_keep_filtered_span(self, span):
         """
         Keep spans if:
-        1. It's a root span (no parent)
-        2. Custom filter returns True/False (if provided)
-        3. Span name starts with 'gen_ai.', 'braintrust.', 'llm.', 'ai.', or 'traceloop.'
-        4. Any attribute name starts with those prefixes
+        1. Custom filter returns True/False (if provided)
+        2. Span name starts with 'gen_ai.', 'braintrust.', 'llm.', 'ai.', or 'traceloop.'
+        3. Any attribute name starts with those prefixes
         """
         if not span:
             return False
 
-        # Braintrust requires root spans, so always keep them
-        if span.parent is None:
-            return True
-
         # Apply custom filter if provided
         if self._custom_filter:
             custom_result = self._custom_filter(span)
@@ -384,6 +379,9 @@ def _get_braintrust_parent(object_type, object_id: str | None = None, compute_ar
 
     return None
 
+def is_root_span(span) -> bool:
+    """Returns True if the span is a root span (no parent span)."""
+    return getattr(span, "parent", None) is None
 
 def context_from_span_export(export_str: str):
     """
@@ -522,15 +520,17 @@ def add_span_parent_to_baggage(span, ctx=None):
     return add_parent_to_baggage(parent_value, ctx=ctx)
 
 
-def parent_from_headers(headers: dict[str, str]) -> str | None:
+def parent_from_headers(headers: dict[str, str], propagator=None) -> str | None:
     """
-    Extract a Braintrust-compatible parent string from W3C Trace Context headers.
+    Extract a Braintrust-compatible parent string from trace context headers.
 
-    This converts OTEL trace context headers (traceparent/baggage) into a format
-    that can be passed as the 'parent' parameter to Braintrust's start_span() method.
+    This converts OTEL trace context headers into a format that can be passed
+    as the 'parent' parameter to Braintrust's start_span() method.
 
     Args:
-        headers: Dictionary with 'traceparent' and optionally 'baggage' keys
+        headers: Dictionary with trace context headers (e.g., 'traceparent'/'baggage' for W3C)
+        propagator: Optional custom TextMapPropagator. If not provided, uses the
+                   globally registered propagator (W3C TraceContext by default).
 
     Returns:
         Braintrust V4 export string that can be used as parent parameter,
@@ -545,6 +545,12 @@ def parent_from_headers(headers: dict[str, str]) -> str | None:
         >>> parent = parent_from_headers(headers)
         >>> with project.start_span(name="service_c", parent=parent) as span:
         >>>     span.log(input="BT span as child of OTEL parent")
+
+        >>> # Using a custom propagator (e.g., B3 format)
+        >>> from opentelemetry.propagators.b3 import B3MultiFormat
+        >>> propagator = B3MultiFormat()
+        >>> headers = {'X-B3-TraceId': '...', 'X-B3-SpanId': '...', 'baggage': '...'}
+        >>> parent = parent_from_headers(headers, propagator=propagator)
     """
     if not OTEL_AVAILABLE:
         raise ImportError(INSTALL_ERR_MSG)
@@ -553,8 +559,11 @@ def parent_from_headers(headers: dict[str, str]) -> str | None:
     from opentelemetry import baggage, trace
     from opentelemetry.propagate import extract
 
-    # Extract context from headers using W3C Trace Context propagator
-    ctx = extract(headers)
+    # Extract context from headers using provided propagator or global propagator
+    if propagator is not None:
+        ctx = propagator.extract(headers)
+    else:
+        ctx = extract(headers)
 
     # Get span from context
     span = trace.get_current_span(ctx)

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/test_framework.py

@@ -343,6 +343,31 @@ async def test_eval_no_send_logs_true(with_memory_logger, simple_scorer):
     assert len(logs) == 0
 
 
+@pytest.mark.asyncio
+async def test_eval_no_send_logs_with_none_score(with_memory_logger):
+    """Test that scorers returning None don't crash local mode."""
+
+    def sometimes_none_scorer(input, output, expected):
+        # Return None for first input, score for second
+        if input == "hello":
+            return {"name": "conditional", "score": None}
+        return {"name": "conditional", "score": 1.0}
+
+    result = await Eval(
+        "test-none-score",
+        data=[
+            {"input": "hello", "expected": "hello world"},
+            {"input": "test", "expected": "test world"},
+        ],
+        task=lambda input_val: input_val + " world",
+        scores=[sometimes_none_scorer],
+        no_send_logs=True,
+    )
+
+    # Should not crash and should calculate average from non-None scores only
+    assert result.summary.scores["conditional"].score == 1.0  # Only the second score counts
+
+
 @pytest.mark.asyncio
 async def test_hooks_tags_append(with_memory_logger, with_simulate_login, simple_scorer):
     """Test that hooks.tags can be appended to and logged."""

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/test_logger.py

@@ -849,6 +849,40 @@ def test_span_link_with_unresolved_experiment(with_simulate_login, with_memory_l
     assert link == "https://www.braintrust.dev/error-generating-link?msg=resolve-experiment-id"
 
 
+def test_experiment_span_link_uses_env_vars_when_logged_out(with_memory_logger):
+    """Verify EXPERIMENT spans use BRAINTRUST_ORG_NAME env var when not logged in."""
+    simulate_logout()
+    assert_logged_out()
+
+    keys = ["BRAINTRUST_APP_URL", "BRAINTRUST_ORG_NAME"]
+    originals = {k: os.environ.get(k) for k in keys}
+    try:
+        os.environ["BRAINTRUST_APP_URL"] = "https://test-app.example.com"
+        os.environ["BRAINTRUST_ORG_NAME"] = "env-org-name"
+
+        experiment = braintrust.init(
+            project="test-project",
+            experiment="test-experiment",
+        )
+
+        # Create span with resolved experiment ID
+        span = experiment.start_span(name="test-span")
+        span.parent_object_id = LazyValue(lambda: "test-exp-id", use_mutex=False)
+        span.end()
+
+        link = span.link()
+
+        # Should use env var org name and app url
+        assert "env-org-name" in link
+        assert "test-app.example.com" in link
+        assert "test-exp-id" in link
+    finally:
+        for k, v in originals.items():
+            os.environ.pop(k, None)
+            if v:
+                os.environ[k] = v
+
+
 def test_permalink_with_valid_span_logged_in(with_simulate_login, with_memory_logger):
     logger = init_logger(
         project="test-project",

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/test_otel.py

@@ -294,13 +294,12 @@ class TestSpanFiltering:
             self.provider.shutdown()
             self.memory_exporter.clear()
 
-    def test_keeps_root_spans(self):
+    def test_filters_out_root_spans(self):
         with self.tracer.start_as_current_span("root_operation"):
             pass
 
         spans = self.memory_exporter.get_finished_spans()
-        assert len(spans) == 1
-        assert spans[0].name == "root_operation"
+        assert len(spans) == 0
 
     def test_keeps_gen_ai_spans(self):
         with self.tracer.start_as_current_span("root"):
@@ -312,7 +311,7 @@ class TestSpanFiltering:
         spans = self.memory_exporter.get_finished_spans()
         span_names = [span.name for span in spans]
 
-        assert "root" in span_names
+        assert "root" not in span_names
         assert "gen_ai.completion" in span_names
         assert "regular_operation" not in span_names
 
@@ -329,35 +328,37 @@ class TestSpanFiltering:
         assert "braintrust.eval" in span_names
         assert "database_query" not in span_names
 
-    def test_keeps_llm_spans(self):
+    def test_keeps_traceloop_spans(self):
         with self.tracer.start_as_current_span("root"):
-            with self.tracer.start_as_current_span("llm.generate"):
+            with self.tracer.start_as_current_span("traceloop.agent"):
+                pass
+            with self.tracer.start_as_current_span("traceloop.workflow.step"):
                 pass
 
         spans = self.memory_exporter.get_finished_spans()
         span_names = [span.name for span in spans]
-        assert "llm.generate" in span_names
+        assert "root" not in span_names
+        assert "traceloop.agent" in span_names
+        assert "traceloop.workflow.step" in span_names
 
-    def test_keeps_ai_spans(self):
+    def test_keeps_llm_spans(self):
         with self.tracer.start_as_current_span("root"):
-            with self.tracer.start_as_current_span("ai.model_call"):
+            with self.tracer.start_as_current_span("llm.generate"):
                 pass
 
         spans = self.memory_exporter.get_finished_spans()
         span_names = [span.name for span in spans]
-        assert "ai.model_call" in span_names
+        assert "llm.generate" in span_names
 
-    def test_keeps_traceloop_spans(self):
+    def test_keeps_ai_spans(self):
         with self.tracer.start_as_current_span("root"):
-            with self.tracer.start_as_current_span("traceloop.agent"):
-                pass
-            with self.tracer.start_as_current_span("traceloop.workflow.step"):
+            with self.tracer.start_as_current_span("ai.model_call"):
                 pass
 
         spans = self.memory_exporter.get_finished_spans()
         span_names = [span.name for span in spans]
-        assert "traceloop.agent" in span_names
-        assert "traceloop.workflow.step" in span_names
+        assert "root" not in span_names
+        assert "ai.model_call" in span_names
 
     def test_keeps_spans_with_llm_attributes(self):
         with self.tracer.start_as_current_span("root"):
@@ -374,7 +375,7 @@ class TestSpanFiltering:
         spans = self.memory_exporter.get_finished_spans()
         span_names = [span.name for span in spans]
 
-        assert "root" in span_names
+        assert "root" not in span_names
         assert "some_operation" in span_names  # has gen_ai.model attribute
         assert "another_operation" in span_names  # has llm.tokens attribute
         assert "traceloop_operation" in span_names  # has traceloop.agent_id attribute
@@ -390,10 +391,7 @@ class TestSpanFiltering:
                 pass
 
         spans = self.memory_exporter.get_finished_spans()
-
-        # Only root should be kept
-        assert len(spans) == 1
-        assert spans[0].name == "root"
+        assert len(spans) == 0
 
     def test_custom_filter_keeps_spans(self):
         def custom_filter(span):
@@ -422,9 +420,9 @@ class TestSpanFiltering:
         spans = memory_exporter.get_finished_spans()
         span_names = [span.name for span in spans]
 
-        assert "root" in span_names
         assert "custom_keep" in span_names  # kept by custom filter
         assert "regular_operation" not in span_names  # dropped by default logic
+        assert "root" not in span_names
 
     def test_custom_filter_drops_spans(self):
         def custom_filter(span):
@@ -453,9 +451,9 @@ class TestSpanFiltering:
         spans = memory_exporter.get_finished_spans()
         span_names = [span.name for span in spans]
 
-        assert "root" in span_names
         assert "gen_ai.drop_this" not in span_names  # dropped by custom filter
         assert "gen_ai.keep_this" in span_names  # kept by default LLM logic
+        assert "root" not in span_names
 
     def test_custom_filter_none_uses_default_logic(self):
         def custom_filter(span):
@@ -482,7 +480,7 @@ class TestSpanFiltering:
         spans = memory_exporter.get_finished_spans()
         span_names = [span.name for span in spans]
 
-        assert "root" in span_names
+        assert "root" not in span_names
         assert "gen_ai.completion" in span_names  # kept by default LLM logic
         assert "regular_operation" not in span_names  # dropped by default logic
 
@@ -546,11 +544,32 @@ class TestSpanFiltering:
         filtered_spans = filtered_spans_exporter.get_finished_spans()
         filtered_span_names = [span.name for span in filtered_spans]
 
-        assert len(filtered_spans) == 3
-        assert "user_request" in filtered_span_names  # root span
+        assert len(filtered_spans) == 2
+        assert "user_request" not in filtered_span_names  # root span
         assert "gen_ai.completion" in filtered_span_names  # LLM name
         assert "response_formatting" in filtered_span_names  # LLM attribute
 
+    def test_custom_filter_is_root_span(self):
+        from braintrust.otel import AISpanProcessor, is_root_span
+        from opentelemetry.sdk.trace import TracerProvider
+        from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+        from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+        memory_exporter = InMemorySpanExporter()
+        processor = AISpanProcessor(SimpleSpanProcessor(memory_exporter), custom_filter=is_root_span)
+        provider = TracerProvider()
+        provider.add_span_processor(processor)
+        tracer = provider.get_tracer("test-braintrust-root-filter")
+
+        with tracer.start_as_current_span("root_span"):
+            with tracer.start_as_current_span("child_span"):
+                pass
+
+        provider.shutdown()
+        spans = memory_exporter.get_finished_spans()
+        names = [span.name for span in spans]
+        assert "root_span" in names
+        assert "child_span" not in names
 
 def test_parent_from_headers_invalid_inputs():
     """Test parent_from_headers with various invalid inputs."""
@@ -716,3 +735,76 @@ def test_add_span_parent_to_baggage():
     # Test with None span (should return None and warn)
     token = add_span_parent_to_baggage(None)
     assert token is None
+
+
+def test_parent_from_headers_with_custom_propagator():
+    """Test parent_from_headers with a custom propagator."""
+    if not _check_otel_installed():
+        pytest.skip("OpenTelemetry SDK not fully installed, skipping test")
+
+    from braintrust.otel import parent_from_headers
+    from opentelemetry import baggage as otel_baggage
+    from opentelemetry import context as otel_context
+    from opentelemetry import trace
+    from opentelemetry.propagators.textmap import CarrierT, Getter, TextMapPropagator, default_getter
+    from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags
+
+    class CustomHeaderPropagator(TextMapPropagator):
+        """Custom propagator that reads trace context from X-Custom-* headers."""
+
+        def extract(
+            self,
+            carrier: CarrierT,
+            context: otel_context.Context | None = None,
+            getter: Getter = default_getter,
+        ) -> otel_context.Context:
+            if context is None:
+                context = otel_context.get_current()
+
+            trace_id = getter.get(carrier, "X-Custom-Trace-Id")
+            span_id = getter.get(carrier, "X-Custom-Span-Id")
+
+            if trace_id and span_id:
+                trace_id_list = trace_id if isinstance(trace_id, list) else [trace_id]
+                span_id_list = span_id if isinstance(span_id, list) else [span_id]
+
+                span_context = SpanContext(
+                    trace_id=int(trace_id_list[0], 16),
+                    span_id=int(span_id_list[0], 16),
+                    is_remote=True,
+                    trace_flags=TraceFlags.SAMPLED,
+                )
+                span = NonRecordingSpan(span_context)
+                context = trace.set_span_in_context(span, context)
+
+            # Also extract baggage from standard baggage header
+            baggage_header = getter.get(carrier, "baggage")
+            if baggage_header:
+                baggage_list = baggage_header if isinstance(baggage_header, list) else [baggage_header]
+                for item in baggage_list[0].split(","):
+                    if "=" in item:
+                        key, value = item.split("=", 1)
+                        context = otel_baggage.set_baggage(key.strip(), value.strip(), context)
+
+            return context
+
+        def inject(self, carrier, context=None, setter=None):
+            pass  # Not needed for this test
+
+        @property
+        def fields(self):
+            return {"X-Custom-Trace-Id", "X-Custom-Span-Id", "baggage"}
+
+    propagator = CustomHeaderPropagator()
+
+    # Custom header format
+    headers = {
+        "X-Custom-Trace-Id": "4bf92f3577b34da6a3ce929d0e0e4736",
+        "X-Custom-Span-Id": "00f067aa0ba902b7",
+        "baggage": "braintrust.parent=project_name:test-project",
+    }
+
+    result = parent_from_headers(headers, propagator=propagator)
+    assert result is not None
+    assert isinstance(result, str)
+    assert len(result) > 0

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/test_util.py

@@ -3,7 +3,7 @@ from typing import List
 
 import pytest
 
-from .util import LazyValue, mask_api_key
+from .util import LazyValue, mask_api_key, merge_dicts_with_paths
 
 
 class TestLazyValue(unittest.TestCase):
@@ -160,3 +160,53 @@ def test_mask_api_key():
     assert mask_api_key("12345") == "12*45"
     for i in ["", "1", "12", "123", "1234"]:
         assert mask_api_key(i) == "*" * len(i)
+
+
+class TestTagsSetUnionMerge:
+    def test_tags_arrays_are_merged_as_sets_by_default(self):
+        a = {"tags": ["a", "b"]}
+        b = {"tags": ["b", "c"]}
+        merge_dicts_with_paths(a, b, (), set())
+        assert set(a["tags"]) == {"a", "b", "c"}
+
+    def test_tags_merge_deduplicates_values(self):
+        a = {"tags": ["a", "b", "c"]}
+        b = {"tags": ["a", "b", "c", "d"]}
+        merge_dicts_with_paths(a, b, (), set())
+        assert set(a["tags"]) == {"a", "b", "c", "d"}
+
+    def test_tags_merge_works_when_merge_into_has_no_tags(self):
+        a = {"other": "data"}
+        b = {"tags": ["a", "b"]}
+        merge_dicts_with_paths(a, b, (), set())
+        assert set(a["tags"]) == {"a", "b"}
+
+    def test_tags_merge_works_when_merge_from_has_no_tags(self):
+        a = {"tags": ["a", "b"]}
+        b = {"other": "data"}
+        merge_dicts_with_paths(a, b, (), set())
+        assert set(a["tags"]) == {"a", "b"}
+
+    def test_tags_are_replaced_when_included_in_merge_paths(self):
+        a = {"tags": ["a", "b"]}
+        b = {"tags": ["c", "d"]}
+        merge_dicts_with_paths(a, b, (), {("tags",)})
+        assert a["tags"] == ["c", "d"]
+
+    def test_empty_tags_array_clears_tags_when_in_merge_paths(self):
+        a = {"tags": ["a", "b"]}
+        b = {"tags": []}
+        merge_dicts_with_paths(a, b, (), {("tags",)})
+        assert a["tags"] == []
+
+    def test_none_tags_replaces_tags(self):
+        a = {"tags": ["a", "b"]}
+        b = {"tags": None}
+        merge_dicts_with_paths(a, b, (), set())
+        assert a["tags"] is None
+
+    def test_set_union_only_applies_to_top_level_tags_field(self):
+        a = {"metadata": {"tags": ["a", "b"]}}
+        b = {"metadata": {"tags": ["c", "d"]}}
+        merge_dicts_with_paths(a, b, (), set())
+        assert a["metadata"]["tags"] == ["c", "d"]

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/util.py

@@ -1,4 +1,5 @@
 import inspect
+import json
 import sys
 import threading
 import urllib.parse
@@ -29,11 +30,16 @@ def coalesce(*args):
     return None
 
 
+# Fields that automatically use set-union merge semantics (unless in merge_paths).
+_SET_UNION_FIELDS = frozenset(["tags"])
+
+
 def merge_dicts_with_paths(
-    merge_into: dict[str, Any], merge_from: Mapping[str, Any], path: tuple[str, ...], merge_paths: set[tuple[str]]
+    merge_into: dict[str, Any], merge_from: Mapping[str, Any], path: tuple[str, ...], merge_paths: set[tuple[str, ...]]
 ) -> dict[str, Any]:
     """Merges merge_from into merge_into, destructively updating merge_into. Does not merge any further than
-    merge_paths."""
+    merge_paths. For fields in _SET_UNION_FIELDS (like "tags"), arrays are merged as sets (union)
+    unless the field is explicitly listed in merge_paths (opt-out to replacement)."""
 
     if not isinstance(merge_into, dict):
         raise ValueError("merge_into must be a dictionary")
@@ -43,7 +49,22 @@ def merge_dicts_with_paths(
     for k, merge_from_v in merge_from.items():
         full_path = path + (k,)
         merge_into_v = merge_into.get(k)
-        if isinstance(merge_into_v, dict) and isinstance(merge_from_v, dict) and full_path not in merge_paths:
+
+        # Check if this field should use set-union merge (e.g., "tags" at top level)
+        is_set_union_field = len(path) == 0 and k in _SET_UNION_FIELDS and full_path not in merge_paths
+
+        if is_set_union_field and isinstance(merge_into_v, list) and isinstance(merge_from_v, list):
+            # Set-union merge: combine arrays, deduplicate using JSON for objects
+            seen: set[str] = set()
+            combined = []
+            for item in merge_into_v + list(merge_from_v):
+                # Use JSON serialization for consistent object comparison
+                item_key = json.dumps(item, sort_keys=True) if isinstance(item, (dict, list)) else str(item)
+                if item_key not in seen:
+                    seen.add(item_key)
+                    combined.append(item)
+            merge_into[k] = combined
+        elif isinstance(merge_into_v, dict) and isinstance(merge_from_v, dict) and full_path not in merge_paths:
             merge_dicts_with_paths(merge_into_v, merge_from_v, full_path, merge_paths)
         else:
             merge_into[k] = merge_from_v

braintrust-0.4.2/src/braintrust/version.py

@@ -0,0 +1,4 @@
+VERSION = "0.4.2"
+
+# this will be templated during the build
+GIT_COMMIT = "3ca420e53e77d4665b91ccc7631c95dc97ce566d"

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/wrappers/litellm.py

@@ -657,9 +657,52 @@ def patch_litellm():
         import litellm
 
         if not hasattr(litellm, "_braintrust_wrapped"):
+            # Store originals for unpatch_litellm()
+            litellm._braintrust_original_completion = litellm.completion
+            litellm._braintrust_original_acompletion = litellm.acompletion
+            litellm._braintrust_original_responses = litellm.responses
+            litellm._braintrust_original_aresponses = litellm.aresponses
+
             wrapped = wrap_litellm(litellm)
             litellm.completion = wrapped.completion
             litellm.acompletion = wrapped.acompletion
+            litellm.responses = wrapped.responses
+            litellm.aresponses = wrapped.aresponses
             litellm._braintrust_wrapped = True
     except ImportError:
         pass  # litellm not available
+
+
+def unpatch_litellm():
+    """
+    Restore LiteLLM to its original state, removing Braintrust tracing.
+
+    This undoes the patching done by patch_litellm(), restoring the original
+    completion, acompletion, responses, and aresponses functions.
+
+    Example:
+        ```python
+        import braintrust
+        braintrust.patch_litellm()
+
+        # ... use litellm with tracing ...
+
+        braintrust.unpatch_litellm()  # restore original behavior
+        ```
+    """
+    try:
+        import litellm
+
+        if hasattr(litellm, "_braintrust_wrapped"):
+            litellm.completion = litellm._braintrust_original_completion
+            litellm.acompletion = litellm._braintrust_original_acompletion
+            litellm.responses = litellm._braintrust_original_responses
+            litellm.aresponses = litellm._braintrust_original_aresponses
+
+            delattr(litellm, "_braintrust_wrapped")
+            delattr(litellm, "_braintrust_original_completion")
+            delattr(litellm, "_braintrust_original_acompletion")
+            delattr(litellm, "_braintrust_original_responses")
+            delattr(litellm, "_braintrust_original_aresponses")
+    except ImportError:
+        pass  # litellm not available

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust/wrappers/test_litellm.py

@@ -702,3 +702,76 @@ async def test_litellm_async_streaming_with_break(memory_logger):
     span = spans[0]
     metrics = span["metrics"]
     assert metrics["time_to_first_token"] >= 0
+
+
+@pytest.mark.vcr
+def test_patch_litellm_responses(memory_logger):
+    """Test that patch_litellm() patches responses."""
+    from braintrust.wrappers.litellm import patch_litellm, unpatch_litellm
+
+    assert not memory_logger.pop()
+
+    patch_litellm()
+    try:
+        start = time.time()
+        # Call litellm.responses directly (not wrapped_litellm.responses)
+        response = litellm.responses(
+            model=TEST_MODEL,
+            input=TEST_PROMPT,
+            instructions="Just the number please",
+        )
+        end = time.time()
+
+        assert response
+        assert response.output
+        assert len(response.output) > 0
+        content = response.output[0].content[0].text
+        assert "24" in content or "twenty-four" in content.lower()
+
+        # Verify span was created
+        spans = memory_logger.pop()
+        assert len(spans) == 1
+        span = spans[0]
+        assert_metrics_are_valid(span["metrics"], start, end)
+        assert span["metadata"]["model"] == TEST_MODEL
+        assert span["metadata"]["provider"] == "litellm"
+        assert TEST_PROMPT in str(span["input"])
+    finally:
+        unpatch_litellm()
+
+
+@pytest.mark.vcr
+@pytest.mark.asyncio
+async def test_patch_litellm_aresponses(memory_logger):
+    """Test that patch_litellm() patches aresponses."""
+    from braintrust.wrappers.litellm import patch_litellm, unpatch_litellm
+
+    assert not memory_logger.pop()
+
+    patch_litellm()
+    try:
+        start = time.time()
+        # Call litellm.aresponses directly (not wrapped_litellm.aresponses)
+        response = await litellm.aresponses(
+            model=TEST_MODEL,
+            input=TEST_PROMPT,
+            instructions="Just the number please",
+        )
+        end = time.time()
+
+        assert response
+        assert response.output
+        assert len(response.output) > 0
+        content = response.output[0].content[0].text
+        assert "24" in content or "twenty-four" in content.lower()
+
+        # Verify span was created
+        spans = memory_logger.pop()
+        assert len(spans) == 1
+        span = spans[0]
+        assert_metrics_are_valid(span["metrics"], start, end)
+        assert span["metadata"]["model"] == TEST_MODEL
+        assert span["metadata"]["provider"] == "litellm"
+        assert TEST_PROMPT in str(span["input"])
+    finally:
+        unpatch_litellm()

{braintrust-0.4.1 → braintrust-0.4.2}/src/braintrust.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braintrust
-Version: 0.4.1
+Version: 0.4.2
 Summary: SDK for integrating Braintrust
 Home-page: https://www.braintrust.dev
 Author: Braintrust

braintrust-0.4.1/src/braintrust/version.py

@@ -1,4 +0,0 @@
-VERSION = "0.4.1"
-
-# this will be templated during the build
-GIT_COMMIT = "d9c624ea93ca6bf62c2412abce1b3a2ef1a2be67"