feat(openai): instrument Audio API (speech, transcriptions, translations)

py/src/braintrust/integrations/openai/integration.py

@@ -3,6 +3,9 @@
 from braintrust.integrations.base import BaseIntegration
 
 from .patchers import (
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
@@ -19,5 +22,8 @@ class OpenAIIntegration(BaseIntegration):
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ResponsesPatcher,
  )

py/src/braintrust/integrations/openai/patchers.py

@@ -7,6 +7,9 @@
 from wrapt import BoundFunctionWrapper, FunctionWrapper
 
 from .tracing import (
+ _audio_speech_create_wrapper,
+ _audio_transcription_create_wrapper,
+ _audio_translation_create_wrapper,
  _chat_completion_create_wrapper,
  _chat_completion_parse_wrapper,
  _embedding_create_wrapper,
@@ -182,6 +185,96 @@ class _WrapModerations(CompositeFunctionWrapperPatcher):
  sub_patchers = (_wrap_mod_create,)
 
 
+# ---------------------------------------------------------------------------
+# Audio — Speech
+# ---------------------------------------------------------------------------
+
+_speech_create_sync, _speech_create_async, _wrap_speech_create = _make_method_patchers(
+ name_prefix="openai.audio.speech.create",
+ target_module="openai.resources.audio.speech",
+ sync_class="Speech",
+ async_class="AsyncSpeech",
+ method="create",
+ wrapper=_audio_speech_create_wrapper,
+ wrap_name="openai.wrap.audio.speech.create",
+)
+
+
+class AudioSpeechPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.speech`` for tracing."""
+
+ name = "openai.audio.speech"
+ sub_patchers = (
+ _speech_create_sync,
+ _speech_create_async,
+ )
+
+
+class _WrapAudioSpeech(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.speech"
+ sub_patchers = (_wrap_speech_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Transcriptions
+# ---------------------------------------------------------------------------
+
+_transcription_create_sync, _transcription_create_async, _wrap_transcription_create = _make_method_patchers(
+ name_prefix="openai.audio.transcriptions.create",
+ target_module="openai.resources.audio.transcriptions",
+ sync_class="Transcriptions",
+ async_class="AsyncTranscriptions",
+ method="create",
+ wrapper=_audio_transcription_create_wrapper,
+ wrap_name="openai.wrap.audio.transcriptions.create",
+)
+
+
+class AudioTranscriptionsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.transcriptions`` for tracing."""
+
+ name = "openai.audio.transcriptions"
+ sub_patchers = (
+ _transcription_create_sync,
+ _transcription_create_async,
+ )
+
+
+class _WrapAudioTranscriptions(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.transcriptions"
+ sub_patchers = (_wrap_transcription_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Translations
+# ---------------------------------------------------------------------------
+
+_translation_create_sync, _translation_create_async, _wrap_translation_create = _make_method_patchers(
+ name_prefix="openai.audio.translations.create",
+ target_module="openai.resources.audio.translations",
+ sync_class="Translations",
+ async_class="AsyncTranslations",
+ method="create",
+ wrapper=_audio_translation_create_wrapper,
+ wrap_name="openai.wrap.audio.translations.create",
+)
+
+
+class AudioTranslationsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.translations`` for tracing."""
+
+ name = "openai.audio.translations"
+ sub_patchers = (
+ _translation_create_sync,
+ _translation_create_async,
+ )
+
+
+class _WrapAudioTranslations(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.translations"
+ sub_patchers = (_wrap_translation_create,)
+
+
 # ---------------------------------------------------------------------------
 # Responses
 # ---------------------------------------------------------------------------
@@ -269,6 +362,9 @@ class _WrapResponsesRaw(CompositeFunctionWrapperPatcher):
  ("chat.completions", _WrapChatCompletions),
  ("embeddings", _WrapEmbeddings),
  ("moderations", _WrapModerations),
+ ("audio.speech", _WrapAudioSpeech),
+ ("audio.transcriptions", _WrapAudioTranscriptions),
+ ("audio.translations", _WrapAudioTranslations),
  ("responses", _WrapResponses),
  ("responses.with_raw_response", _WrapResponsesRaw),
  ("beta.chat.completions", _WrapChatCompletions),

py/src/braintrust/integrations/openai/test_openai.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import time
 
 import openai
@@ -1714,6 +1715,195 @@ def _is_wrapped(client):
  return isinstance(attr, FunctionWrapper)
 
 
+TEST_AUDIO_FILE = os.path.join(os.path.dirname(__file__), "..", "..", "fixtures", "test_audio.wav")
+
+
+@pytest.mark.vcr
+def test_openai_audio_speech(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ response = client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ response2 = client2.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription_text_format(memory_logger):
+ """When response_format='text', the API returns a plain string (not JSON)."""
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span with the plain-text output
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_translation(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.translations.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_speech_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ response = await client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_transcription_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_translation_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
 class TestOpenAIIntegrationSetupSpans:
  """VCR-based tests verifying that OpenAIIntegration.setup() produces spans."""
 

py/src/braintrust/integrations/openai/integration.py

@@ -3,6 +3,9 @@
 from braintrust.integrations.base import BaseIntegration
 
 from .patchers import (
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
@@ -19,5 +22,8 @@ class OpenAIIntegration(BaseIntegration):
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ResponsesPatcher,
  )

py/src/braintrust/integrations/openai/patchers.py

@@ -7,6 +7,9 @@
 from wrapt import BoundFunctionWrapper, FunctionWrapper
 
 from .tracing import (
+ _audio_speech_create_wrapper,
+ _audio_transcription_create_wrapper,
+ _audio_translation_create_wrapper,
  _chat_completion_create_wrapper,
  _chat_completion_parse_wrapper,
  _embedding_create_wrapper,
@@ -182,6 +185,96 @@ class _WrapModerations(CompositeFunctionWrapperPatcher):
  sub_patchers = (_wrap_mod_create,)
 
 
+# ---------------------------------------------------------------------------
+# Audio — Speech
+# ---------------------------------------------------------------------------
+
+_speech_create_sync, _speech_create_async, _wrap_speech_create = _make_method_patchers(
+ name_prefix="openai.audio.speech.create",
+ target_module="openai.resources.audio.speech",
+ sync_class="Speech",
+ async_class="AsyncSpeech",
+ method="create",
+ wrapper=_audio_speech_create_wrapper,
+ wrap_name="openai.wrap.audio.speech.create",
+)
+
+
+class AudioSpeechPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.speech`` for tracing."""
+
+ name = "openai.audio.speech"
+ sub_patchers = (
+ _speech_create_sync,
+ _speech_create_async,
+ )
+
+
+class _WrapAudioSpeech(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.speech"
+ sub_patchers = (_wrap_speech_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Transcriptions
+# ---------------------------------------------------------------------------
+
+_transcription_create_sync, _transcription_create_async, _wrap_transcription_create = _make_method_patchers(
+ name_prefix="openai.audio.transcriptions.create",
+ target_module="openai.resources.audio.transcriptions",
+ sync_class="Transcriptions",
+ async_class="AsyncTranscriptions",
+ method="create",
+ wrapper=_audio_transcription_create_wrapper,
+ wrap_name="openai.wrap.audio.transcriptions.create",
+)
+
+
+class AudioTranscriptionsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.transcriptions`` for tracing."""
+
+ name = "openai.audio.transcriptions"
+ sub_patchers = (
+ _transcription_create_sync,
+ _transcription_create_async,
+ )
+
+
+class _WrapAudioTranscriptions(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.transcriptions"
+ sub_patchers = (_wrap_transcription_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Translations
+# ---------------------------------------------------------------------------
+
+_translation_create_sync, _translation_create_async, _wrap_translation_create = _make_method_patchers(
+ name_prefix="openai.audio.translations.create",
+ target_module="openai.resources.audio.translations",
+ sync_class="Translations",
+ async_class="AsyncTranslations",
+ method="create",
+ wrapper=_audio_translation_create_wrapper,
+ wrap_name="openai.wrap.audio.translations.create",
+)
+
+
+class AudioTranslationsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.translations`` for tracing."""
+
+ name = "openai.audio.translations"
+ sub_patchers = (
+ _translation_create_sync,
+ _translation_create_async,
+ )
+
+
+class _WrapAudioTranslations(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.translations"
+ sub_patchers = (_wrap_translation_create,)
+
+
 # ---------------------------------------------------------------------------
 # Responses
 # ---------------------------------------------------------------------------
@@ -269,6 +362,9 @@ class _WrapResponsesRaw(CompositeFunctionWrapperPatcher):
  ("chat.completions", _WrapChatCompletions),
  ("embeddings", _WrapEmbeddings),
  ("moderations", _WrapModerations),
+ ("audio.speech", _WrapAudioSpeech),
+ ("audio.transcriptions", _WrapAudioTranscriptions),
+ ("audio.translations", _WrapAudioTranslations),
  ("responses", _WrapResponses),
  ("responses.with_raw_response", _WrapResponsesRaw),
  ("beta.chat.completions", _WrapChatCompletions),

py/src/braintrust/integrations/openai/test_openai.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import time
 
 import openai
@@ -1714,6 +1715,195 @@ def _is_wrapped(client):
  return isinstance(attr, FunctionWrapper)
 
 
+TEST_AUDIO_FILE = os.path.join(os.path.dirname(__file__), "..", "..", "fixtures", "test_audio.wav")
+
+
+@pytest.mark.vcr
+def test_openai_audio_speech(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ response = client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ response2 = client2.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription_text_format(memory_logger):
+ """When response_format='text', the API returns a plain string (not JSON)."""
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span with the plain-text output
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_translation(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.translations.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_speech_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ response = await client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_transcription_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_translation_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
 class TestOpenAIIntegrationSetupSpans:
  """VCR-based tests verifying that OpenAIIntegration.setup() produces spans."""
 

py/src/braintrust/integrations/openai/integration.py

@@ -3,6 +3,9 @@
 from braintrust.integrations.base import BaseIntegration
 
 from .patchers import (
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
@@ -19,5 +22,8 @@ class OpenAIIntegration(BaseIntegration):
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ResponsesPatcher,
  )

py/src/braintrust/integrations/openai/patchers.py

@@ -7,6 +7,9 @@
 from wrapt import BoundFunctionWrapper, FunctionWrapper
 
 from .tracing import (
+ _audio_speech_create_wrapper,
+ _audio_transcription_create_wrapper,
+ _audio_translation_create_wrapper,
  _chat_completion_create_wrapper,
  _chat_completion_parse_wrapper,
  _embedding_create_wrapper,
@@ -182,6 +185,96 @@ class _WrapModerations(CompositeFunctionWrapperPatcher):
  sub_patchers = (_wrap_mod_create,)
 
 
+# ---------------------------------------------------------------------------
+# Audio — Speech
+# ---------------------------------------------------------------------------
+
+_speech_create_sync, _speech_create_async, _wrap_speech_create = _make_method_patchers(
+ name_prefix="openai.audio.speech.create",
+ target_module="openai.resources.audio.speech",
+ sync_class="Speech",
+ async_class="AsyncSpeech",
+ method="create",
+ wrapper=_audio_speech_create_wrapper,
+ wrap_name="openai.wrap.audio.speech.create",
+)
+
+
+class AudioSpeechPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.speech`` for tracing."""
+
+ name = "openai.audio.speech"
+ sub_patchers = (
+ _speech_create_sync,
+ _speech_create_async,
+ )
+
+
+class _WrapAudioSpeech(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.speech"
+ sub_patchers = (_wrap_speech_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Transcriptions
+# ---------------------------------------------------------------------------
+
+_transcription_create_sync, _transcription_create_async, _wrap_transcription_create = _make_method_patchers(
+ name_prefix="openai.audio.transcriptions.create",
+ target_module="openai.resources.audio.transcriptions",
+ sync_class="Transcriptions",
+ async_class="AsyncTranscriptions",
+ method="create",
+ wrapper=_audio_transcription_create_wrapper,
+ wrap_name="openai.wrap.audio.transcriptions.create",
+)
+
+
+class AudioTranscriptionsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.transcriptions`` for tracing."""
+
+ name = "openai.audio.transcriptions"
+ sub_patchers = (
+ _transcription_create_sync,
+ _transcription_create_async,
+ )
+
+
+class _WrapAudioTranscriptions(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.transcriptions"
+ sub_patchers = (_wrap_transcription_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Translations
+# ---------------------------------------------------------------------------
+
+_translation_create_sync, _translation_create_async, _wrap_translation_create = _make_method_patchers(
+ name_prefix="openai.audio.translations.create",
+ target_module="openai.resources.audio.translations",
+ sync_class="Translations",
+ async_class="AsyncTranslations",
+ method="create",
+ wrapper=_audio_translation_create_wrapper,
+ wrap_name="openai.wrap.audio.translations.create",
+)
+
+
+class AudioTranslationsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.translations`` for tracing."""
+
+ name = "openai.audio.translations"
+ sub_patchers = (
+ _translation_create_sync,
+ _translation_create_async,
+ )
+
+
+class _WrapAudioTranslations(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.translations"
+ sub_patchers = (_wrap_translation_create,)
+
+
 # ---------------------------------------------------------------------------
 # Responses
 # ---------------------------------------------------------------------------
@@ -269,6 +362,9 @@ class _WrapResponsesRaw(CompositeFunctionWrapperPatcher):
  ("chat.completions", _WrapChatCompletions),
  ("embeddings", _WrapEmbeddings),
  ("moderations", _WrapModerations),
+ ("audio.speech", _WrapAudioSpeech),
+ ("audio.transcriptions", _WrapAudioTranscriptions),
+ ("audio.translations", _WrapAudioTranslations),
  ("responses", _WrapResponses),
  ("responses.with_raw_response", _WrapResponsesRaw),
  ("beta.chat.completions", _WrapChatCompletions),

py/src/braintrust/integrations/openai/test_openai.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import time
 
 import openai
@@ -1714,6 +1715,195 @@ def _is_wrapped(client):
  return isinstance(attr, FunctionWrapper)
 
 
+TEST_AUDIO_FILE = os.path.join(os.path.dirname(__file__), "..", "..", "fixtures", "test_audio.wav")
+
+
+@pytest.mark.vcr
+def test_openai_audio_speech(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ response = client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ response2 = client2.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription_text_format(memory_logger):
+ """When response_format='text', the API returns a plain string (not JSON)."""
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span with the plain-text output
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_translation(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.translations.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_speech_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ response = await client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_transcription_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_translation_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
 class TestOpenAIIntegrationSetupSpans:
  """VCR-based tests verifying that OpenAIIntegration.setup() produces spans."""
 

py/src/braintrust/integrations/openai/integration.py

@@ -3,6 +3,9 @@
 from braintrust.integrations.base import BaseIntegration
 
 from .patchers import (
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
@@ -19,5 +22,8 @@ class OpenAIIntegration(BaseIntegration):
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ResponsesPatcher,
  )

py/src/braintrust/integrations/openai/patchers.py

@@ -7,6 +7,9 @@
 from wrapt import BoundFunctionWrapper, FunctionWrapper
 
 from .tracing import (
+ _audio_speech_create_wrapper,
+ _audio_transcription_create_wrapper,
+ _audio_translation_create_wrapper,
  _chat_completion_create_wrapper,
  _chat_completion_parse_wrapper,
  _embedding_create_wrapper,
@@ -182,6 +185,96 @@ class _WrapModerations(CompositeFunctionWrapperPatcher):
  sub_patchers = (_wrap_mod_create,)
 
 
+# ---------------------------------------------------------------------------
+# Audio — Speech
+# ---------------------------------------------------------------------------
+
+_speech_create_sync, _speech_create_async, _wrap_speech_create = _make_method_patchers(
+ name_prefix="openai.audio.speech.create",
+ target_module="openai.resources.audio.speech",
+ sync_class="Speech",
+ async_class="AsyncSpeech",
+ method="create",
+ wrapper=_audio_speech_create_wrapper,
+ wrap_name="openai.wrap.audio.speech.create",
+)
+
+
+class AudioSpeechPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.speech`` for tracing."""
+
+ name = "openai.audio.speech"
+ sub_patchers = (
+ _speech_create_sync,
+ _speech_create_async,
+ )
+
+
+class _WrapAudioSpeech(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.speech"
+ sub_patchers = (_wrap_speech_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Transcriptions
+# ---------------------------------------------------------------------------
+
+_transcription_create_sync, _transcription_create_async, _wrap_transcription_create = _make_method_patchers(
+ name_prefix="openai.audio.transcriptions.create",
+ target_module="openai.resources.audio.transcriptions",
+ sync_class="Transcriptions",
+ async_class="AsyncTranscriptions",
+ method="create",
+ wrapper=_audio_transcription_create_wrapper,
+ wrap_name="openai.wrap.audio.transcriptions.create",
+)
+
+
+class AudioTranscriptionsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.transcriptions`` for tracing."""
+
+ name = "openai.audio.transcriptions"
+ sub_patchers = (
+ _transcription_create_sync,
+ _transcription_create_async,
+ )
+
+
+class _WrapAudioTranscriptions(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.transcriptions"
+ sub_patchers = (_wrap_transcription_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Translations
+# ---------------------------------------------------------------------------
+
+_translation_create_sync, _translation_create_async, _wrap_translation_create = _make_method_patchers(
+ name_prefix="openai.audio.translations.create",
+ target_module="openai.resources.audio.translations",
+ sync_class="Translations",
+ async_class="AsyncTranslations",
+ method="create",
+ wrapper=_audio_translation_create_wrapper,
+ wrap_name="openai.wrap.audio.translations.create",
+)
+
+
+class AudioTranslationsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.translations`` for tracing."""
+
+ name = "openai.audio.translations"
+ sub_patchers = (
+ _translation_create_sync,
+ _translation_create_async,
+ )
+
+
+class _WrapAudioTranslations(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.translations"
+ sub_patchers = (_wrap_translation_create,)
+
+
 # ---------------------------------------------------------------------------
 # Responses
 # ---------------------------------------------------------------------------
@@ -269,6 +362,9 @@ class _WrapResponsesRaw(CompositeFunctionWrapperPatcher):
  ("chat.completions", _WrapChatCompletions),
  ("embeddings", _WrapEmbeddings),
  ("moderations", _WrapModerations),
+ ("audio.speech", _WrapAudioSpeech),
+ ("audio.transcriptions", _WrapAudioTranscriptions),
+ ("audio.translations", _WrapAudioTranslations),
  ("responses", _WrapResponses),
  ("responses.with_raw_response", _WrapResponsesRaw),
  ("beta.chat.completions", _WrapChatCompletions),

py/src/braintrust/integrations/openai/test_openai.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import time
 
 import openai
@@ -1714,6 +1715,195 @@ def _is_wrapped(client):
  return isinstance(attr, FunctionWrapper)
 
 
+TEST_AUDIO_FILE = os.path.join(os.path.dirname(__file__), "..", "..", "fixtures", "test_audio.wav")
+
+
+@pytest.mark.vcr
+def test_openai_audio_speech(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ response = client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ response2 = client2.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription_text_format(memory_logger):
+ """When response_format='text', the API returns a plain string (not JSON)."""
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span with the plain-text output
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_translation(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.translations.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_speech_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ response = await client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_transcription_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_translation_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
 class TestOpenAIIntegrationSetupSpans:
  """VCR-based tests verifying that OpenAIIntegration.setup() produces spans."""
 

py/src/braintrust/integrations/openai/integration.py

@@ -3,6 +3,9 @@
 from braintrust.integrations.base import BaseIntegration
 
 from .patchers import (
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
@@ -19,5 +22,8 @@ class OpenAIIntegration(BaseIntegration):
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ResponsesPatcher,
  )

py/src/braintrust/integrations/openai/patchers.py

@@ -7,6 +7,9 @@
 from wrapt import BoundFunctionWrapper, FunctionWrapper
 
 from .tracing import (
+ _audio_speech_create_wrapper,
+ _audio_transcription_create_wrapper,
+ _audio_translation_create_wrapper,
  _chat_completion_create_wrapper,
  _chat_completion_parse_wrapper,
  _embedding_create_wrapper,
@@ -182,6 +185,96 @@ class _WrapModerations(CompositeFunctionWrapperPatcher):
  sub_patchers = (_wrap_mod_create,)
 
 
+# ---------------------------------------------------------------------------
+# Audio — Speech
+# ---------------------------------------------------------------------------
+
+_speech_create_sync, _speech_create_async, _wrap_speech_create = _make_method_patchers(
+ name_prefix="openai.audio.speech.create",
+ target_module="openai.resources.audio.speech",
+ sync_class="Speech",
+ async_class="AsyncSpeech",
+ method="create",
+ wrapper=_audio_speech_create_wrapper,
+ wrap_name="openai.wrap.audio.speech.create",
+)
+
+
+class AudioSpeechPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.speech`` for tracing."""
+
+ name = "openai.audio.speech"
+ sub_patchers = (
+ _speech_create_sync,
+ _speech_create_async,
+ )
+
+
+class _WrapAudioSpeech(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.speech"
+ sub_patchers = (_wrap_speech_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Transcriptions
+# ---------------------------------------------------------------------------
+
+_transcription_create_sync, _transcription_create_async, _wrap_transcription_create = _make_method_patchers(
+ name_prefix="openai.audio.transcriptions.create",
+ target_module="openai.resources.audio.transcriptions",
+ sync_class="Transcriptions",
+ async_class="AsyncTranscriptions",
+ method="create",
+ wrapper=_audio_transcription_create_wrapper,
+ wrap_name="openai.wrap.audio.transcriptions.create",
+)
+
+
+class AudioTranscriptionsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.transcriptions`` for tracing."""
+
+ name = "openai.audio.transcriptions"
+ sub_patchers = (
+ _transcription_create_sync,
+ _transcription_create_async,
+ )
+
+
+class _WrapAudioTranscriptions(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.transcriptions"
+ sub_patchers = (_wrap_transcription_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Translations
+# ---------------------------------------------------------------------------
+
+_translation_create_sync, _translation_create_async, _wrap_translation_create = _make_method_patchers(
+ name_prefix="openai.audio.translations.create",
+ target_module="openai.resources.audio.translations",
+ sync_class="Translations",
+ async_class="AsyncTranslations",
+ method="create",
+ wrapper=_audio_translation_create_wrapper,
+ wrap_name="openai.wrap.audio.translations.create",
+)
+
+
+class AudioTranslationsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.translations`` for tracing."""
+
+ name = "openai.audio.translations"
+ sub_patchers = (
+ _translation_create_sync,
+ _translation_create_async,
+ )
+
+
+class _WrapAudioTranslations(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.translations"
+ sub_patchers = (_wrap_translation_create,)
+
+
 # ---------------------------------------------------------------------------
 # Responses
 # ---------------------------------------------------------------------------
@@ -269,6 +362,9 @@ class _WrapResponsesRaw(CompositeFunctionWrapperPatcher):
  ("chat.completions", _WrapChatCompletions),
  ("embeddings", _WrapEmbeddings),
  ("moderations", _WrapModerations),
+ ("audio.speech", _WrapAudioSpeech),
+ ("audio.transcriptions", _WrapAudioTranscriptions),
+ ("audio.translations", _WrapAudioTranslations),
  ("responses", _WrapResponses),
  ("responses.with_raw_response", _WrapResponsesRaw),
  ("beta.chat.completions", _WrapChatCompletions),

py/src/braintrust/integrations/openai/test_openai.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import time
 
 import openai
@@ -1714,6 +1715,195 @@ def _is_wrapped(client):
  return isinstance(attr, FunctionWrapper)
 
 
+TEST_AUDIO_FILE = os.path.join(os.path.dirname(__file__), "..", "..", "fixtures", "test_audio.wav")
+
+
+@pytest.mark.vcr
+def test_openai_audio_speech(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ response = client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ response2 = client2.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription_text_format(memory_logger):
+ """When response_format='text', the API returns a plain string (not JSON)."""
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span with the plain-text output
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_translation(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.translations.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_speech_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ response = await client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_transcription_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_translation_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
 class TestOpenAIIntegrationSetupSpans:
  """VCR-based tests verifying that OpenAIIntegration.setup() produces spans."""
 

py/src/braintrust/integrations/openai/integration.py

@@ -3,6 +3,9 @@
 from braintrust.integrations.base import BaseIntegration
 
 from .patchers import (
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
@@ -19,5 +22,8 @@ class OpenAIIntegration(BaseIntegration):
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ResponsesPatcher,
  )

py/src/braintrust/integrations/openai/patchers.py

@@ -7,6 +7,9 @@
 from wrapt import BoundFunctionWrapper, FunctionWrapper
 
 from .tracing import (
+ _audio_speech_create_wrapper,
+ _audio_transcription_create_wrapper,
+ _audio_translation_create_wrapper,
  _chat_completion_create_wrapper,
  _chat_completion_parse_wrapper,
  _embedding_create_wrapper,
@@ -182,6 +185,96 @@ class _WrapModerations(CompositeFunctionWrapperPatcher):
  sub_patchers = (_wrap_mod_create,)
 
 
+# ---------------------------------------------------------------------------
+# Audio — Speech
+# ---------------------------------------------------------------------------
+
+_speech_create_sync, _speech_create_async, _wrap_speech_create = _make_method_patchers(
+ name_prefix="openai.audio.speech.create",
+ target_module="openai.resources.audio.speech",
+ sync_class="Speech",
+ async_class="AsyncSpeech",
+ method="create",
+ wrapper=_audio_speech_create_wrapper,
+ wrap_name="openai.wrap.audio.speech.create",
+)
+
+
+class AudioSpeechPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.speech`` for tracing."""
+
+ name = "openai.audio.speech"
+ sub_patchers = (
+ _speech_create_sync,
+ _speech_create_async,
+ )
+
+
+class _WrapAudioSpeech(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.speech"
+ sub_patchers = (_wrap_speech_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Transcriptions
+# ---------------------------------------------------------------------------
+
+_transcription_create_sync, _transcription_create_async, _wrap_transcription_create = _make_method_patchers(
+ name_prefix="openai.audio.transcriptions.create",
+ target_module="openai.resources.audio.transcriptions",
+ sync_class="Transcriptions",
+ async_class="AsyncTranscriptions",
+ method="create",
+ wrapper=_audio_transcription_create_wrapper,
+ wrap_name="openai.wrap.audio.transcriptions.create",
+)
+
+
+class AudioTranscriptionsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.transcriptions`` for tracing."""
+
+ name = "openai.audio.transcriptions"
+ sub_patchers = (
+ _transcription_create_sync,
+ _transcription_create_async,
+ )
+
+
+class _WrapAudioTranscriptions(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.transcriptions"
+ sub_patchers = (_wrap_transcription_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Translations
+# ---------------------------------------------------------------------------
+
+_translation_create_sync, _translation_create_async, _wrap_translation_create = _make_method_patchers(
+ name_prefix="openai.audio.translations.create",
+ target_module="openai.resources.audio.translations",
+ sync_class="Translations",
+ async_class="AsyncTranslations",
+ method="create",
+ wrapper=_audio_translation_create_wrapper,
+ wrap_name="openai.wrap.audio.translations.create",
+)
+
+
+class AudioTranslationsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.translations`` for tracing."""
+
+ name = "openai.audio.translations"
+ sub_patchers = (
+ _translation_create_sync,
+ _translation_create_async,
+ )
+
+
+class _WrapAudioTranslations(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.translations"
+ sub_patchers = (_wrap_translation_create,)
+
+
 # ---------------------------------------------------------------------------
 # Responses
 # ---------------------------------------------------------------------------
@@ -269,6 +362,9 @@ class _WrapResponsesRaw(CompositeFunctionWrapperPatcher):
  ("chat.completions", _WrapChatCompletions),
  ("embeddings", _WrapEmbeddings),
  ("moderations", _WrapModerations),
+ ("audio.speech", _WrapAudioSpeech),
+ ("audio.transcriptions", _WrapAudioTranscriptions),
+ ("audio.translations", _WrapAudioTranslations),
  ("responses", _WrapResponses),
  ("responses.with_raw_response", _WrapResponsesRaw),
  ("beta.chat.completions", _WrapChatCompletions),

py/src/braintrust/integrations/openai/test_openai.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import time
 
 import openai
@@ -1714,6 +1715,195 @@ def _is_wrapped(client):
  return isinstance(attr, FunctionWrapper)
 
 
+TEST_AUDIO_FILE = os.path.join(os.path.dirname(__file__), "..", "..", "fixtures", "test_audio.wav")
+
+
+@pytest.mark.vcr
+def test_openai_audio_speech(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ response = client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ response2 = client2.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription_text_format(memory_logger):
+ """When response_format='text', the API returns a plain string (not JSON)."""
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span with the plain-text output
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_translation(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.translations.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_speech_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ response = await client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_transcription_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_translation_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
 class TestOpenAIIntegrationSetupSpans:
  """VCR-based tests verifying that OpenAIIntegration.setup() produces spans."""
 

py/src/braintrust/integrations/openai/integration.py

@@ -3,6 +3,9 @@
 from braintrust.integrations.base import BaseIntegration
 
 from .patchers import (
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
@@ -19,5 +22,8 @@ class OpenAIIntegration(BaseIntegration):
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ResponsesPatcher,
  )

py/src/braintrust/integrations/openai/patchers.py

@@ -7,6 +7,9 @@
 from wrapt import BoundFunctionWrapper, FunctionWrapper
 
 from .tracing import (
+ _audio_speech_create_wrapper,
+ _audio_transcription_create_wrapper,
+ _audio_translation_create_wrapper,
  _chat_completion_create_wrapper,
  _chat_completion_parse_wrapper,
  _embedding_create_wrapper,
@@ -182,6 +185,96 @@ class _WrapModerations(CompositeFunctionWrapperPatcher):
  sub_patchers = (_wrap_mod_create,)
 
 
+# ---------------------------------------------------------------------------
+# Audio — Speech
+# ---------------------------------------------------------------------------
+
+_speech_create_sync, _speech_create_async, _wrap_speech_create = _make_method_patchers(
+ name_prefix="openai.audio.speech.create",
+ target_module="openai.resources.audio.speech",
+ sync_class="Speech",
+ async_class="AsyncSpeech",
+ method="create",
+ wrapper=_audio_speech_create_wrapper,
+ wrap_name="openai.wrap.audio.speech.create",
+)
+
+
+class AudioSpeechPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.speech`` for tracing."""
+
+ name = "openai.audio.speech"
+ sub_patchers = (
+ _speech_create_sync,
+ _speech_create_async,
+ )
+
+
+class _WrapAudioSpeech(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.speech"
+ sub_patchers = (_wrap_speech_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Transcriptions
+# ---------------------------------------------------------------------------
+
+_transcription_create_sync, _transcription_create_async, _wrap_transcription_create = _make_method_patchers(
+ name_prefix="openai.audio.transcriptions.create",
+ target_module="openai.resources.audio.transcriptions",
+ sync_class="Transcriptions",
+ async_class="AsyncTranscriptions",
+ method="create",
+ wrapper=_audio_transcription_create_wrapper,
+ wrap_name="openai.wrap.audio.transcriptions.create",
+)
+
+
+class AudioTranscriptionsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.transcriptions`` for tracing."""
+
+ name = "openai.audio.transcriptions"
+ sub_patchers = (
+ _transcription_create_sync,
+ _transcription_create_async,
+ )
+
+
+class _WrapAudioTranscriptions(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.transcriptions"
+ sub_patchers = (_wrap_transcription_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Translations
+# ---------------------------------------------------------------------------
+
+_translation_create_sync, _translation_create_async, _wrap_translation_create = _make_method_patchers(
+ name_prefix="openai.audio.translations.create",
+ target_module="openai.resources.audio.translations",
+ sync_class="Translations",
+ async_class="AsyncTranslations",
+ method="create",
+ wrapper=_audio_translation_create_wrapper,
+ wrap_name="openai.wrap.audio.translations.create",
+)
+
+
+class AudioTranslationsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.translations`` for tracing."""
+
+ name = "openai.audio.translations"
+ sub_patchers = (
+ _translation_create_sync,
+ _translation_create_async,
+ )
+
+
+class _WrapAudioTranslations(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.translations"
+ sub_patchers = (_wrap_translation_create,)
+
+
 # ---------------------------------------------------------------------------
 # Responses
 # ---------------------------------------------------------------------------
@@ -269,6 +362,9 @@ class _WrapResponsesRaw(CompositeFunctionWrapperPatcher):
  ("chat.completions", _WrapChatCompletions),
  ("embeddings", _WrapEmbeddings),
  ("moderations", _WrapModerations),
+ ("audio.speech", _WrapAudioSpeech),
+ ("audio.transcriptions", _WrapAudioTranscriptions),
+ ("audio.translations", _WrapAudioTranslations),
  ("responses", _WrapResponses),
  ("responses.with_raw_response", _WrapResponsesRaw),
  ("beta.chat.completions", _WrapChatCompletions),

py/src/braintrust/integrations/openai/test_openai.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import time
 
 import openai
@@ -1714,6 +1715,195 @@ def _is_wrapped(client):
  return isinstance(attr, FunctionWrapper)
 
 
+TEST_AUDIO_FILE = os.path.join(os.path.dirname(__file__), "..", "..", "fixtures", "test_audio.wav")
+
+
+@pytest.mark.vcr
+def test_openai_audio_speech(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ response = client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ response2 = client2.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription_text_format(memory_logger):
+ """When response_format='text', the API returns a plain string (not JSON)."""
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span with the plain-text output
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_translation(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.translations.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_speech_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ response = await client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_transcription_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_translation_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
 class TestOpenAIIntegrationSetupSpans:
  """VCR-based tests verifying that OpenAIIntegration.setup() produces spans."""
 

py/src/braintrust/integrations/openai/integration.py

@@ -3,6 +3,9 @@
 from braintrust.integrations.base import BaseIntegration
 
 from .patchers import (
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
@@ -19,5 +22,8 @@ class OpenAIIntegration(BaseIntegration):
  ChatCompletionsPatcher,
  EmbeddingsPatcher,
  ModerationsPatcher,
+ AudioSpeechPatcher,
+ AudioTranscriptionsPatcher,
+ AudioTranslationsPatcher,
  ResponsesPatcher,
  )

py/src/braintrust/integrations/openai/patchers.py

@@ -7,6 +7,9 @@
 from wrapt import BoundFunctionWrapper, FunctionWrapper
 
 from .tracing import (
+ _audio_speech_create_wrapper,
+ _audio_transcription_create_wrapper,
+ _audio_translation_create_wrapper,
  _chat_completion_create_wrapper,
  _chat_completion_parse_wrapper,
  _embedding_create_wrapper,
@@ -182,6 +185,96 @@ class _WrapModerations(CompositeFunctionWrapperPatcher):
  sub_patchers = (_wrap_mod_create,)
 
 
+# ---------------------------------------------------------------------------
+# Audio — Speech
+# ---------------------------------------------------------------------------
+
+_speech_create_sync, _speech_create_async, _wrap_speech_create = _make_method_patchers(
+ name_prefix="openai.audio.speech.create",
+ target_module="openai.resources.audio.speech",
+ sync_class="Speech",
+ async_class="AsyncSpeech",
+ method="create",
+ wrapper=_audio_speech_create_wrapper,
+ wrap_name="openai.wrap.audio.speech.create",
+)
+
+
+class AudioSpeechPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.speech`` for tracing."""
+
+ name = "openai.audio.speech"
+ sub_patchers = (
+ _speech_create_sync,
+ _speech_create_async,
+ )
+
+
+class _WrapAudioSpeech(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.speech"
+ sub_patchers = (_wrap_speech_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Transcriptions
+# ---------------------------------------------------------------------------
+
+_transcription_create_sync, _transcription_create_async, _wrap_transcription_create = _make_method_patchers(
+ name_prefix="openai.audio.transcriptions.create",
+ target_module="openai.resources.audio.transcriptions",
+ sync_class="Transcriptions",
+ async_class="AsyncTranscriptions",
+ method="create",
+ wrapper=_audio_transcription_create_wrapper,
+ wrap_name="openai.wrap.audio.transcriptions.create",
+)
+
+
+class AudioTranscriptionsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.transcriptions`` for tracing."""
+
+ name = "openai.audio.transcriptions"
+ sub_patchers = (
+ _transcription_create_sync,
+ _transcription_create_async,
+ )
+
+
+class _WrapAudioTranscriptions(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.transcriptions"
+ sub_patchers = (_wrap_transcription_create,)
+
+
+# ---------------------------------------------------------------------------
+# Audio — Translations
+# ---------------------------------------------------------------------------
+
+_translation_create_sync, _translation_create_async, _wrap_translation_create = _make_method_patchers(
+ name_prefix="openai.audio.translations.create",
+ target_module="openai.resources.audio.translations",
+ sync_class="Translations",
+ async_class="AsyncTranslations",
+ method="create",
+ wrapper=_audio_translation_create_wrapper,
+ wrap_name="openai.wrap.audio.translations.create",
+)
+
+
+class AudioTranslationsPatcher(CompositeFunctionWrapperPatcher):
+ """Patch ``openai.resources.audio.translations`` for tracing."""
+
+ name = "openai.audio.translations"
+ sub_patchers = (
+ _translation_create_sync,
+ _translation_create_async,
+ )
+
+
+class _WrapAudioTranslations(CompositeFunctionWrapperPatcher):
+ name = "openai.wrap.audio.translations"
+ sub_patchers = (_wrap_translation_create,)
+
+
 # ---------------------------------------------------------------------------
 # Responses
 # ---------------------------------------------------------------------------
@@ -269,6 +362,9 @@ class _WrapResponsesRaw(CompositeFunctionWrapperPatcher):
  ("chat.completions", _WrapChatCompletions),
  ("embeddings", _WrapEmbeddings),
  ("moderations", _WrapModerations),
+ ("audio.speech", _WrapAudioSpeech),
+ ("audio.transcriptions", _WrapAudioTranscriptions),
+ ("audio.translations", _WrapAudioTranslations),
  ("responses", _WrapResponses),
  ("responses.with_raw_response", _WrapResponsesRaw),
  ("beta.chat.completions", _WrapChatCompletions),

py/src/braintrust/integrations/openai/test_openai.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import time
 
 import openai
@@ -1714,6 +1715,195 @@ def _is_wrapped(client):
  return isinstance(attr, FunctionWrapper)
 
 
+TEST_AUDIO_FILE = os.path.join(os.path.dirname(__file__), "..", "..", "fixtures", "test_audio.wav")
+
+
+@pytest.mark.vcr
+def test_openai_audio_speech(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ response = client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ response2 = client2.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_transcription_text_format(memory_logger):
+ """When response_format='text', the API returns a plain string (not JSON)."""
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span with the plain-text output
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.transcriptions.create(model="whisper-1", file=f, response_format="text")
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.vcr
+def test_openai_audio_translation(memory_logger):
+ assert not memory_logger.pop()
+
+ # Unwrapped client should produce no spans
+ client = openai.OpenAI()
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+ assert not memory_logger.pop()
+
+ # Wrapped client should produce a span
+ client2 = wrap_openai(openai.OpenAI())
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response2 = client2.audio.translations.create(model="whisper-1", file=f)
+ assert response2
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_speech_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ response = await client.audio.speech.create(
+ model="tts-1",
+ voice="alloy",
+ input="Hello, this is a test.",
+ )
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "tts-1"
+ assert span["metadata"]["voice"] == "alloy"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["input"] == "Hello, this is a test."
+ assert span["output"] == {"type": "audio"}
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_transcription_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.transcriptions.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
+@pytest.mark.asyncio
+@pytest.mark.vcr
+async def test_openai_audio_translation_async(memory_logger):
+ assert not memory_logger.pop()
+
+ clients = [(AsyncOpenAI(), False), (wrap_openai(AsyncOpenAI()), True)]
+
+ for client, is_wrapped in clients:
+ with open(TEST_AUDIO_FILE, "rb") as f:
+ response = await client.audio.translations.create(model="whisper-1", file=f)
+ assert response
+
+ if not is_wrapped:
+ assert not memory_logger.pop()
+ continue
+
+ spans = memory_logger.pop()
+ assert len(spans) == 1
+ span = spans[0]
+ assert span["metadata"]["model"] == "whisper-1"
+ assert span["metadata"]["provider"] == "openai"
+ assert span["output"] == "you"
+
+
 class TestOpenAIIntegrationSetupSpans:
  """VCR-based tests verifying that OpenAIIntegration.setup() produces spans."""