braintrust 0.3.12__py3-none-any.whl → 0.3.13__py3-none-any.whl

braintrust/bt_json.py

@@ -2,27 +2,115 @@ import dataclasses
 import json
 from typing import Any, cast
 
+# Try to import orjson for better performance
+# If not available, we'll use standard json
+try:
+    import orjson
+
+    _HAS_ORJSON = True
+except ImportError:
+    _HAS_ORJSON = False
+
+
+def _to_dict(obj: Any) -> Any:
+    """
+    Function-based default handler for non-JSON-serializable objects.
+
+    Handles:
+    - dataclasses
+    - Pydantic v2 BaseModel
+    - Pydantic v1 BaseModel
+    - Falls back to str() for unknown types
+    """
+    if dataclasses.is_dataclass(obj) and not isinstance(obj, type):
+        return dataclasses.asdict(obj)
+
+    # Attempt to dump a Pydantic v2 `BaseModel`.
+    try:
+        return cast(Any, obj).model_dump()
+    except (AttributeError, TypeError):
+        pass
+
+    # Attempt to dump a Pydantic v1 `BaseModel`.
+    try:
+        return cast(Any, obj).dict()
+    except (AttributeError, TypeError):
+        pass
+
+    # When everything fails, try to return the string representation of the object
+    try:
+        return str(obj)
+    except Exception:
+        # If str() fails, return an error placeholder
+        return f"<non-serializable: {type(obj).__name__}>"
+
 
 class BraintrustJSONEncoder(json.JSONEncoder):
+    """
+    Custom JSON encoder for standard json library.
+
+    This is used as a fallback when orjson is not available or fails.
+    """
+
     def default(self, o: Any):
-        if dataclasses.is_dataclass(o) and not isinstance(o, type):
-            return dataclasses.asdict(o)
+        return _to_dict(o)
 
-        # Attempt to dump a Pydantic v2 `BaseModel`.
-        try:
-            return cast(Any, o).model_dump()
-        except (AttributeError, TypeError):
-            pass
 
-        # Attempt to dump a Pydantic v1 `BaseModel`.
+def bt_dumps(obj, **kwargs) -> str:
+    """
+    Serialize obj to a JSON-formatted string.
+
+    Automatically uses orjson if available for better performance (3-5x faster),
+    with fallback to standard json library if orjson is not installed or fails.
+
+    Args:
+        obj: Object to serialize
+        **kwargs: Additional arguments (passed to json.dumps in fallback path)
+
+    Returns:
+        JSON string representation of obj
+    """
+    if _HAS_ORJSON:
+        # Try orjson first for better performance
         try:
-            return cast(Any, o).dict()
-        except (AttributeError, TypeError):
+            # pylint: disable=no-member  # orjson is a C extension, pylint can't introspect it
+            return orjson.dumps(  # type: ignore[possibly-unbound]
+                obj,
+                default=_to_dict,
+                # options match json.dumps behavior for bc
+                option=orjson.OPT_SORT_KEYS | orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_NON_STR_KEYS,  # type: ignore[possibly-unbound]
+            ).decode("utf-8")
+        except Exception:
+            # If orjson fails, fall back to standard json
             pass
 
-        # When everything fails, just return the string representation of the object
-        return str(o)
+    # Use standard json (either orjson not available or it failed)
+    # Use sort_keys=True for deterministic output (matches orjson OPT_SORT_KEYS)
+    return json.dumps(obj, cls=BraintrustJSONEncoder, allow_nan=False, sort_keys=True, **kwargs)
 
 
-def bt_dumps(obj, **kwargs) -> str:
-    return json.dumps(obj, cls=BraintrustJSONEncoder, allow_nan=False, **kwargs)
+def bt_loads(s: str, **kwargs) -> Any:
+    """
+    Deserialize s (a str containing a JSON document) to a Python object.
+
+    Automatically uses orjson if available for better performance (2-3x faster),
+    with fallback to standard json library if orjson is not installed or fails.
+
+    Args:
+        s: JSON string to deserialize
+        **kwargs: Additional arguments (passed to json.loads in fallback path)
+
+    Returns:
+        Python object representation of JSON string
+    """
+    if _HAS_ORJSON:
+        # Try orjson first for better performance
+        try:
+            # pylint: disable=no-member  # orjson is a C extension, pylint can't introspect it
+            return orjson.loads(s)  # type: ignore[possibly-unbound]
+        except Exception:
+            # If orjson fails, fall back to standard json
+            pass
+
+    # Use standard json (either orjson not available or it failed)
+    return json.loads(s, **kwargs)

braintrust/logger.py

@@ -9,6 +9,7 @@ import inspect
 import io
 import json
 import logging
+import math
 import os
 import sys
 import textwrap
@@ -53,7 +54,7 @@ from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 
 from . import context, id_gen
-from .bt_json import bt_dumps
+from .bt_json import bt_dumps, bt_loads
 from .db_fields import (
     ASYNC_SCORING_CONTROL_FIELD,
     AUDIT_METADATA_FIELD,
@@ -2471,7 +2472,15 @@ def _deep_copy_event(event: Mapping[str, Any]) -> Dict[str, Any]:
                     # `json.dumps`. However, that runs at log upload time, while we want to
                     # cut out all the references to user objects synchronously in this
                     # function.
-                    return {str(k): _deep_copy_object(v[k], depth + 1) for k in v}
+                    result = {}
+                    for k in v:
+                        try:
+                            key_str = str(k)
+                        except Exception:
+                            # If str() fails on the key, use a fallback representation
+                            key_str = f"<non-stringifiable-key: {type(k).__name__}>"
+                        result[key_str] = _deep_copy_object(v[k], depth + 1)
+                    return result
                 elif isinstance(v, (List, Tuple, Set)):
                     return [_deep_copy_object(x, depth + 1) for x in v]
             finally:
@@ -2491,7 +2500,14 @@ def _deep_copy_event(event: Mapping[str, Any]) -> Dict[str, Any]:
             return v
         elif isinstance(v, ReadonlyAttachment):
             return v.reference
-        elif isinstance(v, (int, float, str, bool)) or v is None:
+        elif isinstance(v, float):
+            # Handle NaN and Infinity for JSON compatibility
+            if math.isnan(v):
+                return "NaN"
+            elif math.isinf(v):
+                return "Infinity" if v > 0 else "-Infinity"
+            return v
+        elif isinstance(v, (int, str, bool)) or v is None:
             # Skip roundtrip for primitive types.
             return v
         else:
@@ -2500,7 +2516,7 @@ def _deep_copy_event(event: Mapping[str, Any]) -> Dict[str, Any]:
             # E.g. the original type could have a `__del__` method that alters
             # some shared internal state, and we need this deep copy to be
             # fully-independent from the original.
-            return json.loads(bt_dumps(v))
+            return bt_loads(bt_dumps(v))
 
     return _deep_copy_object(event)
 
@@ -2523,7 +2539,7 @@ class ObjectIterator(Generic[T]):
         return value
 
 
-INTERNAL_BTQL_LIMIT = 1000
+DEFAULT_FETCH_BATCH_SIZE = 1000
 MAX_BTQL_ITERATIONS = 10000
 
 
@@ -2550,7 +2566,7 @@ class ObjectFetcher(ABC, Generic[TMapping]):
         self._fetched_data: Optional[List[TMapping]] = None
         self._internal_btql = _internal_btql
 
-    def fetch(self) -> Iterator[TMapping]:
+    def fetch(self, batch_size: Optional[int] = None) -> Iterator[TMapping]:
         """
         Fetch all records.
 
@@ -2563,9 +2579,10 @@ class ObjectFetcher(ABC, Generic[TMapping]):
             print(record)
         ```
 
+        :param batch_size: The number of records to fetch per request. Defaults to 1000.
         :returns: An iterator over the records.
         """
-        return ObjectIterator(self._refetch)
+        return ObjectIterator(lambda: self._refetch(batch_size=batch_size))
 
     def __iter__(self) -> Iterator[TMapping]:
         return self.fetch()
@@ -2584,8 +2601,9 @@ class ObjectFetcher(ABC, Generic[TMapping]):
     @abstractmethod
     def id(self) -> str: ...
 
-    def _refetch(self) -> List[TMapping]:
+    def _refetch(self, batch_size: Optional[int] = None) -> List[TMapping]:
         state = self._get_state()
+        limit = batch_size if batch_size is not None else DEFAULT_FETCH_BATCH_SIZE
         if self._fetched_data is None:
             cursor = None
             data = None
@@ -2610,7 +2628,7 @@ class ObjectFetcher(ABC, Generic[TMapping]):
                                 ],
                             },
                             "cursor": cursor,
-                            "limit": INTERNAL_BTQL_LIMIT,
+                            "limit": limit,
                             **(self._internal_btql or {}),
                         },
                         "use_columnstore": False,
@@ -3761,8 +3779,14 @@ class ReadonlyExperiment(ObjectFetcher[ExperimentEvent]):
         self._lazy_metadata.get()
         return self.state
 
-    def as_dataset(self) -> Iterator[_ExperimentDatasetEvent]:
-        return ExperimentDatasetIterator(self.fetch())
+    def as_dataset(self, batch_size: Optional[int] = None) -> Iterator[_ExperimentDatasetEvent]:
+        """
+        Return the experiment's data as a dataset iterator.
+
+        :param batch_size: The number of records to fetch per request. Defaults to 1000.
+        :returns: An iterator over the experiment data as dataset records.
+        """
+        return ExperimentDatasetIterator(self.fetch(batch_size=batch_size))
 
 
 _EXEC_COUNTER_LOCK = threading.Lock()

braintrust/test_logger.py

@@ -716,6 +716,107 @@ def test_span_log_with_large_document_many_pages(with_memory_logger):
     assert logged_output["pages"][0]["lines"][0]["words"][0]["content"] == "word_0"
 
 
+def test_span_log_handles_nan_gracefully(with_memory_logger):
+    """Test that span.log() handles NaN values by converting them to "NaN" string."""
+    logger = init_test_logger(__name__)
+
+    with logger.start_span(name="test_span") as span:
+        # Should NOT raise - should handle NaN gracefully
+        span.log(
+            input={"test": "input"},
+            output={"value": float("nan")},
+        )
+
+    # Verify the log was recorded with NaN handled appropriately
+    logs = with_memory_logger.pop()
+    assert len(logs) == 1
+    assert logs[0]["input"]["test"] == "input"
+    # NaN should be converted to "NaN" string for JSON compatibility
+    output_value = logs[0]["output"]["value"]
+    assert output_value == "NaN"
+
+
+def test_span_log_handles_infinity_gracefully(with_memory_logger):
+    """Test that span.log() handles Infinity values by converting them to "Infinity"/"-Infinity" strings."""
+    logger = init_test_logger(__name__)
+
+    with logger.start_span(name="test_span") as span:
+        # Should NOT raise - should handle Infinity gracefully
+        span.log(
+            input={"test": "input"},
+            output={"value": float("inf"), "neg": float("-inf")},
+        )
+
+    # Verify the log was recorded with Infinity handled appropriately
+    logs = with_memory_logger.pop()
+    assert len(logs) == 1
+    assert logs[0]["input"]["test"] == "input"
+    # Infinity should be converted to string representations for JSON compatibility
+    assert logs[0]["output"]["value"] == "Infinity"
+    assert logs[0]["output"]["neg"] == "-Infinity"
+
+
+def test_span_log_handles_unstringifiable_object_gracefully(with_memory_logger):
+    """Test that span.log() should handle objects with bad __str__ gracefully without raising.
+
+    This test currently FAILS - it demonstrates the desired behavior after the fix.
+    """
+    logger = init_test_logger(__name__)
+
+    class BadStrObject:
+        def __str__(self):
+            raise RuntimeError("Cannot convert to string!")
+
+        def __repr__(self):
+            raise RuntimeError("Cannot convert to repr!")
+
+    with logger.start_span(name="test_span") as span:
+        # Should NOT raise - should handle gracefully
+        span.log(
+            input={"test": "input"},
+            output={"result": BadStrObject()},
+        )
+
+    # Verify the log was recorded with a fallback representation
+    logs = with_memory_logger.pop()
+    assert len(logs) == 1
+    assert logs[0]["input"]["test"] == "input"
+    # The bad object should have been replaced with some error placeholder
+    assert "result" in logs[0]["output"]
+    output_str = str(logs[0]["output"]["result"])
+    # Should contain some indication of serialization failure
+    assert "error" in output_str.lower() or "serializ" in output_str.lower()
+
+
+def test_span_log_handles_bad_dict_keys_gracefully(with_memory_logger):
+    """Test that span.log() should handle non-stringifiable dict keys gracefully.
+
+    This test currently FAILS - it demonstrates the desired behavior after the fix.
+    """
+    logger = init_test_logger(__name__)
+
+    class BadKey:
+        def __str__(self):
+            raise ValueError("Key cannot be stringified!")
+
+        def __repr__(self):
+            raise ValueError("Key cannot be stringified!")
+
+    with logger.start_span(name="test_span") as span:
+        # Should NOT raise - should handle gracefully
+        span.log(
+            input={"test": "input"},
+            output={BadKey(): "value"},
+        )
+
+    # Verify the log was recorded with the problematic key handled
+    logs = with_memory_logger.pop()
+    assert len(logs) == 1
+    assert logs[0]["input"]["test"] == "input"
+    # The output should exist but the bad key should be replaced
+    assert "output" in logs[0]
+
+
 def test_span_link_logged_out(with_memory_logger):
     simulate_logout()
     assert_logged_out()
@@ -2491,7 +2592,7 @@ class TestDatasetInternalBtql(TestCase):
 
     @patch("braintrust.logger.BraintrustState")
     def test_dataset_internal_btql_limit_not_overwritten(self, mock_state_class):
-        """Test that custom limit in _internal_btql is not overwritten by INTERNAL_BTQL_LIMIT."""
+        """Test that custom limit in _internal_btql is not overwritten by DEFAULT_FETCH_BATCH_SIZE."""
         # Set up mock state
         mock_state = MagicMock()
         mock_state_class.return_value = mock_state
@@ -2538,7 +2639,7 @@ class TestDatasetInternalBtql(TestCase):
         call_args = mock_api_conn.post.call_args
         query_json = call_args[1]["json"]["query"]
 
-        # Verify that the custom limit is present (not overwritten by INTERNAL_BTQL_LIMIT)
+        # Verify that the custom limit is present (not overwritten by DEFAULT_FETCH_BATCH_SIZE)
         self.assertEqual(query_json["limit"], custom_limit)
 
         # Verify that other _internal_btql fields are also present
@@ -2546,8 +2647,14 @@ class TestDatasetInternalBtql(TestCase):
 
     @patch("braintrust.logger.BraintrustState")
     def test_dataset_default_limit_when_not_specified(self, mock_state_class):
-        """Test that INTERNAL_BTQL_LIMIT is used when no custom limit is specified."""
-        from braintrust.logger import INTERNAL_BTQL_LIMIT, Dataset, LazyValue, ObjectMetadata, ProjectDatasetMetadata
+        """Test that DEFAULT_FETCH_BATCH_SIZE is used when no custom limit is specified."""
+        from braintrust.logger import (
+            DEFAULT_FETCH_BATCH_SIZE,
+            Dataset,
+            LazyValue,
+            ObjectMetadata,
+            ProjectDatasetMetadata,
+        )
 
         # Set up mock state
         mock_state = MagicMock()
@@ -2590,4 +2697,52 @@ class TestDatasetInternalBtql(TestCase):
         query_json = call_args[1]["json"]["query"]
 
         # Verify that the default limit is used
-        self.assertEqual(query_json["limit"], INTERNAL_BTQL_LIMIT)
+        self.assertEqual(query_json["limit"], DEFAULT_FETCH_BATCH_SIZE)
+
+    @patch("braintrust.logger.BraintrustState")
+    def test_dataset_custom_batch_size_in_fetch(self, mock_state_class):
+        """Test that custom batch_size in fetch() is properly passed to BTQL query."""
+        from braintrust.logger import Dataset, LazyValue, ObjectMetadata, ProjectDatasetMetadata
+
+        # Set up mock state
+        mock_state = MagicMock()
+        mock_state_class.return_value = mock_state
+
+        # Mock the API connection and response
+        mock_api_conn = MagicMock()
+        mock_state.api_conn.return_value = mock_api_conn
+
+        # Mock response object
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "data": [{"id": "1", "input": "test1", "expected": "output1"}],
+            "cursor": None,
+        }
+        mock_api_conn.post.return_value = mock_response
+
+        # Create dataset
+        project_metadata = ObjectMetadata(id="test-project", name="test-project", full_info={})
+        dataset_metadata = ObjectMetadata(id="test-dataset", name="test-dataset", full_info={})
+        lazy_metadata = LazyValue(
+            lambda: ProjectDatasetMetadata(project=project_metadata, dataset=dataset_metadata),
+            use_mutex=False,
+        )
+
+        dataset = Dataset(
+            lazy_metadata=lazy_metadata,
+            state=mock_state,
+        )
+
+        # Trigger a fetch with custom batch_size
+        custom_batch_size = 250
+        list(dataset.fetch(batch_size=custom_batch_size))
+
+        # Verify the API was called
+        mock_api_conn.post.assert_called_once()
+
+        # Get the actual call arguments
+        call_args = mock_api_conn.post.call_args
+        query_json = call_args[1]["json"]["query"]
+
+        # Verify that the custom batch_size is used
+        self.assertEqual(query_json["limit"], custom_batch_size)

braintrust/version.py

@@ -1,4 +1,4 @@
-VERSION = "0.3.12"
+VERSION = "0.3.13"
 
 # this will be templated during the build
-GIT_COMMIT = "8c2b2995c2097f5699c101f4ab5e653ff40014a1"
+GIT_COMMIT = "cef88a007fa60f4cd873f1d891a54ce5e173f3aa"

{braintrust-0.3.12.dist-info → braintrust-0.3.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braintrust
-Version: 0.3.12
+Version: 0.3.13
 Summary: SDK for integrating Braintrust
 Home-page: https://www.braintrust.dev
 Author: Braintrust
@@ -75,6 +75,20 @@ Install the library with pip.
 pip install braintrust
 ```
 
+**Performance tip**: For 3-5x faster JSON serialization, install with the optional `performance` extra:
+
+```bash
+pip install braintrust[performance]
+```
+
+Or install `orjson` separately:
+
+```bash
+pip install orjson
+```
+
+The SDK automatically detects and uses orjson if available, with seamless fallback to standard json. See [ORJSON_OPTIMIZATION.md](ORJSON_OPTIMIZATION.md) for details.
+
 Then, run a simple experiment with the following code (replace `YOUR_API_KEY` with
 your Braintrust API key):
 
@@ -100,3 +114,7 @@ Eval(
   scores=[is_equal],
 )
 ```
+
+# Performance Optimization
+
+For 3-5x faster JSON serialization, install `orjson`. The SDK automatically detects and uses orjson if available, with seamless fallback to standard json.

{braintrust-0.3.12.dist-info → braintrust-0.3.13.dist-info}/RECORD

@@ -2,7 +2,7 @@ braintrust/__init__.py,sha256=-NLWOaTdzVtQFu2TA0qYULbxP4pAdVdgqzZWosqL2eI,2092
 braintrust/_generated_types.py,sha256=X5UGdtWp9vnoyUd4PyY74xjWIoNRVqiqWHNpYd-v0to,80911
 braintrust/audit.py,sha256=Na3LJhpHj8Nd1az41HMQLLbHeWQkDZIOYHLLmVZdAdQ,467
 braintrust/aws.py,sha256=OBz_SRyopgpCDSNvETLypzGwTXk-bNLn-Eisevnjfwo,377
-braintrust/bt_json.py,sha256=NrpEpl7FkwgL3sSg_XoKCR8HYy9uEiBOfaJ4r7HkW2U,816
+braintrust/bt_json.py,sha256=f2AkpVxT2LY3PZliJn-jH_1Qd9nujnSJcFronTdlsBE,3650
 braintrust/conftest.py,sha256=EZi9aU9g8O6XWwPP6EMv5OcDLkVwI5he_TTGM4jCMlQ,1598
 braintrust/context.py,sha256=ZXIOc3zXIXOzAopkuPIM9tq2prfsTjH0-e_FEEFTTJI,4235
 braintrust/db_fields.py,sha256=DBGFhfu9B3aLQI6cU6P2WGrdfCIs8AzDFRQEUBt9NCw,439
@@ -14,7 +14,7 @@ braintrust/gitutil.py,sha256=bEk38AlNtT-umtdCJ9lnSXlbKXsvjBOyTTsmzUKiVtM,5586
 braintrust/graph_util.py,sha256=lABIOMzxHf6E5LfDYfqa4OUR4uaW7xgUYNq5WGewD4w,5594
 braintrust/http_headers.py,sha256=9ZsDcsAKG04SGowsgchZktD6rG_oSTKWa8QyGUPA4xE,154
 braintrust/id_gen.py,sha256=PVkz-pS-9AzgmnAgpV-jgOFFo4hfl6e3IP9dVt6FouQ,1595
-braintrust/logger.py,sha256=qIElwbRqzT_3mrQ1XiS7razFxADjL6775eukwkiIhA0,209333
+braintrust/logger.py,sha256=NTbxgXa_qsu7bwl4bUoLuj9HNDuaGQiDlu0-addkAQc,210560
 braintrust/merge_row_batch.py,sha256=NX4jRE9uuFB3Z7btrarQp_di84_NGTjvzpJhksn82W8,9882
 braintrust/oai.py,sha256=DW_i6bXXDprwZ_uwcdIE25MUxx5y5DDdqr0ucdIWP9I,33187
 braintrust/object.py,sha256=vYLyYWncsqLD00zffZUJwGTSkcJF9IIXmgIzrx3Np5c,632
@@ -34,7 +34,7 @@ braintrust/test_framework.py,sha256=fALvUefSmNOdQcEVgKHvdCOnPlUreZjhF5AiqfNLBPg,
 braintrust/test_framework2.py,sha256=pSEEmBIyszAiYnpEVvDZgJqIe3lQ3T807LmIuBqV98w,7235
 braintrust/test_helpers.py,sha256=-RrxDtyCfOOukhdN6tFSwr-Nmq7DrNQ7KO45hySqNZ0,13549
 braintrust/test_id_gen.py,sha256=mgArTyEBV-Xv21ARHPSHEPBsJshZrvIiPjBLNOKsAko,2490
-braintrust/test_logger.py,sha256=IgsfNUvztNqUd6NL4fh_IYsW44dkGxneiHsTxYSFozY,92846
+braintrust/test_logger.py,sha256=Z3euqSHmc4kqsyKo838tkYGK8B1rTkIdxl7QZYR1CLk,98516
 braintrust/test_otel.py,sha256=janmEtu6dyFQL8N68WjRTS-65Kr5vSNSSwIaBWqXlyw,27243
 braintrust/test_queue.py,sha256=MdH6R9uSk_4akY4Db514Cpukwiy2RJ76Lqts1nQwZJY,8432
 braintrust/test_serializable_data_class.py,sha256=b04Ym64YtC6GJRGbKIN4J20RG1QN1FlnODwtEQh4sv0,1897
@@ -42,7 +42,7 @@ braintrust/test_span_components.py,sha256=UnF6ZL4k41XZ-CnfbjuqLeK4MZLtHTMdID3CMh
 braintrust/test_util.py,sha256=gyqe2JspRP7oXlp6ENztZe2fdRTOEMZMKpQi00y1DSc,4538
 braintrust/test_version.py,sha256=hk5JKjEFbNJ_ONc1VEkqHquflzre34RpFhCEYLTK8iA,1051
 braintrust/util.py,sha256=Ec6sRkQw5BckGrFjdA4YTyu_2BaKmHh4tWDwAi_ysOw,7227
-braintrust/version.py,sha256=i1ljewUfl4VA2SYv_e8CfC5C1RUiCNBL8mOBlRusJHk,118
+braintrust/version.py,sha256=YyNQY-UJ0O_hVg8XR4VJGGwb-qChpEoYLN6jfWC4rEQ,118
 braintrust/xact_ids.py,sha256=bdyp88HjlyIkglgLSqYlCYscdSH6EWVyE14sR90Xl1s,658
 braintrust/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 braintrust/cli/__main__.py,sha256=wCBKHGVmn3IT_yMXk5qfDwyI2SV2gf1tLr0NTxm9T8k,1519
@@ -109,8 +109,8 @@ braintrust/wrappers/claude_agent_sdk/__init__.py,sha256=CSXJWy-z2fHF7h4VJjLSnXJv
 braintrust/wrappers/claude_agent_sdk/_wrapper.py,sha256=uzElIOwwPmF_Y5fbWcKWEPC8HnSzW7byzpiuVKK0TXE,15613
 braintrust/wrappers/claude_agent_sdk/test_wrapper.py,sha256=0NmohdECudFvWtc-5PbANtTXzexkkwIJhGbujydDrT8,6826
 braintrust/wrappers/google_genai/__init__.py,sha256=PGFMuR3c4Gc3SUt24eP7z5AzdS2Dc1uF1d3QPCnLnuo,16018
-braintrust-0.3.12.dist-info/METADATA,sha256=LMIW6iDtc0F1i6QsqMWoUcJn6RREF0H9XJ0n6mHjYb4,3131
-braintrust-0.3.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-braintrust-0.3.12.dist-info/entry_points.txt,sha256=Zpc0_09g5xm8as5jHqqFq7fhwO0xHSNct_TrEMONS7Q,60
-braintrust-0.3.12.dist-info/top_level.txt,sha256=hw1-y-UFMf60RzAr8x_eM7SThbIuWfQsQIbVvqSF83A,11
-braintrust-0.3.12.dist-info/RECORD,,
+braintrust-0.3.13.dist-info/METADATA,sha256=cZM8kCyxf7v0SHVRVPHBElZcVIis1GcwcXTOea54WPo,3702
+braintrust-0.3.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+braintrust-0.3.13.dist-info/entry_points.txt,sha256=Zpc0_09g5xm8as5jHqqFq7fhwO0xHSNct_TrEMONS7Q,60
+braintrust-0.3.13.dist-info/top_level.txt,sha256=hw1-y-UFMf60RzAr8x_eM7SThbIuWfQsQIbVvqSF83A,11
+braintrust-0.3.13.dist-info/RECORD,,