Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.
TypeScript agent-harnessagent-harness-engineeringai-engineeringai-observabilityamd-gpuclaude-codeclickhousecodexcoding-agentcoding-agentscursorgenaigpu-monitoringllm-observabilityllmopsnvidia-smiobservabilityopen-sourceopenaiopentelemetry
feat(python-sdk): add Groq audio instrumentation (#1326)
Aditya Jethanib7dee1ca06d1
diff --git a/assets/pricing.json b/assets/pricing.jsonindex 6aeabdcb..692cecf3 100644--- a/assets/pricing.json+++ b/assets/pricing.json@@ -122,7 +122,11 @@"eleven_english_sts_v2": 0.24,"eleven_multilingual_sts_v2": 0.24,"best": 0.00010277777,- "nano": 0.00003333333+ "nano": 0.00003333333,+ "whisper-large-v3": 0.00003083333,+ "whisper-large-v3-turbo": 0.00001111111,+ "canopylabs/orpheus-v1-english": 0.022,+ "canopylabs/orpheus-arabic-saudi": 0.040},"chat": {"gpt-4.1-nano-2025-04-14": {diff --git a/sdk/python/src/openlit/instrumentation/groq/__init__.py b/sdk/python/src/openlit/instrumentation/groq/__init__.pyindex d3db33f3..06b7831c 100644--- a/sdk/python/src/openlit/instrumentation/groq/__init__.py+++ b/sdk/python/src/openlit/instrumentation/groq/__init__.py@@ -1,5 +1,6 @@"""Initializer of Auto Instrumentation of Groq Functions"""+import loggingfrom typing import Collectionimport importlib.metadatafrom opentelemetry import _logs, trace@@ -7,12 +8,34 @@ from opentelemetry.instrumentation.instrumentor import BaseInstrumentorfrom wrapt import wrap_function_wrapperfrom openlit._config import OpenlitConfig-from openlit.instrumentation.groq.groq import chat-from openlit.instrumentation.groq.async_groq import async_chat+from openlit.instrumentation.groq.groq import (+ chat,+ audio_create,+ audio_transcription,+ audio_translation,+)+from openlit.instrumentation.groq.async_groq import (+ async_chat,+ async_audio_create,+ async_audio_transcription,+ async_audio_translation,+)++logger = logging.getLogger(__name__)_instruments = ("groq >= 0.5.0",)+def _safe_wrap(module, class_method, wrapper):+ """Wrap a function, silently skipping if the target isn't present in this SDK version."""+ try:+ wrap_function_wrapper(module, class_method, wrapper)+ except (ModuleNotFoundError, AttributeError):+ logger.debug(+ "Skipping %s.%s — not available in this groq version", module, class_method+ )++class GroqInstrumentor(BaseInstrumentor):"""An instrumentor for Groq client library.@@ -66,5 +89,107 @@ class GroqInstrumentor(BaseInstrumentor):),)+ # Audio speech (text-to-speech)+ _safe_wrap(+ "groq.resources.audio.speech",+ "Speech.create",+ audio_create(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ ),+ )++ # Audio speech (text-to-speech)+ _safe_wrap(+ "groq.resources.audio.speech",+ "AsyncSpeech.create",+ async_audio_create(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ ),+ )++ # Audio transcriptions (speech-to-text)+ _safe_wrap(+ "groq.resources.audio.transcriptions",+ "Transcriptions.create",+ audio_transcription(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ ),+ )++ # Audio transcriptions (speech-to-text)+ _safe_wrap(+ "groq.resources.audio.transcriptions",+ "AsyncTranscriptions.create",+ async_audio_transcription(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ ),+ )++ # Audio translations (speech-to-text)+ _safe_wrap(+ "groq.resources.audio.translations",+ "Translations.create",+ audio_translation(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ ),+ )++ # Audio translations (speech-to-text)+ _safe_wrap(+ "groq.resources.audio.translations",+ "AsyncTranslations.create",+ async_audio_translation(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ ),+ )+def _uninstrument(self, **kwargs):passdiff --git a/sdk/python/src/openlit/instrumentation/groq/async_groq.py b/sdk/python/src/openlit/instrumentation/groq/async_groq.pyindex 18e742fc..c741a9b1 100644--- a/sdk/python/src/openlit/instrumentation/groq/async_groq.py+++ b/sdk/python/src/openlit/instrumentation/groq/async_groq.py@@ -14,6 +14,8 @@ from openlit.instrumentation.groq.utils import (process_chunk,process_streaming_chat_response,process_chat_response,+ process_audio_response,+ process_transcription_response,)from openlit.semcov import SemanticConvention@@ -191,3 +193,199 @@ def async_chat(return responsereturn wrapper+++def async_audio_create(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """+ Generates a telemetry wrapper for GenAI audio creation function call+ """++ async def wrapper(wrapped, instance, args, kwargs):+ """+ Wraps the GenAI audio creation function call.+ """++ server_address, server_port = set_server_address_and_port(+ instance, "api.groq.com", 443+ )+ request_model = kwargs.get("model", "canopylabs/orpheus-v1-english")++ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO} {request_model}"++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ start_time = time.time()+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as e:+ handle_exception(span, e)+ raise+ end_time = time.time()++ try:+ response = process_audio_response(+ response=response,+ request_model=request_model,+ pricing_info=pricing_info,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ end_time=end_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ **kwargs,+ )++ except Exception as e:+ handle_exception(span, e)++ return response++ return wrapper+++def async_audio_transcription(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """+ Generates a telemetry wrapper for GenAI audio transcription function call+ """++ async def wrapper(wrapped, instance, args, kwargs):+ """+ Wraps the GenAI audio transcription function call.+ """++ server_address, server_port = set_server_address_and_port(+ instance, "api.groq.com", 443+ )+ request_model = kwargs.get("model", "whisper-large-v3")++ span_name = (+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_SPEECH_TO_TEXT} {request_model}"+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ start_time = time.time()+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as e:+ handle_exception(span, e)+ raise+ end_time = time.time()++ try:+ response = process_transcription_response(+ response=response,+ request_model=request_model,+ pricing_info=pricing_info,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ end_time=end_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ **kwargs,+ )++ except Exception as e:+ handle_exception(span, e)++ return response++ return wrapper+++def async_audio_translation(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """+ Generates a telemetry wrapper for GenAI audio translation function call+ """++ async def wrapper(wrapped, instance, args, kwargs):+ """+ Wraps the GenAI audio translation function call.+ """++ server_address, server_port = set_server_address_and_port(+ instance, "api.groq.com", 443+ )+ request_model = kwargs.get("model", "whisper-large-v3")++ span_name = (+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_SPEECH_TO_TEXT} {request_model}"+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ start_time = time.time()+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as e:+ handle_exception(span, e)+ raise+ end_time = time.time()++ try:+ response = process_transcription_response(+ response=response,+ request_model=request_model,+ pricing_info=pricing_info,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ end_time=end_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ **kwargs,+ )++ except Exception as e:+ handle_exception(span, e)++ return response++ return wrapperdiff --git a/sdk/python/src/openlit/instrumentation/groq/groq.py b/sdk/python/src/openlit/instrumentation/groq/groq.pyindex 7d53c075..380e2e24 100644--- a/sdk/python/src/openlit/instrumentation/groq/groq.py+++ b/sdk/python/src/openlit/instrumentation/groq/groq.py@@ -14,6 +14,8 @@ from openlit.instrumentation.groq.utils import (process_chunk,process_streaming_chat_response,process_chat_response,+ process_audio_response,+ process_transcription_response,)from openlit.semcov import SemanticConvention@@ -191,3 +193,199 @@ def chat(return responsereturn wrapper+++def audio_create(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """+ Generates a telemetry wrapper for GenAI audio creation function call+ """++ def wrapper(wrapped, instance, args, kwargs):+ """+ Wraps the GenAI audio creation function call.+ """++ server_address, server_port = set_server_address_and_port(+ instance, "api.groq.com", 443+ )+ request_model = kwargs.get("model", "canopylabs/orpheus-v1-english")++ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO} {request_model}"++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ start_time = time.time()+ try:+ response = wrapped(*args, **kwargs)+ except Exception as e:+ handle_exception(span, e)+ raise+ end_time = time.time()++ try:+ response = process_audio_response(+ response=response,+ request_model=request_model,+ pricing_info=pricing_info,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ end_time=end_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ **kwargs,+ )++ except Exception as e:+ handle_exception(span, e)++ return response++ return wrapper+++def audio_transcription(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """+ Generates a telemetry wrapper for GenAI audio transcription function call+ """++ def wrapper(wrapped, instance, args, kwargs):+ """+ Wraps the GenAI audio transcription function call.+ """++ server_address, server_port = set_server_address_and_port(+ instance, "api.groq.com", 443+ )+ request_model = kwargs.get("model", "whisper-large-v3")++ span_name = (+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_SPEECH_TO_TEXT} {request_model}"+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ start_time = time.time()+ try:+ response = wrapped(*args, **kwargs)+ except Exception as e:+ handle_exception(span, e)+ raise+ end_time = time.time()++ try:+ response = process_transcription_response(+ response=response,+ request_model=request_model,+ pricing_info=pricing_info,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ end_time=end_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ **kwargs,+ )++ except Exception as e:+ handle_exception(span, e)++ return response++ return wrapper+++def audio_translation(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """+ Generates a telemetry wrapper for GenAI audio translation function call+ """++ def wrapper(wrapped, instance, args, kwargs):+ """+ Wraps the GenAI audio translation function call.+ """++ server_address, server_port = set_server_address_and_port(+ instance, "api.groq.com", 443+ )+ request_model = kwargs.get("model", "whisper-large-v3")++ span_name = (+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_SPEECH_TO_TEXT} {request_model}"+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ start_time = time.time()+ try:+ response = wrapped(*args, **kwargs)+ except Exception as e:+ handle_exception(span, e)+ raise+ end_time = time.time()++ try:+ response = process_transcription_response(+ response=response,+ request_model=request_model,+ pricing_info=pricing_info,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ end_time=end_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ **kwargs,+ )++ except Exception as e:+ handle_exception(span, e)++ return response++ return wrapperdiff --git a/sdk/python/src/openlit/instrumentation/groq/utils.py b/sdk/python/src/openlit/instrumentation/groq/utils.pyindex 93c90060..e8047500 100644--- a/sdk/python/src/openlit/instrumentation/groq/utils.py+++ b/sdk/python/src/openlit/instrumentation/groq/utils.py@@ -18,8 +18,10 @@ from openlit.__helpers import (response_as_dict,calculate_tbt,general_tokens,+ get_audio_model_cost,get_chat_model_cost,common_span_attributes,+ record_audio_metrics,record_completion_metrics,otel_event,set_span_reasoning_content,@@ -674,3 +676,363 @@ def process_chat_response()return response+++def handle_not_given(value, default=None):+ """+ Handle Groq's NotGiven/Omit sentinel values and None by converting them to defaults.+ """+ if hasattr(value, "__class__") and value.__class__.__name__ in ("NotGiven", "Omit"):+ return default+ if value is None:+ return default+ return value+++def common_audio_logic(+ scope,+ request_model,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """+ Common logic for processing audio operations.+ """++ # Calculate cost+ input_text = scope._kwargs.get("input", "")+ cost = get_audio_model_cost(request_model, pricing_info, input_text)++ # Common Span Attributes+ common_span_attributes(+ scope,+ SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO,+ SemanticConvention.GEN_AI_SYSTEM_GROQ,+ scope._server_address,+ scope._server_port,+ request_model,+ request_model,+ environment,+ application_name,+ False,+ scope._tbt,+ scope._ttft,+ version,+ )++ # Span Attributes for Request parameters+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_AUDIO_VOICE,+ handle_not_given(scope._kwargs.get("voice"), "troy"),+ )+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_AUDIO_RESPONSE_FORMAT,+ handle_not_given(scope._kwargs.get("response_format"), "wav"),+ )+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_AUDIO_SPEED,+ handle_not_given(scope._kwargs.get("speed"), 1.0),+ )++ # Span Attributes for Cost+ scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)++ # Span Attributes for Content (OTel: array structure)+ if capture_message_content:+ input_text = scope._kwargs.get("input", "")+ input_msgs = (+ [{"role": "user", "parts": [{"type": "text", "content": input_text}]}]+ if input_text+ else []+ )+ output_msgs = [+ {+ "role": "assistant",+ "parts": [{"type": "text", "content": "[audio generated]"}],+ "finish_reason": "stop",+ }+ ]+ _set_span_messages_as_array(scope._span, input_msgs, output_msgs)++ if event_provider:+ try:+ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO,+ request_model=request_model,+ response_model=request_model,+ input_messages=input_msgs,+ output_messages=output_msgs,+ tool_definitions=None,+ server_address=scope._server_address,+ server_port=scope._server_port,+ )+ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)++ scope._span.set_status(Status(StatusCode.OK))++ # Record metrics+ if not disable_metrics:+ record_audio_metrics(+ metrics,+ SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO,+ SemanticConvention.GEN_AI_SYSTEM_GROQ,+ scope._server_address,+ scope._server_port,+ request_model,+ request_model,+ environment,+ application_name,+ scope._start_time,+ scope._end_time,+ cost,+ )+++def process_audio_response(+ response,+ request_model,+ pricing_info,+ server_port,+ server_address,+ environment,+ application_name,+ metrics,+ start_time,+ end_time,+ span,+ capture_message_content=False,+ disable_metrics=False,+ version="1.0.0",+ event_provider=None,+ **kwargs,+):+ """+ Process audio generation response and generate telemetry.+ """++ scope = type("GenericScope", (), {})()++ scope._start_time = start_time+ scope._end_time = end_time+ scope._span = span+ scope._timestamps = []+ scope._ttft, scope._tbt = scope._end_time - scope._start_time, 0+ scope._server_address, scope._server_port = server_address, server_port+ scope._kwargs = kwargs++ common_audio_logic(+ scope,+ request_model,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=event_provider,+ )++ return response+++def common_transcription_logic(+ scope,+ request_model,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Common logic for processing audio transcription/translation operations."""++ cost = get_audio_model_cost(+ request_model, pricing_info, None, duration=getattr(scope, "_duration", 0)+ )++ common_span_attributes(+ scope,+ SemanticConvention.GEN_AI_OPERATION_TYPE_SPEECH_TO_TEXT,+ SemanticConvention.GEN_AI_SYSTEM_GROQ,+ scope._server_address,+ scope._server_port,+ request_model,+ request_model,+ environment,+ application_name,+ False,+ scope._tbt,+ scope._ttft,+ version,+ )++ language = scope._kwargs.get("language")+ if language:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_AUDIO_LANGUAGE, language+ )+ response_format = scope._kwargs.get("response_format")+ if response_format:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_AUDIO_RESPONSE_FORMAT,+ str(response_format),+ )+ temperature = handle_not_given(scope._kwargs.get("temperature"))+ if temperature is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, temperature+ )++ if hasattr(scope, "_duration") and scope._duration:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_RESPONSE_AUDIO_DURATION, scope._duration+ )++ if hasattr(scope, "_input_tokens") and scope._input_tokens:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, scope._input_tokens+ )+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, scope._output_tokens+ )+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE,+ scope._input_tokens + scope._output_tokens,+ )++ scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)++ if capture_message_content:+ file_obj = scope._kwargs.get("file")+ if isinstance(file_obj, (tuple, list)) and file_obj:+ # Groq accepts (filename, fileobj[, content_type]) tuples for uploads.+ file_name = file_obj[0]+ elif file_obj is not None:+ file_name = getattr(file_obj, "name", "unknown")+ else:+ file_name = "unknown"+ input_msgs = [+ {+ "role": "user",+ "parts": [{"type": "text", "content": f"[audio file: {file_name}]"}],+ }+ ]+ output_msgs = None+ if hasattr(scope, "_transcription_text") and scope._transcription_text:+ output_msgs = [+ {+ "role": "assistant",+ "parts": [{"type": "text", "content": scope._transcription_text}],+ "finish_reason": "stop",+ }+ ]+ _set_span_messages_as_array(scope._span, input_msgs, output_msgs)++ if event_provider:+ try:+ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_SPEECH_TO_TEXT,+ request_model=request_model,+ response_model=request_model,+ input_messages=input_msgs,+ output_messages=output_msgs,+ server_address=scope._server_address,+ server_port=scope._server_port,+ )+ except Exception as e:+ logger.warning("Failed to emit inference event: %s", e, exc_info=True)++ scope._span.set_status(Status(StatusCode.OK))++ if not disable_metrics:+ record_audio_metrics(+ metrics,+ SemanticConvention.GEN_AI_OPERATION_TYPE_SPEECH_TO_TEXT,+ SemanticConvention.GEN_AI_SYSTEM_GROQ,+ scope._server_address,+ scope._server_port,+ request_model,+ request_model,+ environment,+ application_name,+ scope._start_time,+ scope._end_time,+ cost,+ )+++def process_transcription_response(+ response,+ request_model,+ pricing_info,+ server_port,+ server_address,+ environment,+ application_name,+ metrics,+ start_time,+ end_time,+ span,+ capture_message_content=False,+ disable_metrics=False,+ version="1.0.0",+ event_provider=None,+ **kwargs,+):+ """Process audio transcription/translation response and generate telemetry."""++ scope = type("GenericScope", (), {})()+ response_dict = response_as_dict(response)++ scope._start_time = start_time+ scope._end_time = end_time+ scope._span = span+ scope._timestamps = []+ scope._ttft, scope._tbt = end_time - start_time, 0+ scope._server_address, scope._server_port = server_address, server_port+ scope._kwargs = kwargs++ usage = response_dict.get("usage", {})+ if isinstance(usage, dict):+ usage_type = usage.get("type", "duration")+ if usage_type == "tokens":+ scope._input_tokens = usage.get("input_tokens", 0)+ scope._output_tokens = usage.get("output_tokens", 0)+ else:+ scope._input_tokens = 0+ scope._output_tokens = 0+ else:+ scope._input_tokens = 0+ scope._output_tokens = 0++ scope._transcription_text = response_dict.get("text", "")+ scope._language = response_dict.get("language", "")+ scope._duration = response_dict.get("duration", 0)++ common_transcription_logic(+ scope,+ request_model,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=event_provider,+ )++ return responsediff --git a/sdk/python/tests/test_groq.py b/sdk/python/tests/test_groq.pyindex e5491dc9..89e49832 100644--- a/sdk/python/tests/test_groq.py+++ b/sdk/python/tests/test_groq.py@@ -86,3 +86,167 @@ async def test_async_groq_chat():print("Rate Limited:", e)else:raise+++def _sample_audio_file():+ """+ Generates a small in-memory WAV file for speech-to-text tests.+ """++ import io+ import struct+ import wave++ buffer = io.BytesIO()+ with wave.open(buffer, "wb") as wav_file:+ wav_file.setnchannels(1)+ wav_file.setsampwidth(2)+ wav_file.setframerate(16000)+ wav_file.writeframes(struct.pack("<h", 0) * 16000)+ buffer.seek(0)+ return ("sample.wav", buffer)+++def test_sync_groq_transcription():+ """+ Tests synchronous Audio Transcriptions.++ Raises:+ AssertionError: If the Audio Transcriptions response object is not as expected.+ """++ try:+ transcription_resp = sync_client.audio.transcriptions.create(+ file=_sample_audio_file(),+ model="whisper-large-v3",+ )+ assert isinstance(transcription_resp.text, str)++ # pylint: disable=broad-exception-caught+ except Exception as e:+ if "rate limit" in str(e).lower():+ print("Rate Limited:", e)+ else:+ raise+++def test_sync_groq_translation():+ """+ Tests synchronous Audio Translations.++ Raises:+ AssertionError: If the Audio Translations response object is not as expected.+ """++ try:+ translation_resp = sync_client.audio.translations.create(+ file=_sample_audio_file(),+ model="whisper-large-v3",+ )+ assert isinstance(translation_resp.text, str)++ # pylint: disable=broad-exception-caught+ except Exception as e:+ if "rate limit" in str(e).lower():+ print("Rate Limited:", e)+ else:+ raise+++def test_sync_groq_speech():+ """+ Tests synchronous Audio Speech (text-to-speech).++ Raises:+ AssertionError: If the Audio Speech response object is not as expected.+ """++ try:+ speech_resp = sync_client.audio.speech.create(+ model="canopylabs/orpheus-v1-english",+ voice="troy",+ input="Monitor LLM Applications",+ response_format="wav",+ )+ assert speech_resp.read()++ # pylint: disable=broad-exception-caught+ except Exception as e:+ if "rate limit" in str(e).lower() or "terms acceptance" in str(e).lower():+ print("Skipped:", e)+ else:+ raise+++async def test_async_groq_transcription():+ """+ Tests asynchronous Audio Transcriptions.++ Raises:+ AssertionError: If the Audio Transcriptions response object is not as expected.+ """++ try:+ transcription_resp = await async_client.audio.transcriptions.create(+ file=_sample_audio_file(),+ model="whisper-large-v3",+ )+ assert isinstance(transcription_resp.text, str)++ # pylint: disable=broad-exception-caught+ except Exception as e:+ if "rate limit" in str(e).lower():+ print("Rate Limited:", e)+ else:+ raise+++async def test_async_groq_translation():+ """+ Tests asynchronous Audio Translations.++ Raises:+ AssertionError: If the Audio Translations response object is not as expected.+ """++ try:+ translation_resp = await async_client.audio.translations.create(+ file=_sample_audio_file(),+ model="whisper-large-v3",+ )+ assert isinstance(translation_resp.text, str)++ # pylint: disable=broad-exception-caught+ except Exception as e:+ if "rate limit" in str(e).lower():+ print("Rate Limited:", e)+ else:+ raise+++async def test_async_groq_speech():+ """+ Tests asynchronous Audio Speech (text-to-speech).++ Raises:+ AssertionError: If the Audio Speech response object is not as expected.+ """++ try:+ speech_resp = await async_client.audio.speech.create(+ model="canopylabs/orpheus-v1-english",+ voice="troy",+ input="Monitor LLM Applications",+ response_format="wav",+ )+ assert await speech_resp.read()++ # pylint: disable=broad-exception-caught+ except Exception as e:+ if "rate limit" in str(e).lower() or "terms acceptance" in str(e).lower():+ print("Skipped:", e)+ else:+ raise