openlit 1.34.29__py3-none-any.whl → 1.34.31__py3-none-any.whl

openlit/instrumentation/openai/utils.py

@@ -1,6 +1,7 @@
 """
 OpenAI OpenTelemetry instrumentation utility functions
 """
+
 import time
 
 from opentelemetry.trace import Status, StatusCode
@@ -22,14 +23,18 @@ from openlit.__helpers import (
 )
 from openlit.semcov import SemanticConvention
 
+
 def handle_not_given(value, default=None):
     """
-    Handle OpenAI's NotGiven values by converting them to appropriate defaults.
+    Handle OpenAI's NotGiven values and None values by converting them to appropriate defaults.
     """
-    if hasattr(value, '__class__') and value.__class__.__name__ == 'NotGiven':
+    if hasattr(value, "__class__") and value.__class__.__name__ == "NotGiven":
+        return default
+    if value is None:
         return default
     return value
 
+
 def format_content(messages):
     """
     Format the messages into a string for span events.
@@ -60,18 +65,19 @@ def format_content(messages):
             for item in content:
                 # Chat completions format
                 if item.get("type") == "text":
-                    content_str_list.append(f'text: {item.get("text", "")}')
-                elif (item.get("type") == "image_url" and
-                      not item.get("image_url", {}).get("url", "").startswith("data:")):
-                    content_str_list.append(f'image_url: {item["image_url"]["url"]}')
+                    content_str_list.append(f"text: {item.get('text', '')}")
+                elif item.get("type") == "image_url" and not item.get(
+                    "image_url", {}
+                ).get("url", "").startswith("data:"):
+                    content_str_list.append(f"image_url: {item['image_url']['url']}")
 
                 # Responses API format
                 elif item.get("type") == "input_text":
-                    content_str_list.append(f'text: {item.get("text", "")}')
+                    content_str_list.append(f"text: {item.get('text', '')}")
                 elif item.get("type") == "input_image":
                     image_url = item.get("image_url", "")
                     if image_url and not image_url.startswith("data:"):
-                        content_str_list.append(f'image_url: {image_url}')
+                        content_str_list.append(f"image_url: {image_url}")
 
             content_str = ", ".join(content_str_list)
             formatted_messages.append(f"{role}: {content_str}")
@@ -80,6 +86,7 @@ def format_content(messages):
 
     return "\n".join(formatted_messages)
 
+
 def process_chat_chunk(scope, chunk):
     """
     Process a chunk of chat response data and update state.
@@ -94,9 +101,7 @@ def process_chat_chunk(scope, chunk):
     chunked = response_as_dict(chunk)
 
     # Extract content from chat completions
-    if (len(chunked.get("choices", [])) > 0 and
-        "delta" in chunked.get("choices")[0]):
-
+    if len(chunked.get("choices", [])) > 0 and "delta" in chunked.get("choices")[0]:
         delta = chunked.get("choices")[0]["delta"]
         content = delta.get("content")
         if content:
@@ -117,24 +122,36 @@ def process_chat_chunk(scope, chunk):
                     func = tool.get("function", {})
                     scope._tools[idx] = {
                         "id": tool["id"],
-                        "function": {"name": func.get("name", ""), "arguments": func.get("arguments", "")},
-                        "type": tool.get("type", "function")
+                        "function": {
+                            "name": func.get("name", ""),
+                            "arguments": func.get("arguments", ""),
+                        },
+                        "type": tool.get("type", "function"),
                     }
-                elif scope._tools[idx] and "function" in tool:  # Append args (id is None)
-                    scope._tools[idx]["function"]["arguments"] += tool["function"].get("arguments", "")
+                elif (
+                    scope._tools[idx] and "function" in tool
+                ):  # Append args (id is None)
+                    scope._tools[idx]["function"]["arguments"] += tool["function"].get(
+                        "arguments", ""
+                    )
 
     # Extract metadata
     scope._response_id = chunked.get("id") or scope._response_id
     scope._response_model = chunked.get("model") or scope._response_model
 
     try:
-        scope._finish_reason = chunked.get("choices", [])[0].get("finish_reason") or scope._finish_reason
+        scope._finish_reason = (
+            chunked.get("choices", [])[0].get("finish_reason") or scope._finish_reason
+        )
     except (IndexError, AttributeError, TypeError):
         scope._finish_reason = "stop"
 
-    scope._system_fingerprint = chunked.get("system_fingerprint") or scope._system_fingerprint
+    scope._system_fingerprint = (
+        chunked.get("system_fingerprint") or scope._system_fingerprint
+    )
     scope._service_tier = chunked.get("service_tier") or scope._service_tier
 
+
 def process_response_chunk(scope, chunk):
     """
     Process a chunk of response API data and update state.
@@ -160,14 +177,16 @@ def process_response_chunk(scope, chunk):
 
         item = chunked.get("item", {})
         if item.get("type") == "function_call":
-            scope._response_tools.append({
-                "id": item.get("id", ""),
-                "call_id": item.get("call_id", ""),
-                "name": item.get("name", ""),
-                "type": item.get("type", "function_call"),
-                "arguments": item.get("arguments", ""),
-                "status": item.get("status", "in_progress")
-            })
+            scope._response_tools.append(
+                {
+                    "id": item.get("id", ""),
+                    "call_id": item.get("call_id", ""),
+                    "name": item.get("name", ""),
+                    "type": item.get("type", "function_call"),
+                    "arguments": item.get("arguments", ""),
+                    "status": item.get("status", "in_progress"),
+                }
+            )
 
     elif chunked.get("type") == "response.function_call_arguments.delta":
         # Tool arguments being streamed
@@ -202,12 +221,16 @@ def process_response_chunk(scope, chunk):
             # Update the tool with final status and data
             for tool in scope._response_tools:
                 if tool.get("id") == item_id:
-                    tool.update({
-                        "call_id": item.get("call_id", tool.get("call_id", "")),
-                        "name": item.get("name", tool.get("name", "")),
-                        "arguments": item.get("arguments", tool.get("arguments", "")),
-                        "status": item.get("status", "completed")
-                    })
+                    tool.update(
+                        {
+                            "call_id": item.get("call_id", tool.get("call_id", "")),
+                            "name": item.get("name", tool.get("name", "")),
+                            "arguments": item.get(
+                                "arguments", tool.get("arguments", "")
+                            ),
+                            "status": item.get("status", "completed"),
+                        }
+                    )
                     break
 
     elif chunked.get("type") == "response.completed":
@@ -224,8 +247,18 @@ def process_response_chunk(scope, chunk):
         output_tokens_details = usage.get("output_tokens_details", {})
         scope._reasoning_tokens = output_tokens_details.get("reasoning_tokens", 0)
 
-def common_response_logic(scope, pricing_info, environment, application_name, metrics,
-    capture_message_content, disable_metrics, version, is_stream):
+
+def common_response_logic(
+    scope,
+    pricing_info,
+    environment,
+    application_name,
+    metrics,
+    capture_message_content,
+    disable_metrics,
+    version,
+    is_stream,
+):
     """
     Process responses API request and generate Telemetry
     """
@@ -250,66 +283,115 @@ def common_response_logic(scope, pricing_info, environment, application_name, me
     cost = get_chat_model_cost(request_model, pricing_info, input_tokens, output_tokens)
 
     # Common Span Attributes
-    common_span_attributes(scope,
-        SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT, SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-        scope._server_address, scope._server_port, request_model, scope._response_model,
-        environment, application_name, is_stream, scope._tbt, scope._ttft, version)
+    common_span_attributes(
+        scope,
+        SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+        SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+        scope._server_address,
+        scope._server_port,
+        request_model,
+        scope._response_model,
+        environment,
+        application_name,
+        is_stream,
+        scope._tbt,
+        scope._ttft,
+        version,
+    )
 
     # Span Attributes for Request parameters specific to responses API
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, handle_not_given(scope._kwargs.get("temperature"), 1.0))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_TEMPERATURE,
+        handle_not_given(scope._kwargs.get("temperature"), 1.0),
+    )
     scope._span.set_attribute(
         SemanticConvention.GEN_AI_REQUEST_TOP_P,
-        handle_not_given(scope._kwargs.get("top_p"), 1.0)
+        handle_not_given(scope._kwargs.get("top_p"), 1.0),
     )
     scope._span.set_attribute(
         SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS,
-        handle_not_given(scope._kwargs.get("max_output_tokens"), -1)
+        handle_not_given(scope._kwargs.get("max_output_tokens"), -1),
     )
 
     # Reasoning parameters
     reasoning = scope._kwargs.get("reasoning", {})
     if reasoning:
         if reasoning.get("effort"):
-            scope._span.set_attribute("gen_ai.request.reasoning_effort", reasoning.get("effort"))
+            scope._span.set_attribute(
+                "gen_ai.request.reasoning_effort", reasoning.get("effort")
+            )
 
     # Responses API specific attributes
     if hasattr(scope, "_service_tier"):
-        scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SERVICE_TIER, scope._service_tier)
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_REQUEST_SERVICE_TIER, scope._service_tier
+        )
 
     # Span Attributes for Response parameters
     scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, scope._response_id)
-    scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [scope._finish_reason])
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [scope._finish_reason]
+    )
     scope._span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, "text")
 
     # Span Attributes for Tools (responses API structure) - optimized
     if hasattr(scope, "_response_tools") and scope._response_tools:
-        tools = scope._response_tools if isinstance(scope._response_tools, list) else [scope._response_tools]
+        tools = (
+            scope._response_tools
+            if isinstance(scope._response_tools, list)
+            else [scope._response_tools]
+        )
 
-        names, ids, args = zip(*[
-            (t.get("name", ""),
-             str(t.get("call_id", "")),  # Use call_id for responses API
-             str(t.get("arguments", "")))
-            for t in tools if isinstance(t, dict) and t
-        ]) if tools else ([], [], [])
+        names, ids, args = (
+            zip(
+                *[
+                    (
+                        t.get("name", ""),
+                        str(t.get("call_id", "")),  # Use call_id for responses API
+                        str(t.get("arguments", "")),
+                    )
+                    for t in tools
+                    if isinstance(t, dict) and t
+                ]
+            )
+            if tools
+            else ([], [], [])
+        )
 
-        scope._span.set_attribute(SemanticConvention.GEN_AI_TOOL_NAME, ", ".join(filter(None, names)))
-        scope._span.set_attribute(SemanticConvention.GEN_AI_TOOL_CALL_ID, ", ".join(filter(None, ids)))
-        scope._span.set_attribute(SemanticConvention.GEN_AI_TOOL_ARGS, ", ".join(filter(None, args)))
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_TOOL_NAME, ", ".join(filter(None, names))
+        )
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_TOOL_CALL_ID, ", ".join(filter(None, ids))
+        )
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_TOOL_ARGS, ", ".join(filter(None, args))
+        )
 
     # Span Attributes for Cost and Tokens
-    scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
-    scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
-    scope._span.set_attribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, input_tokens + output_tokens)
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, input_tokens + output_tokens
+    )
     scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
 
     # Reasoning tokens
     if hasattr(scope, "_reasoning_tokens") and scope._reasoning_tokens > 0:
-        scope._span.set_attribute("gen_ai.usage.reasoning_tokens", scope._reasoning_tokens)
+        scope._span.set_attribute(
+            "gen_ai.usage.reasoning_tokens", scope._reasoning_tokens
+        )
 
     # Span Attributes for Content
     if capture_message_content:
         scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, prompt)
-        scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, scope._llmresponse)
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_CONTENT_COMPLETION, scope._llmresponse
+        )
 
         # To be removed once the change to span_attributes (from span events) is complete
         scope._span.add_event(
@@ -329,23 +411,69 @@ def common_response_logic(scope, pricing_info, environment, application_name, me
 
     # Record metrics
     if not disable_metrics:
-        record_completion_metrics(metrics, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT, SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-            scope._server_address, scope._server_port, request_model, scope._response_model, environment,
-            application_name, scope._start_time, scope._end_time, input_tokens, output_tokens,
-            cost, scope._tbt, scope._ttft)
+        record_completion_metrics(
+            metrics,
+            SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+            SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+            scope._server_address,
+            scope._server_port,
+            request_model,
+            scope._response_model,
+            environment,
+            application_name,
+            scope._start_time,
+            scope._end_time,
+            input_tokens,
+            output_tokens,
+            cost,
+            scope._tbt,
+            scope._ttft,
+        )
 
-def process_streaming_response_response(scope, pricing_info, environment, application_name, metrics,
-    capture_message_content=False, disable_metrics=False, version=""):
+
+def process_streaming_response_response(
+    scope,
+    pricing_info,
+    environment,
+    application_name,
+    metrics,
+    capture_message_content=False,
+    disable_metrics=False,
+    version="",
+):
     """
     Process streaming responses API response and generate telemetry.
     """
 
-    common_response_logic(scope, pricing_info, environment, application_name, metrics,
-                        capture_message_content, disable_metrics, version, is_stream=True)
+    common_response_logic(
+        scope,
+        pricing_info,
+        environment,
+        application_name,
+        metrics,
+        capture_message_content,
+        disable_metrics,
+        version,
+        is_stream=True,
+    )
+
 
-def process_response_response(response, request_model, pricing_info, server_port, server_address,
-    environment, application_name, metrics, start_time, span, capture_message_content=False,
-    disable_metrics=False, version="1.0.0", **kwargs):
+def process_response_response(
+    response,
+    request_model,
+    pricing_info,
+    server_port,
+    server_address,
+    environment,
+    application_name,
+    metrics,
+    start_time,
+    span,
+    capture_message_content=False,
+    disable_metrics=False,
+    version="1.0.0",
+    **kwargs,
+):
     """
     Process non-streaming responses API response and generate telemetry.
     """
@@ -371,14 +499,16 @@ def process_response_response(response, request_model, pricing_info, server_port
                 break
             if item.get("type") == "function_call":
                 # Handle tool call
-                scope._response_tools = [{
-                    "id": item.get("id", ""),
-                    "call_id": item.get("call_id", ""),
-                    "name": item.get("name", ""),
-                    "type": item.get("type", "function_call"),
-                    "arguments": item.get("arguments", ""),
-                    "status": item.get("status", "")
-                }]
+                scope._response_tools = [
+                    {
+                        "id": item.get("id", ""),
+                        "call_id": item.get("call_id", ""),
+                        "name": item.get("name", ""),
+                        "type": item.get("type", "function_call"),
+                        "arguments": item.get("arguments", ""),
+                        "status": item.get("status", ""),
+                    }
+                ]
 
         # Extract content from message item if found
         if message_item:
@@ -404,13 +534,32 @@ def process_response_response(response, request_model, pricing_info, server_port
     scope._service_tier = response_dict.get("service_tier", "default")
     scope._finish_reason = response_dict.get("status", "completed")
 
-    common_response_logic(scope, pricing_info, environment, application_name, metrics,
-                        capture_message_content, disable_metrics, version, is_stream=False)
+    common_response_logic(
+        scope,
+        pricing_info,
+        environment,
+        application_name,
+        metrics,
+        capture_message_content,
+        disable_metrics,
+        version,
+        is_stream=False,
+    )
 
     return response
 
-def common_chat_logic(scope, pricing_info, environment, application_name, metrics,
-    capture_message_content, disable_metrics, version, is_stream):
+
+def common_chat_logic(
+    scope,
+    pricing_info,
+    environment,
+    application_name,
+    metrics,
+    capture_message_content,
+    disable_metrics,
+    version,
+    is_stream,
+):
     """
     Process chat request and generate Telemetry
     """
@@ -445,63 +594,121 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
         scope,
         SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
         SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-        scope._server_address, scope._server_port, request_model,
-        scope._response_model, environment, application_name,
-        is_stream, scope._tbt, scope._ttft, version
+        scope._server_address,
+        scope._server_port,
+        request_model,
+        scope._response_model,
+        environment,
+        application_name,
+        is_stream,
+        scope._tbt,
+        scope._ttft,
+        version,
     )
 
     # Span Attributes for Request parameters
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SEED, str(handle_not_given(scope._kwargs.get("seed"), "")))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_SEED,
+        str(handle_not_given(scope._kwargs.get("seed"), "")),
+    )
     scope._span.set_attribute(
         SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY,
-        handle_not_given(scope._kwargs.get("frequency_penalty"), 0.0)
+        handle_not_given(scope._kwargs.get("frequency_penalty"), 0.0),
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS,
+        handle_not_given(scope._kwargs.get("max_tokens"), -1),
     )
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, handle_not_given(scope._kwargs.get("max_tokens"), -1))
     scope._span.set_attribute(
         SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY,
-        handle_not_given(scope._kwargs.get("presence_penalty"), 0.0)
+        handle_not_given(scope._kwargs.get("presence_penalty"), 0.0),
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES,
+        handle_not_given(scope._kwargs.get("stop"), []),
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_TEMPERATURE,
+        handle_not_given(scope._kwargs.get("temperature"), 1.0),
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_TOP_P,
+        handle_not_given(scope._kwargs.get("top_p"), 1.0),
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_USER,
+        handle_not_given(scope._kwargs.get("user"), ""),
     )
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, handle_not_given(scope._kwargs.get("stop"), []))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, handle_not_given(scope._kwargs.get("temperature"), 1.0))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P, handle_not_given(scope._kwargs.get("top_p"), 1.0))
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, handle_not_given(scope._kwargs.get("user"), ""))
 
     # Span Attributes for Response parameters
     scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, scope._response_id)
-    scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [scope._finish_reason])
-    scope._span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, "text" if isinstance(scope._llmresponse, str) else "json")
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [scope._finish_reason]
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_OUTPUT_TYPE,
+        "text" if isinstance(scope._llmresponse, str) else "json",
+    )
 
     # OpenAI-specific attributes
     if hasattr(scope, "_system_fingerprint") and scope._system_fingerprint:
-        scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_SYSTEM_FINGERPRINT, scope._system_fingerprint)
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_RESPONSE_SYSTEM_FINGERPRINT,
+            scope._system_fingerprint,
+        )
     if hasattr(scope, "_service_tier") and scope._service_tier:
-        scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SERVICE_TIER, scope._service_tier)
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_REQUEST_SERVICE_TIER, scope._service_tier
+        )
 
     # Span Attributes for Tools - optimized
     if hasattr(scope, "_tools") and scope._tools:
         tools = scope._tools if isinstance(scope._tools, list) else [scope._tools]
 
-        names, ids, args = zip(*[
-            (t.get("function", {}).get("name", ""),
-             str(t.get("id", "")),
-             str(t.get("function", {}).get("arguments", "")))
-            for t in tools if isinstance(t, dict) and t
-        ]) if tools else ([], [], [])
+        names, ids, args = (
+            zip(
+                *[
+                    (
+                        t.get("function", {}).get("name", ""),
+                        str(t.get("id", "")),
+                        str(t.get("function", {}).get("arguments", "")),
+                    )
+                    for t in tools
+                    if isinstance(t, dict) and t
+                ]
+            )
+            if tools
+            else ([], [], [])
+        )
 
-        scope._span.set_attribute(SemanticConvention.GEN_AI_TOOL_NAME, ", ".join(filter(None, names)))
-        scope._span.set_attribute(SemanticConvention.GEN_AI_TOOL_CALL_ID, ", ".join(filter(None, ids)))
-        scope._span.set_attribute(SemanticConvention.GEN_AI_TOOL_ARGS, ", ".join(filter(None, args)))
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_TOOL_NAME, ", ".join(filter(None, names))
+        )
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_TOOL_CALL_ID, ", ".join(filter(None, ids))
+        )
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_TOOL_ARGS, ", ".join(filter(None, args))
+        )
 
     # Span Attributes for Cost and Tokens
-    scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
-    scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
-    scope._span.set_attribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, input_tokens + output_tokens)
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, input_tokens + output_tokens
+    )
     scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
 
     # Span Attributes for Content
     if capture_message_content:
         scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, prompt)
-        scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, scope._llmresponse)
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_CONTENT_COMPLETION, scope._llmresponse
+        )
 
         # To be removed once the change to span_attributes (from span events) is complete
         scope._span.add_event(
@@ -521,23 +728,69 @@ def common_chat_logic(scope, pricing_info, environment, application_name, metric
 
     # Record metrics
     if not disable_metrics:
-        record_completion_metrics(metrics, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT, SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-            scope._server_address, scope._server_port, request_model, scope._response_model, environment,
-            application_name, scope._start_time, scope._end_time, input_tokens, output_tokens,
-            cost, scope._tbt, scope._ttft)
+        record_completion_metrics(
+            metrics,
+            SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,
+            SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+            scope._server_address,
+            scope._server_port,
+            request_model,
+            scope._response_model,
+            environment,
+            application_name,
+            scope._start_time,
+            scope._end_time,
+            input_tokens,
+            output_tokens,
+            cost,
+            scope._tbt,
+            scope._ttft,
+        )
+
 
-def process_streaming_chat_response(scope, pricing_info, environment, application_name, metrics,
-    capture_message_content=False, disable_metrics=False, version=""):
+def process_streaming_chat_response(
+    scope,
+    pricing_info,
+    environment,
+    application_name,
+    metrics,
+    capture_message_content=False,
+    disable_metrics=False,
+    version="",
+):
     """
     Process streaming chat response and generate telemetry.
     """
 
-    common_chat_logic(scope, pricing_info, environment, application_name, metrics,
-                        capture_message_content, disable_metrics, version, is_stream=True)
+    common_chat_logic(
+        scope,
+        pricing_info,
+        environment,
+        application_name,
+        metrics,
+        capture_message_content,
+        disable_metrics,
+        version,
+        is_stream=True,
+    )
+
 
-def process_chat_response(response, request_model, pricing_info, server_port, server_address,
-    environment, application_name, metrics, start_time, span, capture_message_content=False,
-    disable_metrics=False, version="1.0.0", **kwargs):
+def process_chat_response(
+    response,
+    request_model,
+    pricing_info,
+    server_port,
+    server_address,
+    environment,
+    application_name,
+    metrics,
+    start_time,
+    span,
+    capture_message_content=False,
+    disable_metrics=False,
+    version="1.0.0",
+    **kwargs,
+):
     """
     Process non-streaming chat response and generate telemetry.
     """
@@ -562,7 +815,11 @@ def process_chat_response(response, request_model, pricing_info, server_port, se
     scope._kwargs = kwargs
     scope._system_fingerprint = response_dict.get("system_fingerprint", "")
     scope._service_tier = response_dict.get("service_tier", "auto")
-    scope._finish_reason = str(response_dict.get("choices", [])[0].get("finish_reason", "")) if response_dict.get("choices") else ""
+    scope._finish_reason = (
+        str(response_dict.get("choices", [])[0].get("finish_reason", ""))
+        if response_dict.get("choices")
+        else ""
+    )
 
     # Handle operation type for responses API
     if kwargs.get("_operation_type") == "responses":
@@ -570,17 +827,38 @@ def process_chat_response(response, request_model, pricing_info, server_port, se
 
     # Handle tool calls
     if kwargs.get("tools"):
-        scope._tools = response_dict.get("choices", [{}])[0].get("message", {}).get("tool_calls")
+        scope._tools = (
+            response_dict.get("choices", [{}])[0].get("message", {}).get("tool_calls")
+        )
     else:
         scope._tools = None
 
-    common_chat_logic(scope, pricing_info, environment, application_name, metrics,
-                        capture_message_content, disable_metrics, version, is_stream=False)
+    common_chat_logic(
+        scope,
+        pricing_info,
+        environment,
+        application_name,
+        metrics,
+        capture_message_content,
+        disable_metrics,
+        version,
+        is_stream=False,
+    )
 
     return response
 
-def common_embedding_logic(scope, request_model, pricing_info, environment, application_name,
-    metrics, capture_message_content, disable_metrics, version):
+
+def common_embedding_logic(
+    scope,
+    request_model,
+    pricing_info,
+    environment,
+    application_name,
+    metrics,
+    capture_message_content,
+    disable_metrics,
+    version,
+):
     """
     Common logic for processing embedding operations.
     """
@@ -589,61 +867,127 @@ def common_embedding_logic(scope, request_model, pricing_info, environment, appl
     cost = get_embed_model_cost(request_model, pricing_info, scope._input_tokens)
 
     # Common Span Attributes
-    common_span_attributes(scope,
-        SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING, SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-        scope._server_address, scope._server_port, request_model, request_model,
-        environment, application_name, False, scope._tbt, scope._ttft, version)
+    common_span_attributes(
+        scope,
+        SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,
+        SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+        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_ENCODING_FORMATS,
-        [handle_not_given(scope._kwargs.get("encoding_format"), "float")]
+        [handle_not_given(scope._kwargs.get("encoding_format"), "float")],
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_USER,
+        handle_not_given(scope._kwargs.get("user"), ""),
     )
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, handle_not_given(scope._kwargs.get("user"), ""))
 
     # Span Attributes for Cost and Tokens
-    scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, scope._input_tokens)
-    scope._span.set_attribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, scope._input_tokens)
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, scope._input_tokens
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, scope._input_tokens
+    )
     scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
 
     # Span Attributes for Content
     if capture_message_content:
         input_data = scope._kwargs.get("input", "")
-        formatted_content = format_content(input_data) if isinstance(input_data, (list, dict)) else str(input_data)
-        scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, formatted_content)
+        formatted_content = (
+            format_content(input_data)
+            if isinstance(input_data, (list, dict))
+            else str(input_data)
+        )
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_CONTENT_PROMPT, formatted_content
+        )
 
     scope._span.set_status(Status(StatusCode.OK))
 
     # Record metrics
     if not disable_metrics:
-        record_embedding_metrics(metrics, SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING, SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-            scope._server_address, scope._server_port, request_model, request_model, environment,
-            application_name, scope._start_time, scope._end_time, scope._input_tokens, cost)
+        record_embedding_metrics(
+            metrics,
+            SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,
+            SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+            scope._server_address,
+            scope._server_port,
+            request_model,
+            request_model,
+            environment,
+            application_name,
+            scope._start_time,
+            scope._end_time,
+            scope._input_tokens,
+            cost,
+        )
 
-def common_image_logic(scope, request_model, pricing_info, environment, application_name,
-    metrics, capture_message_content, disable_metrics, version):
+
+def common_image_logic(
+    scope,
+    request_model,
+    pricing_info,
+    environment,
+    application_name,
+    metrics,
+    capture_message_content,
+    disable_metrics,
+    version,
+):
     """
     Common logic for processing image operations.
     """
 
     # Calculate cost
-    cost = get_image_model_cost(request_model, pricing_info,
-                                scope._kwargs.get("size", "1024x1024"),
-                                scope._kwargs.get("quality", "standard"))
+    cost = get_image_model_cost(
+        request_model,
+        pricing_info,
+        scope._kwargs.get("size", "1024x1024"),
+        scope._kwargs.get("quality", "standard"),
+    )
 
     # Common Span Attributes
-    common_span_attributes(scope,
-        SemanticConvention.GEN_AI_OPERATION_TYPE_IMAGE, SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-        scope._server_address, scope._server_port, request_model, request_model,
-        environment, application_name, False, scope._tbt, scope._ttft, version)
+    common_span_attributes(
+        scope,
+        SemanticConvention.GEN_AI_OPERATION_TYPE_IMAGE,
+        SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+        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_IMAGE_SIZE, handle_not_given(scope._kwargs.get("size"), "1024x1024"))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_IMAGE_SIZE,
+        handle_not_given(scope._kwargs.get("size"), "1024x1024"),
+    )
     scope._span.set_attribute(
         SemanticConvention.GEN_AI_REQUEST_IMAGE_QUALITY,
-        handle_not_given(scope._kwargs.get("quality"), "standard")
+        handle_not_given(scope._kwargs.get("quality"), "standard"),
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_USER,
+        handle_not_given(scope._kwargs.get("user"), ""),
     )
-    scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, handle_not_given(scope._kwargs.get("user"), ""))
 
     # Extract response data
     response_dict = scope._response_dict
@@ -655,7 +999,9 @@ def common_image_logic(scope, request_model, pricing_info, environment, applicat
 
     # Span Attributes for Response
     if response_created:
-        scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, str(response_created))
+        scope._span.set_attribute(
+            SemanticConvention.GEN_AI_RESPONSE_ID, str(response_created)
+        )
 
     # Process image data and collect URLs/base64 content
     if images_data:
@@ -673,7 +1019,9 @@ def common_image_logic(scope, request_model, pricing_info, environment, applicat
 
         # Set image response data using semantic conventions
         if image_contents:
-            scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_IMAGE, image_contents)
+            scope._span.set_attribute(
+                SemanticConvention.GEN_AI_RESPONSE_IMAGE, image_contents
+            )
 
     # Response-level attributes if different from request
     if response_size:
@@ -681,7 +1029,9 @@ def common_image_logic(scope, request_model, pricing_info, environment, applicat
     if response_quality:
         scope._span.set_attribute("gen_ai.response.image_quality", response_quality)
     if response_output_format:
-        scope._span.set_attribute("gen_ai.response.output_format", response_output_format)
+        scope._span.set_attribute(
+            "gen_ai.response.output_format", response_output_format
+        )
 
     # Span Attributes for Cost
     scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
@@ -701,7 +1051,9 @@ def common_image_logic(scope, request_model, pricing_info, environment, applicat
 
             # Set revised prompts as span attribute if any were found
             if revised_prompts:
-                scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_REVISED_PROMPT, revised_prompts)
+                scope._span.set_attribute(
+                    SemanticConvention.GEN_AI_CONTENT_REVISED_PROMPT, revised_prompts
+                )
 
             # Add revised prompt events for detailed tracking
             for i, image in enumerate(images_data):
@@ -709,7 +1061,9 @@ def common_image_logic(scope, request_model, pricing_info, environment, applicat
                     scope._span.add_event(
                         name=SemanticConvention.GEN_AI_CONTENT_REVISED_PROMPT,
                         attributes={
-                            SemanticConvention.GEN_AI_CONTENT_REVISED_PROMPT: image["revised_prompt"],
+                            SemanticConvention.GEN_AI_CONTENT_REVISED_PROMPT: image[
+                                "revised_prompt"
+                            ],
                             "image_index": i,
                         },
                     )
@@ -718,12 +1072,33 @@ def common_image_logic(scope, request_model, pricing_info, environment, applicat
 
     # Record metrics
     if not disable_metrics:
-        record_image_metrics(metrics, SemanticConvention.GEN_AI_OPERATION_TYPE_IMAGE, SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-            scope._server_address, scope._server_port, request_model, request_model, environment,
-            application_name, scope._start_time, scope._end_time, cost)
+        record_image_metrics(
+            metrics,
+            SemanticConvention.GEN_AI_OPERATION_TYPE_IMAGE,
+            SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+            scope._server_address,
+            scope._server_port,
+            request_model,
+            request_model,
+            environment,
+            application_name,
+            scope._start_time,
+            scope._end_time,
+            cost,
+        )
 
-def common_audio_logic(scope, request_model, pricing_info, environment, application_name,
-    metrics, capture_message_content, disable_metrics, version):
+
+def common_audio_logic(
+    scope,
+    request_model,
+    pricing_info,
+    environment,
+    application_name,
+    metrics,
+    capture_message_content,
+    disable_metrics,
+    version,
+):
     """
     Common logic for processing audio operations.
     """
@@ -733,18 +1108,35 @@ def common_audio_logic(scope, request_model, pricing_info, environment, applicat
     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_OPENAI,
-        scope._server_address, scope._server_port, request_model, request_model,
-        environment, application_name, False, scope._tbt, scope._ttft, version)
+    common_span_attributes(
+        scope,
+        SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO,
+        SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+        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"), "alloy"))
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_AUDIO_VOICE,
+        handle_not_given(scope._kwargs.get("voice"), "alloy"),
+    )
     scope._span.set_attribute(
         SemanticConvention.GEN_AI_REQUEST_AUDIO_RESPONSE_FORMAT,
-        handle_not_given(scope._kwargs.get("response_format"), "mp3")
+        handle_not_given(scope._kwargs.get("response_format"), "mp3"),
+    )
+    scope._span.set_attribute(
+        SemanticConvention.GEN_AI_REQUEST_AUDIO_SPEED,
+        handle_not_given(scope._kwargs.get("speed"), 1.0),
     )
-    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)
@@ -758,13 +1150,39 @@ def common_audio_logic(scope, request_model, pricing_info, environment, applicat
 
     # Record metrics
     if not disable_metrics:
-        record_audio_metrics(metrics, SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO, SemanticConvention.GEN_AI_SYSTEM_OPENAI,
-            scope._server_address, scope._server_port, request_model, request_model, environment,
-            application_name, scope._start_time, scope._end_time, cost)
+        record_audio_metrics(
+            metrics,
+            SemanticConvention.GEN_AI_OPERATION_TYPE_AUDIO,
+            SemanticConvention.GEN_AI_SYSTEM_OPENAI,
+            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", **kwargs):
+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",
+    **kwargs,
+):
     """
     Process audio generation response and generate telemetry.
     """
@@ -779,14 +1197,37 @@ def process_audio_response(response, request_model, pricing_info, server_port, s
     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)
+    common_audio_logic(
+        scope,
+        request_model,
+        pricing_info,
+        environment,
+        application_name,
+        metrics,
+        capture_message_content,
+        disable_metrics,
+        version,
+    )
 
     return response
 
-def process_embedding_response(response, request_model, pricing_info, server_port, server_address,
-    environment, application_name, metrics, start_time, span, capture_message_content=False,
-    disable_metrics=False, version="1.0.0", **kwargs):
+
+def process_embedding_response(
+    response,
+    request_model,
+    pricing_info,
+    server_port,
+    server_address,
+    environment,
+    application_name,
+    metrics,
+    start_time,
+    span,
+    capture_message_content=False,
+    disable_metrics=False,
+    version="1.0.0",
+    **kwargs,
+):
     """
     Process embedding response and generate telemetry.
     """
@@ -803,14 +1244,38 @@ def process_embedding_response(response, request_model, pricing_info, server_por
     scope._server_address, scope._server_port = server_address, server_port
     scope._kwargs = kwargs
 
-    common_embedding_logic(scope, request_model, pricing_info, environment, application_name,
-                          metrics, capture_message_content, disable_metrics, version)
+    common_embedding_logic(
+        scope,
+        request_model,
+        pricing_info,
+        environment,
+        application_name,
+        metrics,
+        capture_message_content,
+        disable_metrics,
+        version,
+    )
 
     return response
 
-def process_image_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", **kwargs):
+
+def process_image_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",
+    **kwargs,
+):
     """
     Process image generation response and generate telemetry.
     """
@@ -827,7 +1292,16 @@ def process_image_response(response, request_model, pricing_info, server_port, s
     scope._kwargs = kwargs
     scope._response_dict = response_dict
 
-    common_image_logic(scope, request_model, pricing_info, environment, application_name,
-                       metrics, capture_message_content, disable_metrics, version)
+    common_image_logic(
+        scope,
+        request_model,
+        pricing_info,
+        environment,
+        application_name,
+        metrics,
+        capture_message_content,
+        disable_metrics,
+        version,
+    )
 
     return response