braintrust 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

braintrust/wrappers/test_langsmith_wrapper.py

@@ -0,0 +1,338 @@
+# pyright: reportPrivateUsage=false
+# pyright: reportMissingParameterType=false
+# pyright: reportUnknownParameterType=false
+# pyright: reportUnknownArgumentType=false
+# pyright: reportUnknownMemberType=false
+# pylint: disable=protected-access
+
+"""
+Tests for the LangSmith wrapper to ensure compatibility with LangSmith's API.
+"""
+
+
+from braintrust.wrappers.langsmith_wrapper import (
+    _convert_langsmith_data,
+    _is_patched,
+    _make_braintrust_scorer,
+    _make_braintrust_task,
+    wrap_aevaluate,
+    wrap_client,
+    wrap_traceable,
+)
+
+
+def test_is_patched_false():
+    """Test that _is_patched returns False for unpatched objects."""
+
+    def unpatched():
+        pass
+
+    assert _is_patched(unpatched) is False
+
+
+def test_is_patched_true():
+    """Test that _is_patched returns True for patched objects."""
+
+    def patched():
+        pass
+
+    patched._braintrust_patched = True  # type: ignore
+
+    assert _is_patched(patched) is True
+
+
+def test_make_braintrust_scorer_dict_result():
+    """Test converting a LangSmith evaluator that returns a dict."""
+
+    def langsmith_evaluator(inputs, outputs, reference_outputs):
+        return {"key": "accuracy", "score": 0.9, "metadata": {"note": "good"}}
+
+    converted = _make_braintrust_scorer(langsmith_evaluator)
+
+    # Create a mock Example object
+    class MockExample:
+        outputs = {"y": 2}
+
+    result = converted(input={"x": 1}, output={"y": 2}, expected=MockExample())
+
+    assert result.name == "accuracy"
+    assert result.score == 0.9
+    assert result.metadata == {"note": "good"}
+
+
+def test_make_braintrust_scorer_numeric_result():
+    """Test converting a LangSmith evaluator that returns a numeric score in a dict."""
+
+    def langsmith_evaluator(inputs, outputs, reference_outputs):
+        return {"score": 1.0 if outputs == reference_outputs else 0.0}
+
+    converted = _make_braintrust_scorer(langsmith_evaluator)
+
+    class MockExample:
+        outputs = {"y": 2}
+
+    result = converted(input={"x": 1}, output={"y": 2}, expected=MockExample())
+
+    assert result.name == "langsmith_evaluator"
+    assert result.score == 1.0
+
+
+def test_make_braintrust_scorer_with_plain_dict_expected():
+    """Test converting a LangSmith evaluator with plain dict as expected."""
+
+    def langsmith_evaluator(inputs, outputs, reference_outputs):
+        return {"score": 1.0 if outputs == reference_outputs else 0.0}
+
+    converted = _make_braintrust_scorer(langsmith_evaluator)
+    result = converted(input={"x": 1}, output={"y": 2}, expected={"y": 2})
+
+    assert result.name == "langsmith_evaluator"
+    assert result.score == 1.0
+
+
+def test_convert_langsmith_data_from_list():
+    """Test converting LangSmith data from a list of dicts."""
+    data = [
+        {"inputs": {"x": 1}, "outputs": {"y": 2}},
+        {"inputs": {"x": 2}, "outputs": {"y": 4}},
+    ]
+
+    data_fn = _convert_langsmith_data(data)
+    result = list(data_fn())
+
+    assert len(result) == 2
+    assert result[0].input == {"x": 1}
+    # The whole item is passed as expected
+    assert result[0].expected == {"inputs": {"x": 1}, "outputs": {"y": 2}}
+    assert result[1].input == {"x": 2}
+    assert result[1].expected == {"inputs": {"x": 2}, "outputs": {"y": 4}}
+
+
+def test_convert_langsmith_data_from_callable():
+    """Test converting LangSmith data from a callable."""
+
+    def data_generator():
+        yield {"inputs": {"x": 1}, "outputs": {"y": 2}}
+        yield {"inputs": {"x": 2}, "outputs": {"y": 4}}
+
+    data_fn = _convert_langsmith_data(data_generator)
+    result = list(data_fn())
+
+    assert len(result) == 2
+    assert result[0].input == {"x": 1}
+    # The whole item is passed as expected
+    assert result[0].expected == {"inputs": {"x": 1}, "outputs": {"y": 2}}
+
+
+def test_convert_langsmith_data_with_example_objects():
+    """Test converting LangSmith data with Example-like objects."""
+
+    class MockExample:
+        def __init__(self, inputs, outputs):
+            self.inputs = inputs
+            self.outputs = outputs
+
+    data = [
+        MockExample(inputs={"x": 1}, outputs={"y": 2}),
+        MockExample(inputs={"x": 2}, outputs={"y": 4}),
+    ]
+
+    data_fn = _convert_langsmith_data(data)
+    result = list(data_fn())
+
+    assert len(result) == 2
+    assert result[0].input == {"x": 1}
+    # The whole Example object is passed as expected
+    assert result[0].expected.inputs == {"x": 1}
+    assert result[0].expected.outputs == {"y": 2}
+
+
+def test_make_braintrust_task_with_dict_input():
+    """Test that task function handles dict inputs correctly."""
+
+    def target_fn(inputs):
+        return inputs["x"] * 2
+
+    task = _make_braintrust_task(target_fn)
+    result = task({"x": 5}, None)
+
+    assert result == 10
+
+
+def test_make_braintrust_task_with_kwargs_expansion():
+    """Test that task function expands dict kwargs when signature matches."""
+
+    def target_fn(x, y):
+        return x + y
+
+    task = _make_braintrust_task(target_fn)
+    result = task({"x": 2, "y": 3}, None)
+
+    assert result == 5
+
+
+def test_make_braintrust_task_simple_input():
+    """Test that task function handles simple inputs."""
+
+    def target_fn(inp):
+        return inp * 2
+
+    task = _make_braintrust_task(target_fn)
+    result = task(5, None)
+
+    assert result == 10
+
+
+class TestWrapTraceable:
+    """Tests for wrap_traceable functionality."""
+
+    def test_wrap_traceable_returns_wrapper(self):
+        """Test that wrap_traceable returns a wrapped version."""
+
+        def mock_traceable(func, **kwargs):
+            return func
+
+        wrapped = wrap_traceable(mock_traceable, standalone=False)
+        assert callable(wrapped)
+        assert _is_patched(wrapped)
+
+    def test_wrap_traceable_standalone_mode(self):
+        """Test that wrap_traceable works in standalone mode."""
+
+        def mock_traceable(func, **kwargs):
+            return func
+
+        wrapped = wrap_traceable(mock_traceable, standalone=True)
+        assert callable(wrapped)
+        assert _is_patched(wrapped)
+
+
+class TestWrapFunctions:
+    """Tests for the wrap_* functions."""
+
+    def test_wrap_functions_exist(self):
+        """Test that wrap functions are callable."""
+        assert callable(wrap_traceable)
+        assert callable(wrap_client)
+        assert callable(wrap_aevaluate)
+
+    def test_wrap_traceable_returns_patched_function(self):
+        """Test that wrap_traceable returns a patched function."""
+
+        def mock_traceable(func, **kwargs):
+            return func
+
+        wrapped = wrap_traceable(mock_traceable)
+        assert _is_patched(wrapped)
+
+    def test_wrap_traceable_skips_if_already_patched(self):
+        """Test that wrap_traceable skips if already patched."""
+
+        def mock_traceable(func, **kwargs):
+            return func
+
+        mock_traceable._braintrust_patched = True  # type: ignore
+
+        result = wrap_traceable(mock_traceable)
+        # Should return the same function
+        assert result is mock_traceable
+
+    def test_wrap_client_sets_flag(self):
+        """Test that wrap_client sets the patched flag."""
+
+        class MockClient:
+            def evaluate(self, *args, **kwargs):
+                return "original"
+
+        wrap_client(MockClient)
+        assert _is_patched(MockClient.evaluate)
+
+    def test_wrap_aevaluate_returns_patched_function(self):
+        """Test that wrap_aevaluate returns a patched function."""
+
+        async def mock_aevaluate(*args, **kwargs):
+            pass
+
+        wrapped = wrap_aevaluate(mock_aevaluate)
+        assert _is_patched(wrapped)
+
+
+class TestTandemModeIntegration:
+    """Integration tests for tandem mode (LangSmith + Braintrust together)."""
+
+    def test_make_braintrust_task_with_inputs_parameter(self):
+        """Test that task handles LangSmith's required 'inputs' parameter name."""
+
+        def target_fn(inputs: dict) -> dict:
+            return {"result": inputs["x"] * 2}
+
+        task = _make_braintrust_task(target_fn)
+        result = task({"x": 5}, None)
+
+        assert result == {"result": 10}
+
+    def test_convert_langsmith_data_handles_different_output_types(self):
+        """Test that data conversion handles various output types."""
+        data = [
+            {"inputs": {"x": 1}, "outputs": 2},  # outputs is int, not dict
+            {"inputs": {"x": 2}, "outputs": {"result": 4}},  # outputs is already dict
+        ]
+
+        data_fn = _convert_langsmith_data(data)
+        result = list(data_fn())
+
+        # Both should work - Braintrust's EvalCase accepts any type for expected
+        assert len(result) == 2
+        assert result[0].input == {"x": 1}
+        assert result[1].input == {"x": 2}
+
+    def test_make_braintrust_scorer_handles_wrapped_outputs(self):
+        """Test that scorers handle output wrapping correctly."""
+
+        def langsmith_evaluator(inputs, outputs, reference_outputs):
+            # outputs will be wrapped as {"output": value} for non-dict results
+            actual = outputs.get("output", outputs)
+            expected = reference_outputs.get("output", reference_outputs) if isinstance(reference_outputs, dict) else reference_outputs
+            return {"key": "match", "score": 1.0 if actual == expected else 0.0}
+
+        converted = _make_braintrust_scorer(langsmith_evaluator)
+
+        class MockExample:
+            outputs = {"output": 42}
+
+        # Test with wrapped output
+        result = converted(input={"x": 1}, output=42, expected=MockExample())
+        assert result.name == "match"
+        assert result.score == 1.0
+
+
+class TestDataConversion:
+    """Tests for data conversion utilities."""
+
+    def test_convert_data_with_braintrust_format(self):
+        """Test that Braintrust format is properly handled."""
+        data = [
+            {"input": {"x": 1}, "expected": {"y": 2}},
+            {"input": {"x": 2}, "expected": {"y": 4}},
+        ]
+
+        data_fn = _convert_langsmith_data(data)
+        result = list(data_fn())
+
+        assert len(result) == 2
+        assert result[0].input == {"x": 1}
+        assert result[0].expected == {"y": 2}
+        assert result[1].input == {"x": 2}
+        assert result[1].expected == {"y": 4}
+
+    def test_convert_data_with_simple_items(self):
+        """Test that simple items (not dicts) are handled."""
+        data = [1, 2, 3]
+
+        data_fn = _convert_langsmith_data(data)
+        result = list(data_fn())
+
+        assert len(result) == 3
+        assert result[0].input == 1
+        assert result[1].input == 2
+        assert result[2].input == 3

braintrust/wrappers/test_litellm.py

@@ -15,16 +15,6 @@ TEST_PROMPT = "What's 12 + 12?"
 TEST_SYSTEM_PROMPT = "You are a helpful assistant that only responds with numbers."
 
 
-@pytest.fixture(scope="module")
-def vcr_config():
-    return {
-        "filter_headers": [
-            "authorization",
-            "openai-organization",
-        ]
-    }
-
-
 @pytest.fixture
 def memory_logger():
     init_test_logger(PROJECT_NAME)

braintrust/wrappers/test_oai_attachments.py

@@ -11,16 +11,6 @@ PROJECT_NAME = "test-project-openai-attachment-processing"
 TEST_MODEL = "gpt-4o-mini"
 
 
-@pytest.fixture(scope="module")
-def vcr_config():
-    return {
-        "filter_headers": [
-            "authorization",
-            "openai-organization",
-        ]
-    }
-
-
 @pytest.fixture
 def memory_logger():
     init_test_logger(PROJECT_NAME)

braintrust/wrappers/test_openai.py

@@ -18,16 +18,6 @@ TEST_PROMPT = "What's 12 + 12?"
 TEST_SYSTEM_PROMPT = "You are a helpful assistant that only responds with numbers."
 
 
-@pytest.fixture(scope="module")
-def vcr_config():
-    return {
-        "filter_headers": [
-            "authorization",
-            "openai-organization",
-        ]
-    }
-
-
 @pytest.fixture
 def memory_logger():
     init_test_logger(PROJECT_NAME)
@@ -943,8 +933,6 @@ async def test_openai_streaming_with_break(memory_logger):
         model=TEST_MODEL, messages=[{"role": "user", "content": TEST_PROMPT}], stream=True
     )
 
-    time.sleep(0.2)  # time to first token sleep
-
     # Only process the first few chunks
     counter = 0
     async for chunk in stream:
@@ -1331,6 +1319,7 @@ def _is_wrapped(client):
 
 
 @pytest.mark.asyncio
+@pytest.mark.vcr
 async def test_braintrust_tracing_processor_current_span_detection(memory_logger):
     """Test that BraintrustTracingProcessor currentSpan() detection works with OpenAI Agents SDK."""
     pytest.importorskip("agents", reason="agents package not available")
@@ -1440,6 +1429,7 @@ async def test_braintrust_tracing_processor_current_span_detection(memory_logger
 
 
 @pytest.mark.asyncio
+@pytest.mark.vcr
 async def test_braintrust_tracing_processor_concurrency_bug(memory_logger):
     """Test that reproduces the concurrency bug where overlapping traces mix up first_input/last_output."""
     pytest.importorskip("agents", reason="agents package not available")
@@ -1546,6 +1536,7 @@ async def test_braintrust_tracing_processor_concurrency_bug(memory_logger):
 
 
 @pytest.mark.asyncio
+@pytest.mark.vcr
 async def test_agents_tool_openai_nested_spans(memory_logger):
     """Test that OpenAI calls inside agent tools are properly nested under the tool span."""
     pytest.importorskip("agents", reason="agents package not available")

braintrust/wrappers/test_openrouter.py

@@ -19,15 +19,6 @@ PROJECT_NAME = "test-openrouter"
 TEST_MODEL = "openai/gpt-4o-mini"
 
 
-@pytest.fixture(scope="module")
-def vcr_config():
-    return {
-        "filter_headers": [
-            "authorization",
-        ]
-    }
-
-
 @pytest.fixture
 def memory_logger():
     init_test_logger(PROJECT_NAME)

braintrust/wrappers/test_pydantic_ai_integration.py

@@ -32,17 +32,6 @@ def direct():
     return direct_module
 
 
-@pytest.fixture(scope="module")
-def vcr_config():
-    return {
-        "filter_headers": [
-            "authorization",
-            "openai-organization",
-            "x-api-key",
-        ]
-    }
-
-
 @pytest.fixture
 def memory_logger():
     init_test_logger(PROJECT_NAME)

braintrust/wrappers/test_pydantic_ai_wrap_openai.py

@@ -66,6 +66,7 @@ def _assert_metrics_are_valid(metrics: Dict[str, Any]):
     assert "time_to_first_token" in metrics
 
 
+@pytest.mark.vcr
 @pytest.mark.asyncio
 async def test_pydantic_wrapped_stream(memory_logger):
     """Test that Pydantic AI streaming operations work with Braintrust wrapping."""
@@ -108,6 +109,7 @@ async def test_pydantic_wrapped_stream(memory_logger):
     assert span["root_span_id"]
 
 
+@pytest.mark.vcr
 @pytest.mark.asyncio
 async def test_pydantic_wrapped_completion(memory_logger):
     """Test that Pydantic AI completion operations work with Braintrust wrapping."""

{braintrust-0.4.2.dist-info → braintrust-0.4.3.dist-info}/METADATA

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

{braintrust-0.4.2.dist-info → braintrust-0.4.3.dist-info}/RECORD

@@ -1,20 +1,20 @@
 braintrust/__init__.py,sha256=sw6dLIINeyUVP4IbF49wqXv2cyAWEoO3SGSIvCb_b2o,2238
-braintrust/_generated_types.py,sha256=k36Qyd3AkTMXA_EJLyj0_zrUJTa7VIJDAQCNPbiIbL8,93868
+braintrust/_generated_types.py,sha256=kZs5K7dglu5S-NYztq0RO-uM5Z-Ng-8qHzebYNzStVg,96835
 braintrust/audit.py,sha256=3GQKzuTcFquYdrJtABM-k3xMlOIqgVkfG6UyeQ8_028,461
 braintrust/aws.py,sha256=OBz_SRyopgpCDSNvETLypzGwTXk-bNLn-Eisevnjfwo,377
 braintrust/bt_json.py,sha256=VNunedFUEfbvVEBuACHLRsjDr8lLD3_nFwB54MXtcbY,9385
-braintrust/conftest.py,sha256=hopKH5M5ts7DXlvRD_P2b94uXTT7vPKNhBWUdoIetL8,1681
+braintrust/conftest.py,sha256=cmuwhK0BvqZ6yGqD_3x_JJmWkCtaSOwfSKz6n8ZT5Ug,2339
 braintrust/context.py,sha256=bOo1Li29lUsi2DOOllIDar0oRuQNbkLNzJ7cYq5JTbo,4126
 braintrust/db_fields.py,sha256=vjVEyDxl2d13lvvTcVwT5paHvaT-1kgI-4Lg-gihRIw,476
 braintrust/framework.py,sha256=U2ubFkX6LS-3iArMT4sRG17oZa0ClM4GVpC0O8xotxQ,57593
 braintrust/framework2.py,sha256=o0igz4vXbmn0jHJPhDYvx14rFnI3ntV8H6VJfyJYRtM,16542
-braintrust/generated_types.py,sha256=foqHolHkcqYTNL5tfAR0mRIAtOO8Jl4R022QQqe-M1k,4849
+braintrust/generated_types.py,sha256=rzGVd_yajhEXZ-MME3ZWB7UCRvdVx2oANvxDcjKoZA4,4849
 braintrust/git_fields.py,sha256=au5ayyuvt7y_ojE9LC98ypTZd3RgFdjhRc8eFxcjnto,1434
 braintrust/gitutil.py,sha256=RsW7cawJMgaAaTw6WeB1sShyfflkPb7yH2x7yuRv10c,5642
 braintrust/graph_util.py,sha256=Z2Uy8RaOq5iMe5mShhQqRDDIpXVitE-biVxDiFB-0Ds,5545
 braintrust/http_headers.py,sha256=9ZsDcsAKG04SGowsgchZktD6rG_oSTKWa8QyGUPA4xE,154
 braintrust/id_gen.py,sha256=4UWLWRhksf76IkYi4cKACSaQ3yNgausrMRlhiurhy74,1590
-braintrust/logger.py,sha256=UuTETw0JeNBtKX2OJlM_GlzUyCKPg7Ar1DdVULhl_E4,205548
+braintrust/logger.py,sha256=_kpQni3_TTjnz1bcGJphwe_0xPcAuwxQDsccur6G5Z0,205378
 braintrust/merge_row_batch.py,sha256=tvuz3qdsa7HZBrzzAzoQqAXU7pKsHUebC7sw6RybbmA,9881
 braintrust/oai.py,sha256=AjHeD0uNYO-ECVUh9RbPBxyKMps06A3dvHAWa41prMc,36259
 braintrust/object.py,sha256=vYLyYWncsqLD00zffZUJwGTSkcJF9IIXmgIzrx3Np5c,632
@@ -29,8 +29,8 @@ braintrust/span_identifier_v1.py,sha256=eR-dHda0MurdOlghv7-CLSh7eVpNQigbDSQxPpLC
 braintrust/span_identifier_v2.py,sha256=2dLc-Vz8iWLISmL_-ebCyWnY-ysA7sMnBsQtKqzMHYY,8981
 braintrust/span_identifier_v3.py,sha256=l_W8amV0u89X-cHqIhWQdjLZcoeWhwJoAEdYWgCN1nM,9720
 braintrust/span_identifier_v4.py,sha256=uFT-OdzySo4uCeAaJC3VqH55Oy433xZGBdK2hiEsm2w,10044
-braintrust/span_types.py,sha256=UvuyjfL_Delao14TJs9IjnpYLcgDSodKJfAYju01aXQ,292
-braintrust/test_bt_json.py,sha256=iixyk_7QIKiF3VVThD9oiWzAT1b-t2fHPYECmSB8VT0,25304
+braintrust/span_types.py,sha256=cpTzCwUj4yBPbPLnzR23-VXIU2E9nl_dsVCSVMvtSkc,376
+braintrust/test_bt_json.py,sha256=p4r5DlMkH2rRQbYT9X1ASPbKVEMku5bFUUa7hVAO-ZY,25259
 braintrust/test_framework.py,sha256=7spRLovwNjZLula8mNW_KspyWuWgpqSfHV6sZqub-ME,17664
 braintrust/test_framework2.py,sha256=pSEEmBIyszAiYnpEVvDZgJqIe3lQ3T807LmIuBqV98w,7235
 braintrust/test_helpers.py,sha256=VSelzjkR2IHyy5QD6sYB_79VIXq-wEDslDwyx9H11kI,13528
@@ -44,14 +44,14 @@ braintrust/test_span_components.py,sha256=6w0oDnDLuVbHygNienujk4JDqtSRR5A49AI-S8
 braintrust/test_util.py,sha256=xMN84ERVzZYUTAOp0IkFK-ktWOLK4rr6OdhaNeq7Fg0,6382
 braintrust/test_version.py,sha256=hk5JKjEFbNJ_ONc1VEkqHquflzre34RpFhCEYLTK8iA,1051
 braintrust/util.py,sha256=-q73F17BkaUaDCGtNBTtacqIPwWiXcgWYpzHqFTQdhc,8361
-braintrust/version.py,sha256=8d_QVXySfoJqVPmORR9pWGmW5J1QcpfY-Cp9MlqpGC4,117
+braintrust/version.py,sha256=xijckaJ6-1Mn0R0hTRi55lSGRv3JudT78ygiljJCeaU,117
 braintrust/xact_ids.py,sha256=bdyp88HjlyIkglgLSqYlCYscdSH6EWVyE14sR90Xl1s,658
 braintrust/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 braintrust/cli/__main__.py,sha256=wCBKHGVmn3IT_yMXk5qfDwyI2SV2gf1tLr0NTxm9T8k,1519
 braintrust/cli/eval.py,sha256=ymnCVkZ6mefDBDHO1wqd0IPtBjib-vW_4OTZRWh8sbE,13246
 braintrust/cli/push.py,sha256=vUbKirxpiaCDYkFx3mskexaFWhczS4eIXKUDZPo5P9s,12423
 braintrust/cli/install/__init__.py,sha256=scF_YM4dZJ47kT6VlM2CgM9jrEzqEHqPxS88nyVAsfk,1331
-braintrust/cli/install/api.py,sha256=Q5XgKlnV1AaZmOI4Sg8Bl9JW_8ILd2Nn_0CvTkDjtqc,18529
+braintrust/cli/install/api.py,sha256=--wjZ0kV9s6TD_OYqljNGYYuLo1u17zRnG7vZ5I-WuE,18528
 braintrust/cli/install/bump_versions.py,sha256=Wcn6tAXTVz6RcCUg87xxxA-VUeUE8MTSQpOdjQJSz6k,1691
 braintrust/cli/install/logs.py,sha256=XROIpFp-KS1as1sqZBYwbCF4HogoPV2-m9yBooUjGFI,3740
 braintrust/cli/install/redshift.py,sha256=MsjN4MW_us_KTWy_YMRK3G5-2Gxd65L2SgI3uO7g-uw,6857
@@ -69,10 +69,10 @@ braintrust/devserver/schemas.py,sha256=Nwms8IzGyo60G5Az0IqZnCbqPmHUzublZvwT3IwcG
 braintrust/devserver/server.py,sha256=352s7kWxMljs2BcQoCu8rRuBFKek68uHdV5XHt87x2c,12626
 braintrust/devserver/test_cached_login.py,sha256=-khNsDAuHrO7N-Rt1orIAE_kxTBjfmIGTVyXmw2p6IU,3741
 braintrust/devserver/test_lru_cache.py,sha256=5YYJ5uFj7k4Z4PQQ-UOV7bLP5zBYVo-5jV5_hpthtgM,4164
-braintrust/devserver/test_server_integration.py,sha256=ygIYDsTCSqwa_rzQDtdX0mjkXQVy7qyJjntdoCgtjKM,6711
+braintrust/devserver/test_server_integration.py,sha256=7QhanUNsx7MYdhEL9AOr_ZrQJdSVIN1IorZ_JvIJq5Y,6485
 braintrust/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 braintrust/functions/constants.py,sha256=g_EDiSrfCltHr5QaQMQzJ3qy3D29X-11LanDqlicqB0,23
-braintrust/functions/invoke.py,sha256=BZQv5FXjLvT1nlPRBhEQv4MSKRVZPSunn63pm1vdkRs,10096
+braintrust/functions/invoke.py,sha256=5lmCUZ4_FPAVOelHuvMmIMQTQXYaqxYeaymptEs69n8,9731
 braintrust/functions/stream.py,sha256=zH3okhkbUBE3-iYD6edLqjDdewc1Zj1MjVx5A3Xwe9Y,6103
 braintrust/otel/__init__.py,sha256=sZxGs2khKfL9uFJtB118VJJ7O5QOZJSG3vuKUFB0fiE,24350
 braintrust/otel/context.py,sha256=EpGk3B1UeAfBeqDe-yYy4LNNCFBKU6aU-0tfVOMrkcs,4611
@@ -82,7 +82,7 @@ braintrust/prompt_cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 braintrust/prompt_cache/disk_cache.py,sha256=RH20RwKR1lkGMYtMs6oVht6EdBHT0vokq3Z8iOd4jgk,5643
 braintrust/prompt_cache/lru_cache.py,sha256=us4jyznEeScEUDLXfDyaYY6gSUmUba55Kg-P6fBrtm8,2509
 braintrust/prompt_cache/prompt_cache.py,sha256=2eA5lc5_5gYJEccA8fFGJD8a4Y10oBZ12NFIt-D0H9g,4834
-braintrust/prompt_cache/test_disk_cache.py,sha256=TSlkgQZT1yjM960eAn4kc8GntWfLf55HU3cdabGgI6M,7520
+braintrust/prompt_cache/test_disk_cache.py,sha256=szmHQnIa5Rn2CouP9t5CmI6-D48BiX3Dktm6X2WRuWY,7522
 braintrust/prompt_cache/test_lru_cache.py,sha256=4NNIXSfYBtOma7KYum74UdeM83eYmcXSOeiNpuKYpwI,2342
 braintrust/prompt_cache/test_prompt_cache.py,sha256=x17Ru9eaix8jt6yMhRgEljD2vVe7ieA8uKhk3bszgSM,8447
 braintrust/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -90,19 +90,21 @@ braintrust/wrappers/_anthropic_utils.py,sha256=tOj_rv5NVRXpCij0F3NPxOZg0XGAAXo8Y
 braintrust/wrappers/anthropic.py,sha256=sh0UbSWDarU5glic4HIUXNZmMcfn3Odau2K8HzaOIWY,11785
 braintrust/wrappers/dspy.py,sha256=ckPcMHpbVZP6k4R60ZbgegWz82lsK3lu2u9nvN0EIss,13516
 braintrust/wrappers/langchain.py,sha256=0aY5LuVA7BPkgWA0N6CwPG9EaPqRmVVfEPaM1kN4XZY,5028
+braintrust/wrappers/langsmith_wrapper.py,sha256=mWhBnY6KypOlSQw4NrCwzif0Oe6SHV6LYGGiwiz-EJQ,17956
 braintrust/wrappers/litellm.py,sha256=ZE63C8OE5Z0N3mArwOWZusDXBW1MElPOCjODOF-tmB0,26616
 braintrust/wrappers/openai.py,sha256=SZuT4ouJd8FRNXxy9zM_OGb2HNL9XGsFnwkHCk3LDAM,10563
 braintrust/wrappers/pydantic_ai.py,sha256=AgMZS4F7c5Um-P98p13A0uapMFGuYf5YyXuDw1nwPHs,48534
-braintrust/wrappers/test_agno.py,sha256=e-ss-Lr7HMiGvPzsSSTxMblXgzyrbNebrvM062-lVHY,3668
-braintrust/wrappers/test_anthropic.py,sha256=tSHAnroaLK1QYhLhhPFAxSDEJUybzffp2o4IptDZRAU,15554
-braintrust/wrappers/test_dspy.py,sha256=jE-k-joobVbGm8DAyp1eEkbPt_xBleZ10wkWJXLp0nI,1952
-braintrust/wrappers/test_google_genai.py,sha256=W4p3TIuJi2_xXqIVFtwQta7ai-WeoSwAd2y_tReC3Z4,19967
-braintrust/wrappers/test_litellm.py,sha256=miOeXEQm6g8ypvx8LpGlPrnXW-U51glOBP49mdwptc0,23777
-braintrust/wrappers/test_oai_attachments.py,sha256=9UXaXXXzZMLi_Q97QyV2uEtpuTy6BYL6I4olyFfEJ04,11273
-braintrust/wrappers/test_openai.py,sha256=UqKtoIlZlqiLC6x7Rbv9zROgDdE5zvXZObbFMKpmifw,60237
-braintrust/wrappers/test_openrouter.py,sha256=9wIYuwObFkADH8h5pzHFB4C9TcL_HTeq1KlODYhSMLs,3987
-braintrust/wrappers/test_pydantic_ai_integration.py,sha256=zvBqXd7ik-wZEKNMVB6pRTrGZ3XcTSEZ_FG4Ogho9mA,104304
-braintrust/wrappers/test_pydantic_ai_wrap_openai.py,sha256=cxj6uQaObhQ97-mEjN2OStpL4swlWhaln3n2zpIEA_I,5056
+braintrust/wrappers/test_agno.py,sha256=IyxhKOy8kfMbLR_fA__MK7aDvmsJpV-oh-7eez9hrw8,3452
+braintrust/wrappers/test_anthropic.py,sha256=DcLrYhFUhBFiYcP_Su3FcEW6-Ubt21JzjY8Hxwzpcbw,15495
+braintrust/wrappers/test_dspy.py,sha256=peWwbBBi8mpDhp2brs4ozd5cWz_CjYoyQTp7hjvt97U,1759
+braintrust/wrappers/test_google_genai.py,sha256=dY5ZXeTscvrz_8HfSbMr2Qbb_0W-FzUvQSzpG6EZXnU,20204
+braintrust/wrappers/test_langsmith_wrapper.py,sha256=wEbPNy4o7VVvcuHcsCJ-sy2EATvBxhUXTYFBQNkKCjs,10449
+braintrust/wrappers/test_litellm.py,sha256=BAdksj_yzoY0LoHpnDHVgUpOaSxkI_I9Nk5ZZEVuaAU,23604
+braintrust/wrappers/test_oai_attachments.py,sha256=_EtNXjQxPgqXmj6UYMZn9GF4GDZf8m_1_TrwiEk7HWQ,11100
+braintrust/wrappers/test_openai.py,sha256=8gQqJigWmEe3_Nxc5vvPndLIuhIeBY2B2oHLU_vuUkk,60065
+braintrust/wrappers/test_openrouter.py,sha256=8HUfILPugOMqcvttpq76KQrynFb0xZpazvta7TTSF6A,3849
+braintrust/wrappers/test_pydantic_ai_integration.py,sha256=oK26oEI56feg3SwbA-fxkGtVMS8eAC9j-gJsOUudmzw,104106
+braintrust/wrappers/test_pydantic_ai_wrap_openai.py,sha256=OO5NrbothkMr4v2sZ-EZLH7-yLj3k6TfdLG4uzXAsQk,5090
 braintrust/wrappers/test_utils.py,sha256=Qz7LYG5V0DK2KuTJ_YLGpO_Zr_LJFfJgZX_Ps8tlM_c,505
 braintrust/wrappers/agno/__init__.py,sha256=0ehV_7L_ILsMfZ1bKHnzcR_CvFM98KMbGFN9UiE94vI,2379
 braintrust/wrappers/agno/agent.py,sha256=m3HCxQNotJviJswGYMxxsOnMilF-DNGqeFZFJa2Zhs4,6473
@@ -114,8 +116,8 @@ braintrust/wrappers/claude_agent_sdk/__init__.py,sha256=dcBP61ijW2B4g902-09ZfIOk
 braintrust/wrappers/claude_agent_sdk/_wrapper.py,sha256=K6iWfnYSgRq0ETGQ7CCh4rF4JJ0CR-G-VkCUfeKEQ-c,15645
 braintrust/wrappers/claude_agent_sdk/test_wrapper.py,sha256=0NmohdECudFvWtc-5PbANtTXzexkkwIJhGbujydDrT8,6826
 braintrust/wrappers/google_genai/__init__.py,sha256=Yv4hBOUc6TjUpYH3bEW8UaYiZ-sm3TpdVfqUw50NwQU,15826
-braintrust-0.4.2.dist-info/METADATA,sha256=DiX2q-5LiIz53SvCzzwGvoISnjY7YK-peu5Sd6EVM6s,3753
-braintrust-0.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-braintrust-0.4.2.dist-info/entry_points.txt,sha256=Zpc0_09g5xm8as5jHqqFq7fhwO0xHSNct_TrEMONS7Q,60
-braintrust-0.4.2.dist-info/top_level.txt,sha256=hw1-y-UFMf60RzAr8x_eM7SThbIuWfQsQIbVvqSF83A,11
-braintrust-0.4.2.dist-info/RECORD,,
+braintrust-0.4.3.dist-info/METADATA,sha256=XPLnFVJXuBT2YvH3tVwcTR1L8M8gMSCvtpsHWH8AA30,3753
+braintrust-0.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+braintrust-0.4.3.dist-info/entry_points.txt,sha256=Zpc0_09g5xm8as5jHqqFq7fhwO0xHSNct_TrEMONS7Q,60
+braintrust-0.4.3.dist-info/top_level.txt,sha256=hw1-y-UFMf60RzAr8x_eM7SThbIuWfQsQIbVvqSF83A,11
+braintrust-0.4.3.dist-info/RECORD,,