microsoft-agents-a365-observability-extensions-openai 0.1.0__py3-none-any.whl

microsoft_agents_a365/observability/extensions/openai/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""
+Wraps the OpenAI Agents SDK tracer to integrate with the Microsoft Agent 365 Telemetry Solution.
+"""
+
+from .trace_instrumentor import OpenAIAgentsTraceInstrumentor
+
+__all__ = ["OpenAIAgentsTraceInstrumentor"]

microsoft_agents_a365/observability/extensions/openai/constants.py

@@ -0,0 +1,34 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Span Attribute Types
+from microsoft_agents_a365.observability.core.constants import (
+    EXECUTE_TOOL_OPERATION_NAME,
+    INVOKE_AGENT_OPERATION_NAME,
+)
+from microsoft_agents_a365.observability.core.inference_operation_type import InferenceOperationType
+
+GEN_AI_SPAN_KIND_AGENT_KEY = INVOKE_AGENT_OPERATION_NAME
+GEN_AI_SPAN_KIND_TOOL_KEY = EXECUTE_TOOL_OPERATION_NAME
+GEN_AI_SPAN_KIND_CHAIN_KEY = "chain"
+GEN_AI_SPAN_KIND_LLM_KEY = InferenceOperationType.CHAT.value.lower()
+GEN_AI_SPAN_KIND_RETRIEVER_KEY = "retriever"
+GEN_AI_SPAN_KIND_EMBEDDING_KEY = "embedding"
+GEN_AI_SPAN_KIND_RERANKER_KEY = "reranker"
+GEN_AI_SPAN_KIND_GUARDRAIL_KEY = "guardrail"
+GEN_AI_SPAN_KIND_EVALUATOR_KEY = "evaluator"
+GEN_AI_SPAN_KIND_UNKNOWN_KEY = "unknown"
+
+# PREFIXES
+GEN_AI_MESSAGE_ROLE = "message_role"
+GEN_AI_MESSAGE_CONTENT = "message_content"
+GEN_AI_MESSAGE_CONTENTS = "message_contents"
+GEN_AI_MESSAGE_CONTENT_TYPE = "content_type"
+GEN_AI_MESSAGE_TOOL_CALLS = "message_tool_calls"
+GEN_AI_MESSAGE_TOOL_CALL_ID = "message_tool_id"
+GEN_AI_MESSAGE_TOOL_CALL_NAME = "message_tool_name"
+GEN_AI_TOOL_JSON_SCHEMA = "tool_json_schema"
+GEN_AI_LLM_TOKEN_COUNT_TOTAL = "llm_token_count_total"
+GEN_AI_LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHED_READ = "llm_token_count_prompt_details_cached_read"
+GEN_AI_LLM_TOKEN_COUNT_COMPLETION_DETAILS_REASONING = "llm_token_count_completion_details_reasoning"
+GEN_AI_GRAPH_NODE_ID = "graph_node_id"
+GEN_AI_GRAPH_NODE_PARENT_ID = "graph_node_parent_id"

microsoft_agents_a365/observability/extensions/openai/trace_instrumentor.py

@@ -0,0 +1,70 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Wrapper for OpenAI Agents SDK
+
+import logging
+from collections.abc import Collection
+from typing import Any, cast
+
+import opentelemetry.trace as optel_trace
+from agents import set_trace_processors
+from microsoft_agents_a365.observability.core import get_tracer, get_tracer_provider, is_configured
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import Tracer
+
+from .trace_processor import OpenAIAgentsTraceProcessor
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+_instruments = ("openai-agents >= 0.2.6",)
+
+
+class OpenAIAgentsTraceInstrumentor(BaseInstrumentor):
+    """
+    Custom Trace Processor for OpenAI Agents SDK using Microsoft Agent 365.
+    Forwards OpenAI Agents SDK traces and spans to Microsoft Agent 365's tracing scopes.
+
+    ```
+    """
+
+    def __init__(self):
+        """Initialize the OpenAIAgentsTraceInstrumentor.
+        Raises: RuntimeError: If Microsoft Agent 365 is not configured.
+        """
+        # Verify if Microsoft Agent 365 is configured
+        Agent365_status = is_configured()
+        if not Agent365_status:
+            raise RuntimeError(
+                "Microsoft Agent 365 is not configured yet. Please configure Microsoft Agent 365 before initializing this instrumentor."
+            )
+        super().__init__()
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs: Any) -> None:
+        """Instruments the OpenAI Agents SDK with Microsoft Agent 365 tracing."""
+        tracer_name = kwargs["tracer_name"] if kwargs.get("tracer_name") else None
+        tracer_version = kwargs["tracer_version"] if kwargs.get("tracer_version") else None
+
+        # Get the configured Microsoft Agent 365 Tracer
+        try:
+            tracer = get_tracer(tracer_name, tracer_version)
+        except Exception:
+            # fallback
+            tracer = optel_trace.get_tracer(tracer_name, tracer_version)
+
+        # Get the configured Microsoft Agent 365 Tracer Provider instance
+        try:
+            get_tracer_provider()
+        except Exception:
+            # fallback
+            optel_trace.get_tracer_provider()
+
+        agent365_tracer = cast(Tracer, tracer)
+
+        set_trace_processors([OpenAIAgentsTraceProcessor(agent365_tracer)])
+
+    def _uninstrument(self, **kwargs: Any) -> None:
+        pass

microsoft_agents_a365/observability/extensions/openai/trace_processor.py

@@ -0,0 +1,212 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Processor for OpenAI Agents SDK
+
+from __future__ import annotations
+
+import logging
+from collections import OrderedDict
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, assert_never
+
+from agents import MCPListToolsSpanData
+from agents.tracing import Span, Trace, TracingProcessor
+from agents.tracing.span_data import (
+    AgentSpanData,
+    FunctionSpanData,
+    GenerationSpanData,
+    HandoffSpanData,
+    ResponseSpanData,
+)
+from microsoft_agents_a365.observability.core.constants import (
+    CUSTOM_PARENT_SPAN_ID_KEY,
+    EXECUTE_TOOL_OPERATION_NAME,
+    GEN_AI_INPUT_MESSAGES_KEY,
+    GEN_AI_OPERATION_NAME_KEY,
+    GEN_AI_OUTPUT_MESSAGES_KEY,
+    GEN_AI_REQUEST_MODEL_KEY,
+    GEN_AI_SYSTEM_KEY,
+    INVOKE_AGENT_OPERATION_NAME,
+)
+from microsoft_agents_a365.observability.core.utils import as_utc_nano, safe_json_dumps
+from opentelemetry import trace as ot_trace
+from opentelemetry.context import attach, detach
+from opentelemetry.trace import Span as OtelSpan
+from opentelemetry.trace import (
+    Status,
+    StatusCode,
+    Tracer,
+    set_span_in_context,
+)
+
+from openai.types.responses import (
+    Response,
+)
+
+from .constants import (
+    GEN_AI_GRAPH_NODE_ID,
+    GEN_AI_GRAPH_NODE_PARENT_ID,
+)
+from .utils import (
+    get_attributes_from_function_span_data,
+    get_attributes_from_generation_span_data,
+    get_attributes_from_input,
+    get_attributes_from_mcp_list_tool_span_data,
+    get_attributes_from_response,
+    get_span_kind,
+    get_span_name,
+    get_span_status,
+)
+
+logger = logging.getLogger(__name__)
+
+
+"""
+Custom Trace Processor for OpenAI Agents SDK
+"""
+
+
+class OpenAIAgentsTraceProcessor(TracingProcessor):
+    _MAX_HANDOFFS_IN_FLIGHT = 1000
+
+    def __init__(self, tracer: Tracer) -> None:
+        self._tracer = tracer
+        self._root_spans: dict[str, OtelSpan] = {}
+        self._otel_spans: dict[str, OtelSpan] = {}
+        self._tokens: dict[str, object] = {}
+        # This captures in flight handoff. Once the handoff is complete, the entry is deleted
+        # If the handoff does not complete, the entry stays in the dict.
+        # Use an OrderedDict and _MAX_HANDOFFS_IN_FLIGHT to cap the size of the dict
+        # in case there are large numbers of orphaned handoffs
+        self._reverse_handoffs_dict: OrderedDict[str, str] = OrderedDict()
+
+    # helper
+    def _stamp_custom_parent(self, otel_span: OtelSpan, trace_id: str) -> None:
+        root = self._root_spans.get(trace_id)
+        if not root:
+            return
+        sc = root.get_span_context()
+        pid_hex = "0x" + ot_trace.format_span_id(sc.span_id)
+        otel_span.set_attribute(CUSTOM_PARENT_SPAN_ID_KEY, pid_hex)
+
+    def on_trace_start(self, trace: Trace) -> None:
+        """Called when a trace is started.
+
+        Args:
+            trace: The trace that started.
+        """
+
+    def on_trace_end(self, trace: Trace) -> None:
+        """Called when a trace is finished.
+
+        Args:
+            trace: The trace that started.
+        """
+        if root_span := self._root_spans.pop(trace.trace_id, None):
+            root_span.set_status(Status(StatusCode.OK))
+            root_span.end()
+
+    def on_span_start(self, span: Span[Any]) -> None:
+        """Called when a span is started.
+
+        Args:
+            span: The span that started.
+        """
+        if not span.started_at:
+            return
+        start_time = datetime.fromisoformat(span.started_at)
+        parent_span = (
+            self._otel_spans.get(span.parent_id)
+            if span.parent_id
+            else self._root_spans.get(span.trace_id)
+        )
+        context = set_span_in_context(parent_span) if parent_span else None
+        span_name = get_span_name(span)
+        otel_span = self._tracer.start_span(
+            name=span_name,
+            context=context,
+            start_time=as_utc_nano(start_time),
+            attributes={
+                GEN_AI_OPERATION_NAME_KEY: get_span_kind(span.span_data),
+                GEN_AI_SYSTEM_KEY: "openai",
+            },
+        )
+        self._otel_spans[span.span_id] = otel_span
+        self._tokens[span.span_id] = attach(set_span_in_context(otel_span))
+
+    def on_span_end(self, span: Span[Any]) -> None:
+        """Called when a span is finished. Should not block or raise exceptions.
+
+        Args:
+            span: The span that finished.
+        """
+        if token := self._tokens.pop(span.span_id, None):
+            detach(token)  # type: ignore[arg-type]
+        if not (otel_span := self._otel_spans.pop(span.span_id, None)):
+            return
+        otel_span.update_name(get_span_name(span))
+
+        data = span.span_data
+
+        # DATA TYPES AS PER OPENAI AGENTS SDK
+        if isinstance(data, ResponseSpanData):
+            if hasattr(data, "response") and isinstance(response := data.response, Response):
+                otel_span.set_attribute(GEN_AI_OUTPUT_MESSAGES_KEY, response.model_dump_json())
+                for k, v in get_attributes_from_response(response):
+                    otel_span.set_attribute(k, v)
+            if hasattr(data, "input") and (input := data.input):
+                if isinstance(input, str):
+                    otel_span.set_attribute(GEN_AI_INPUT_MESSAGES_KEY, input)
+                elif isinstance(input, list):
+                    otel_span.set_attribute(GEN_AI_INPUT_MESSAGES_KEY, safe_json_dumps(input))
+                    for k, v in get_attributes_from_input(input):
+                        otel_span.set_attribute(k, v)
+                elif TYPE_CHECKING:
+                    assert_never(input)
+        elif isinstance(data, GenerationSpanData):
+            for k, v in get_attributes_from_generation_span_data(data):
+                otel_span.set_attribute(k, v)
+            self._stamp_custom_parent(otel_span, span.trace_id)
+            otel_span.update_name(
+                f"{otel_span.attributes[GEN_AI_OPERATION_NAME_KEY]} {otel_span.attributes[GEN_AI_REQUEST_MODEL_KEY]}"
+            )
+        elif isinstance(data, FunctionSpanData):
+            for k, v in get_attributes_from_function_span_data(data):
+                otel_span.set_attribute(k, v)
+            self._stamp_custom_parent(otel_span, span.trace_id)
+            otel_span.update_name(f"{EXECUTE_TOOL_OPERATION_NAME} {data.function_name}")
+        elif isinstance(data, MCPListToolsSpanData):
+            for k, v in get_attributes_from_mcp_list_tool_span_data(data):
+                otel_span.set_attribute(k, v)
+        elif isinstance(data, HandoffSpanData):
+            # Set this dict to find the parent node when the agent span starts
+            if data.to_agent and data.from_agent:
+                key = f"{data.to_agent}:{span.trace_id}"
+                self._reverse_handoffs_dict[key] = data.from_agent
+                # Cap the size of the dict
+                while len(self._reverse_handoffs_dict) > self._MAX_HANDOFFS_IN_FLIGHT:
+                    self._reverse_handoffs_dict.popitem(last=False)
+        elif isinstance(data, AgentSpanData):
+            otel_span.set_attribute(GEN_AI_GRAPH_NODE_ID, data.name)
+            # Lookup the parent node if exists
+            key = f"{data.name}:{span.trace_id}"
+            if parent_node := self._reverse_handoffs_dict.pop(key, None):
+                otel_span.set_attribute(GEN_AI_GRAPH_NODE_PARENT_ID, parent_node)
+            otel_span.update_name(f"{INVOKE_AGENT_OPERATION_NAME} {get_span_name(span)}")
+
+        end_time: int | None = None
+        if span.ended_at:
+            try:
+                end_time = as_utc_nano(datetime.fromisoformat(span.ended_at))
+            except ValueError:
+                pass
+        otel_span.set_status(status=get_span_status(span))
+        otel_span.end(end_time)
+
+    def force_flush(self) -> None:
+        """Forces an immediate flush of all queued spans/traces."""
+        pass
+
+    def shutdown(self) -> None:
+        """Called when the application stops."""
+        pass

microsoft_agents_a365/observability/extensions/openai/utils.py

@@ -0,0 +1,536 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# -------------------------------------------------- #
+# HELPER FUNCTIONS ###
+# -------------------------------------------------- #
+
+from collections.abc import Iterable, Iterator, Mapping
+from typing import TYPE_CHECKING, Any, assert_never
+from urllib.parse import urlparse
+
+from agents import MCPListToolsSpanData
+from agents.tracing import Span
+from agents.tracing.span_data import (
+    AgentSpanData,
+    CustomSpanData,
+    FunctionSpanData,
+    GenerationSpanData,
+    GuardrailSpanData,
+    HandoffSpanData,
+    ResponseSpanData,
+    SpanData,
+)
+from microsoft_agents_a365.observability.core.constants import (
+    GEN_AI_CHOICE,
+    GEN_AI_EXECUTION_PAYLOAD_KEY,
+    GEN_AI_INPUT_MESSAGES_KEY,
+    GEN_AI_OUTPUT_MESSAGES_KEY,
+    GEN_AI_PROVIDER_NAME_KEY,
+    GEN_AI_REQUEST_MODEL_KEY,
+    GEN_AI_RESPONSE_FINISH_REASONS_KEY,
+    GEN_AI_RESPONSE_ID_KEY,
+    GEN_AI_SYSTEM_KEY,
+    GEN_AI_TOOL_ARGS_KEY,
+    GEN_AI_TOOL_CALL_ID_KEY,
+    GEN_AI_TOOL_CALL_RESULT_KEY,
+    GEN_AI_TOOL_NAME_KEY,
+    GEN_AI_USAGE_INPUT_TOKENS_KEY,
+    GEN_AI_USAGE_OUTPUT_TOKENS_KEY,
+)
+from microsoft_agents_a365.observability.core.utils import safe_json_dumps
+from opentelemetry.trace import (
+    Status,
+    StatusCode,
+)
+from opentelemetry.util.types import AttributeValue
+
+from openai.types.responses import (
+    EasyInputMessageParam,
+    FunctionTool,
+    Response,
+    ResponseCustomToolCall,
+    ResponseCustomToolCallOutputParam,
+    ResponseCustomToolCallParam,
+    ResponseFunctionToolCall,
+    ResponseFunctionToolCallParam,
+    ResponseInputContentParam,
+    ResponseInputItemParam,
+    ResponseOutputItem,
+    ResponseOutputMessage,
+    ResponseOutputMessageParam,
+    ResponseOutputRefusal,
+    ResponseOutputText,
+    ResponseUsage,
+    Tool,
+)
+from openai.types.responses.response_input_item_param import FunctionCallOutput, Message
+from openai.types.responses.response_output_message_param import Content
+
+from .constants import (
+    GEN_AI_LLM_TOKEN_COUNT_COMPLETION_DETAILS_REASONING,
+    GEN_AI_LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHED_READ,
+    GEN_AI_LLM_TOKEN_COUNT_TOTAL,
+    GEN_AI_MESSAGE_CONTENT,
+    GEN_AI_MESSAGE_CONTENT_TYPE,
+    GEN_AI_MESSAGE_CONTENTS,
+    GEN_AI_MESSAGE_ROLE,
+    GEN_AI_MESSAGE_TOOL_CALL_ID,
+    GEN_AI_MESSAGE_TOOL_CALL_NAME,
+    GEN_AI_MESSAGE_TOOL_CALLS,
+    GEN_AI_SPAN_KIND_AGENT_KEY,
+    GEN_AI_SPAN_KIND_CHAIN_KEY,
+    GEN_AI_SPAN_KIND_LLM_KEY,
+    GEN_AI_SPAN_KIND_TOOL_KEY,
+    GEN_AI_TOOL_JSON_SCHEMA,
+)
+
+
+def get_span_name(obj: Span[Any]) -> str:
+    if hasattr(data := obj.span_data, "name") and isinstance(name := data.name, str):
+        return name
+    if isinstance(obj.span_data, HandoffSpanData) and obj.span_data.to_agent:
+        return f"handoff to {obj.span_data.to_agent}"
+    return obj.span_data.type  # type: ignore[no-any-return]
+
+
+def get_span_kind(obj: SpanData) -> str:
+    if isinstance(obj, AgentSpanData):
+        return GEN_AI_SPAN_KIND_AGENT_KEY
+    if isinstance(obj, FunctionSpanData):
+        return GEN_AI_SPAN_KIND_TOOL_KEY
+    if isinstance(obj, GenerationSpanData):
+        return GEN_AI_SPAN_KIND_LLM_KEY
+    if isinstance(obj, ResponseSpanData):
+        return GEN_AI_SPAN_KIND_LLM_KEY
+    if isinstance(obj, HandoffSpanData):
+        return GEN_AI_SPAN_KIND_TOOL_KEY
+    if isinstance(obj, CustomSpanData):
+        return GEN_AI_SPAN_KIND_CHAIN_KEY
+    if isinstance(obj, GuardrailSpanData):
+        return GEN_AI_SPAN_KIND_CHAIN_KEY
+    return GEN_AI_SPAN_KIND_CHAIN_KEY
+
+
+def get_attributes_from_input(
+    obj: Iterable[ResponseInputItemParam],
+    msg_idx: int = 1,
+) -> Iterator[tuple[str, AttributeValue]]:
+    for i, item in enumerate(obj, msg_idx):
+        prefix = f"{GEN_AI_INPUT_MESSAGES_KEY}.{i}."
+        if "type" not in item:
+            if "role" in item and "content" in item:
+                yield from get_attributes_from_message_param(
+                    {  # type: ignore[misc, arg-type]
+                        "type": "message",
+                        "role": item["role"],  # type: ignore[typeddict-item]
+                        "content": item["content"],  # type: ignore[typeddict-item]
+                    },
+                    prefix,
+                )
+        elif item["type"] == "message":
+            yield from get_attributes_from_message_param(item, prefix)
+        elif item["type"] == "function_call":
+            yield f"{prefix}{GEN_AI_MESSAGE_ROLE}", "assistant"
+            yield from get_attributes_from_response_function_tool_call_param(
+                item,
+                f"{prefix}{GEN_AI_MESSAGE_TOOL_CALLS}.0.",
+            )
+        elif item["type"] == "function_call_output":
+            yield from get_attributes_from_function_call_output(item, prefix)
+        elif item["type"] == "custom_tool_call":
+            yield f"{prefix}{GEN_AI_MESSAGE_ROLE}", "assistant"
+            yield from get_attributes_from_response_custom_tool_call_param(
+                item,
+                f"{prefix}{GEN_AI_MESSAGE_TOOL_CALLS}.0.",
+            )
+        elif item["type"] == "custom_tool_call_output":
+            yield from get_attributes_from_response_custom_tool_call_output_param(item, prefix)
+        elif TYPE_CHECKING and item["type"] is not None:
+            assert_never(item["type"])
+
+
+def get_attributes_from_message_param(
+    obj: EasyInputMessageParam | Message | ResponseOutputMessageParam,
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    yield f"{prefix}{GEN_AI_MESSAGE_ROLE}", obj["role"]
+    if content := obj.get("content"):
+        if isinstance(content, str):
+            yield f"{prefix}{GEN_AI_MESSAGE_CONTENT}", content
+        elif isinstance(content, list):
+            yield from get_attributes_from_message_content_list(content, prefix)
+
+
+def get_attributes_from_response_function_tool_call_param(
+    obj: ResponseFunctionToolCallParam,
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    yield f"{prefix}{GEN_AI_MESSAGE_TOOL_CALL_ID}", obj["call_id"]
+    yield f"{prefix}{GEN_AI_MESSAGE_TOOL_CALL_NAME}", obj["name"]
+    if obj["arguments"] != "{}":
+        yield f"{prefix}{GEN_AI_TOOL_ARGS_KEY}", obj["arguments"]
+
+
+def get_attributes_from_response_custom_tool_call_param(
+    obj: ResponseCustomToolCallParam,
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    if (call_id := obj.get("call_id")) is not None:
+        yield f"{prefix}{GEN_AI_TOOL_CALL_ID_KEY}", call_id
+    if (name := obj.get("name")) is not None:
+        yield f"{prefix}{GEN_AI_TOOL_NAME_KEY}", name
+    if (input_data := obj.get("input")) is not None:
+        yield (
+            f"{prefix}{GEN_AI_TOOL_ARGS_KEY}",
+            safe_json_dumps({"input": input_data}),
+        )
+
+
+def get_attributes_from_response_custom_tool_call_output_param(
+    obj: ResponseCustomToolCallOutputParam,
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    yield f"{prefix}{GEN_AI_MESSAGE_ROLE}", "tool"
+    if (call_id := obj.get("call_id")) is not None:
+        yield f"{prefix}{GEN_AI_TOOL_CALL_ID_KEY}", call_id
+    if (output := obj.get("output")) is not None:
+        yield f"{prefix}{GEN_AI_TOOL_CALL_RESULT_KEY}", output
+
+
+def get_attributes_from_function_call_output(
+    obj: FunctionCallOutput,
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    yield f"{prefix}{GEN_AI_MESSAGE_ROLE}", "tool"
+    yield f"{prefix}{GEN_AI_TOOL_CALL_ID_KEY}", obj["call_id"]
+    yield f"{prefix}{GEN_AI_TOOL_CALL_RESULT_KEY}", obj["output"]
+
+
+def get_attributes_from_generation_span_data(
+    obj: GenerationSpanData,
+) -> Iterator[tuple[str, AttributeValue]]:
+    yield GEN_AI_PROVIDER_NAME_KEY, "openai"
+    if isinstance(model := obj.model, str):
+        yield GEN_AI_REQUEST_MODEL_KEY, model
+    if isinstance(obj.model_config, dict) and (
+        param := {k: v for k, v in obj.model_config.items() if v is not None}
+    ):
+        yield GEN_AI_EXECUTION_PAYLOAD_KEY, safe_json_dumps(param)
+        if base_url := param.get("base_url"):
+            parsed = urlparse(base_url)
+            if parsed.hostname == "api.openai.com":
+                yield GEN_AI_SYSTEM_KEY, "openai"
+    yield from _get_attributes_from_chat_completions_input(obj.input)
+    yield from _get_attributes_from_chat_completions_output(obj.output)
+    yield from _get_attributes_from_chat_completions_usage(obj.usage)
+
+
+def get_attributes_from_mcp_list_tool_span_data(
+    obj: MCPListToolsSpanData,
+) -> Iterator[tuple[str, AttributeValue]]:
+    yield GEN_AI_OUTPUT_MESSAGES_KEY, safe_json_dumps(obj.result)
+
+
+def _get_attributes_from_chat_completions_input(
+    obj: Iterable[Mapping[str, Any]] | None,
+) -> Iterator[tuple[str, AttributeValue]]:
+    if not obj:
+        return
+    try:
+        yield GEN_AI_INPUT_MESSAGES_KEY, safe_json_dumps(obj)
+    except Exception:
+        pass
+    yield from get_attributes_from_chat_completions_message_dicts(
+        obj,
+        f"{GEN_AI_INPUT_MESSAGES_KEY}.",
+    )
+
+
+def _get_attributes_from_chat_completions_output(
+    obj: Iterable[Mapping[str, Any]] | None,
+) -> Iterator[tuple[str, AttributeValue]]:
+    if not obj:
+        return
+    try:
+        yield GEN_AI_OUTPUT_MESSAGES_KEY, safe_json_dumps(obj)
+    except Exception:
+        pass
+
+    if isinstance(obj, Mapping) and "id" in obj:
+        yield GEN_AI_RESPONSE_ID_KEY, obj["id"]
+
+    # Collect all finish_reason values
+    finish_reasons = [
+        message.get("finish_reason") for message in obj if message.get("finish_reason") is not None
+    ]
+    if finish_reasons:
+        yield GEN_AI_RESPONSE_FINISH_REASONS_KEY, ",".join(finish_reasons)
+
+    yield from get_attributes_from_chat_completions_message_dicts(
+        obj,
+        f"{GEN_AI_OUTPUT_MESSAGES_KEY}.",
+    )
+
+
+def get_attributes_from_chat_completions_message_dicts(
+    obj: Iterable[Mapping[str, Any]],
+    prefix: str = "",
+    msg_idx: int = 0,
+    tool_call_idx: int = 0,
+) -> Iterator[tuple[str, AttributeValue]]:
+    if not isinstance(obj, Iterable):
+        return
+    for msg in obj:
+        if isinstance(role := msg.get("role"), str):
+            yield f"{prefix}{msg_idx}.{GEN_AI_MESSAGE_ROLE}", role
+        if content := msg.get("content"):
+            yield from get_attributes_from_chat_completions_message_content(
+                content,
+                f"{prefix}{msg_idx}.",
+            )
+        if isinstance(tool_call_id := msg.get("tool_call_id"), str):
+            yield f"{prefix}{msg_idx}.{GEN_AI_MESSAGE_TOOL_CALL_ID}", tool_call_id
+        if isinstance(tool_calls := msg.get("tool_calls"), Iterable):
+            for tc in tool_calls:
+                yield from _get_attributes_from_chat_completions_tool_call_dict(
+                    tc,
+                    f"{prefix}{msg_idx}.{GEN_AI_MESSAGE_TOOL_CALLS}.{tool_call_idx}.",
+                )
+                tool_call_idx += 1
+        msg_idx += 1
+
+
+def get_attributes_from_chat_completions_message_content(
+    obj: str | Iterable[Mapping[str, Any]],
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    if isinstance(obj, str):
+        yield f"{prefix}{GEN_AI_MESSAGE_CONTENT}", obj
+    elif isinstance(obj, Iterable):
+        for i, item in enumerate(obj):
+            if not isinstance(item, Mapping):
+                continue
+            yield from _get_attributes_from_chat_completions_message_content_item(
+                item,
+                f"{prefix}{GEN_AI_MESSAGE_CONTENTS}.{i}.",
+            )
+
+
+def _get_attributes_from_chat_completions_message_content_item(
+    obj: Mapping[str, Any],
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    if obj.get("type") == "text" and (text := obj.get("text")):
+        yield f"{prefix}{GEN_AI_OUTPUT_MESSAGES_KEY}", text
+
+
+def _get_attributes_from_chat_completions_tool_call_dict(
+    obj: Mapping[str, Any],
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    if id_ := obj.get("id"):
+        yield f"{prefix}{GEN_AI_TOOL_CALL_ID_KEY}", id_
+    if function := obj.get("function"):
+        if name := function.get("name"):
+            yield f"{prefix}{GEN_AI_TOOL_NAME_KEY}", name
+        if arguments := function.get("arguments"):
+            if arguments != "{}":
+                yield f"{prefix}{GEN_AI_TOOL_ARGS_KEY}", arguments
+
+
+def _get_attributes_from_chat_completions_usage(
+    obj: Mapping[str, Any] | None,
+) -> Iterator[tuple[str, AttributeValue]]:
+    if not obj:
+        return
+    if input_tokens := obj.get("input_tokens"):
+        yield GEN_AI_USAGE_INPUT_TOKENS_KEY, input_tokens
+    if output_tokens := obj.get("output_tokens"):
+        yield GEN_AI_USAGE_OUTPUT_TOKENS_KEY, output_tokens
+
+
+def _convert_to_primitive(value: Any) -> bool | str | bytes | int | float:
+    if isinstance(value, (bool, str, bytes, int, float)):
+        return value
+    if isinstance(value, (list, tuple)):
+        return safe_json_dumps(value)
+    if isinstance(value, dict):
+        return safe_json_dumps(value)
+    return str(value)
+
+
+def get_attributes_from_function_span_data(
+    obj: FunctionSpanData,
+) -> Iterator[tuple[str, AttributeValue]]:
+    yield GEN_AI_TOOL_NAME_KEY, obj.name
+    if obj.input:
+        yield GEN_AI_INPUT_MESSAGES_KEY, obj.input
+    if obj.output is not None:
+        yield GEN_AI_OUTPUT_MESSAGES_KEY, _convert_to_primitive(obj.output)
+
+
+def get_attributes_from_message_content_list(
+    obj: Iterable[ResponseInputContentParam | Content],
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    for i, item in enumerate(obj):
+        if item["type"] == "input_text" or item["type"] == "output_text":
+            yield f"{prefix}{GEN_AI_INPUT_MESSAGES_KEY}.{i}.{GEN_AI_MESSAGE_CONTENT_TYPE}", "text"
+            yield (
+                f"{prefix}{GEN_AI_INPUT_MESSAGES_KEY}.{i}.{GEN_AI_OUTPUT_MESSAGES_KEY}",
+                item["text"],
+            )
+        elif item["type"] == "refusal":
+            yield f"{prefix}{GEN_AI_INPUT_MESSAGES_KEY}.{i}.{GEN_AI_MESSAGE_CONTENT_TYPE}", "text"
+            yield (
+                f"{prefix}{GEN_AI_INPUT_MESSAGES_KEY}.{i}.{GEN_AI_OUTPUT_MESSAGES_KEY}",
+                item["refusal"],
+            )
+        elif TYPE_CHECKING:
+            assert_never(item["type"])
+
+
+def get_attributes_from_response(obj: Response) -> Iterator[tuple[str, AttributeValue]]:
+    yield from get_attributes_from_tools(obj.tools)
+    yield from get_attributes_from_usage(obj.usage)
+    yield from get_attributes_from_response_output(obj.output)
+    if isinstance(obj.instructions, str):
+        yield from _get_attributes_from_response_instruction(obj.instructions)
+    else:
+        pass  # TODO: handle list instructions
+    yield GEN_AI_REQUEST_MODEL_KEY, obj.model
+    param = obj.model_dump(
+        exclude_none=True,
+        exclude={"object", "tools", "usage", "output", "error", "status"},
+    )
+    yield GEN_AI_EXECUTION_PAYLOAD_KEY, safe_json_dumps(param)
+
+
+def get_attributes_from_tools(
+    tools: Iterable[Tool] | None,
+) -> Iterator[tuple[str, AttributeValue]]:
+    if not tools:
+        return
+    for i, tool in enumerate(tools):
+        if isinstance(tool, FunctionTool):
+            yield (
+                f"{GEN_AI_CHOICE}.{i}.{GEN_AI_TOOL_JSON_SCHEMA}",
+                safe_json_dumps(
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": tool.name,
+                            "description": tool.description,
+                            "parameters": tool.parameters,
+                            "strict": tool.strict,
+                        },
+                    }
+                ),
+            )
+        else:
+            pass
+
+
+def get_attributes_from_response_output(
+    obj: Iterable[ResponseOutputItem],
+    msg_idx: int = 0,
+) -> Iterator[tuple[str, AttributeValue]]:
+    tool_call_idx = 0
+    for _i, item in enumerate(obj):
+        if item.type == "message":
+            prefix = f"{GEN_AI_OUTPUT_MESSAGES_KEY}.{msg_idx}."
+            yield from _get_attributes_from_message(item, prefix)
+            msg_idx += 1
+        elif item.type == "function_call":
+            yield f"{GEN_AI_OUTPUT_MESSAGES_KEY}.{msg_idx}.{GEN_AI_MESSAGE_ROLE}", "assistant"
+            prefix = f"{GEN_AI_OUTPUT_MESSAGES_KEY}.{msg_idx}.{GEN_AI_MESSAGE_TOOL_CALLS}.{tool_call_idx}."
+            yield from _get_attributes_from_function_tool_call(item, prefix)
+            tool_call_idx += 1
+        elif item.type == "custom_tool_call":
+            yield f"{prefix}{GEN_AI_MESSAGE_ROLE}", "assistant"
+            yield from _get_attributes_from_response_custom_tool_call(
+                item,
+                f"{prefix}{GEN_AI_MESSAGE_TOOL_CALLS}.0.",
+            )
+        elif TYPE_CHECKING:
+            assert_never(item)
+
+
+def _get_attributes_from_response_instruction(
+    instructions: str | None,
+) -> Iterator[tuple[str, AttributeValue]]:
+    if not instructions:
+        return
+    yield f"{GEN_AI_INPUT_MESSAGES_KEY}.0.{GEN_AI_MESSAGE_ROLE}", "system"
+    yield f"{GEN_AI_INPUT_MESSAGES_KEY}.0.{GEN_AI_OUTPUT_MESSAGES_KEY}", instructions
+
+
+def _get_attributes_from_function_tool_call(
+    obj: ResponseFunctionToolCall,
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    yield f"{prefix}{GEN_AI_TOOL_CALL_ID_KEY}", obj.call_id
+    yield f"{prefix}{GEN_AI_TOOL_NAME_KEY}", obj.name
+    if obj.arguments != "{}":
+        yield f"{prefix}{GEN_AI_TOOL_ARGS_KEY}", obj.arguments
+
+
+def _get_attributes_from_response_custom_tool_call(
+    obj: ResponseCustomToolCall,
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    if (call_id := obj.call_id) is not None:
+        yield f"{prefix}{GEN_AI_TOOL_CALL_ID_KEY}", call_id
+    if (name := obj.name) is not None:
+        yield f"{prefix}{GEN_AI_TOOL_NAME_KEY}", name
+    if (input_data := obj.input) is not None:
+        yield (
+            f"{prefix}{GEN_AI_TOOL_ARGS_KEY}",
+            safe_json_dumps({"input": input_data}),
+        )
+
+
+def _get_attributes_from_message(
+    obj: ResponseOutputMessage,
+    prefix: str = "",
+) -> Iterator[tuple[str, AttributeValue]]:
+    yield f"{prefix}{GEN_AI_MESSAGE_ROLE}", obj.role
+    for i, item in enumerate(obj.content):
+        if isinstance(item, ResponseOutputText):
+            yield f"{prefix}{GEN_AI_OUTPUT_MESSAGES_KEY}.{i}.{GEN_AI_MESSAGE_CONTENT_TYPE}", "text"
+            yield (
+                f"{prefix}{GEN_AI_OUTPUT_MESSAGES_KEY}.{i}.{GEN_AI_OUTPUT_MESSAGES_KEY}",
+                item.text,
+            )
+        elif isinstance(item, ResponseOutputRefusal):
+            yield f"{prefix}{GEN_AI_OUTPUT_MESSAGES_KEY}.{i}.{GEN_AI_MESSAGE_CONTENT_TYPE}", "text"
+            yield (
+                f"{prefix}{GEN_AI_OUTPUT_MESSAGES_KEY}.{i}.{GEN_AI_OUTPUT_MESSAGES_KEY}",
+                item.refusal,
+            )
+        elif TYPE_CHECKING:
+            assert_never(item)
+
+
+def get_attributes_from_usage(
+    obj: ResponseUsage | None,
+) -> Iterator[tuple[str, AttributeValue]]:
+    if not obj:
+        return
+    yield GEN_AI_USAGE_OUTPUT_TOKENS_KEY, obj.output_tokens
+    yield GEN_AI_USAGE_INPUT_TOKENS_KEY, obj.input_tokens
+    yield GEN_AI_LLM_TOKEN_COUNT_TOTAL, obj.total_tokens
+    yield GEN_AI_LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHED_READ, obj.input_tokens_details.cached_tokens
+    yield (
+        GEN_AI_LLM_TOKEN_COUNT_COMPLETION_DETAILS_REASONING,
+        obj.output_tokens_details.reasoning_tokens,
+    )
+
+
+def get_span_status(obj: Span[Any]) -> Status:
+    if error := getattr(obj, "error", None):
+        return Status(
+            status_code=StatusCode.ERROR, description=f"{error.get('message')}: {error.get('data')}"
+        )
+    else:
+        return Status(StatusCode.OK)

microsoft_agents_a365_observability_extensions_openai-0.1.0.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: microsoft-agents-a365-observability-extensions-openai
+Version: 0.1.0
+Summary: OpenAI Agents SDK observability and tracing extensions for Microsoft Agent 365
+Author-email: Microsoft <support@microsoft.com>
+License: MIT
+Project-URL: Homepage, https://github.com/microsoft/Agent365-python
+Project-URL: Repository, https://github.com/microsoft/Agent365-python
+Project-URL: Issues, https://github.com/microsoft/Agent365-python/issues
+Project-URL: Documentation, https://github.com/microsoft/Agent365-python/tree/main/libraries/microsoft-agents-a365-observability-extensions-openai
+Keywords: observability,telemetry,tracing,opentelemetry,openai,agents,ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: microsoft-agents-a365-observability-core>=0.0.0
+Requires-Dist: openai-agents>=0.2.6
+Requires-Dist: opentelemetry-api>=1.36.0
+Requires-Dist: opentelemetry-sdk>=1.36.0
+Requires-Dist: opentelemetry-instrumentation>=0.47b0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+
+# microsoft-agents-a365-observability-extensions-openai
+
+[![PyPI](https://img.shields.io/pypi/v/microsoft-agents-a365-observability-extensions-openai?label=PyPI&logo=pypi)](https://pypi.org/project/microsoft-agents-a365-observability-extensions-openai)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/microsoft-agents-a365-observability-extensions-openai?label=Downloads&logo=pypi)](https://pypi.org/project/microsoft-agents-a365-observability-extensions-openai)
+
+Observability extensions for OpenAI Agents SDK. This package provides OpenTelemetry tracing integration for OpenAI Agents-based applications with automatic instrumentation for agent workflows and tool invocations.
+
+## Installation
+
+```bash
+pip install microsoft-agents-a365-observability-extensions-openai
+```
+
+## Usage
+
+For usage examples and detailed documentation, see the [Observability documentation](https://learn.microsoft.com/microsoft-agent-365/developer/observability?tabs=python) on Microsoft Learn.
+
+## Support
+
+For issues, questions, or feedback:
+
+- File issues in the [GitHub Issues](https://github.com/microsoft/Agent365-python/issues) section
+- See the [main documentation](../../../README.md) for more information
+ 
+## Trademarks
+ 
+*Microsoft, Windows, Microsoft Azure and/or other Microsoft products and services referenced in the documentation may be either trademarks or registered trademarks of Microsoft in the United States and/or other countries. The licenses for this project do not grant you rights to use any Microsoft names, logos, or trademarks. Microsoft's general trademark guidelines can be found at http://go.microsoft.com/fwlink/?LinkID=254653.*
+
+## License
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the MIT License - see the [LICENSE](../../../LICENSE.md) file for details.

microsoft_agents_a365_observability_extensions_openai-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+microsoft_agents_a365/observability/extensions/openai/__init__.py,sha256=C525c5EXggrjZp2rbQGtak2S5u4I3TC9rYZWxh1MRR8,262
+microsoft_agents_a365/observability/extensions/openai/constants.py,sha256=eAptrhnCpRx0PnCEr_HmmdaHt9CYDLbPwzSDtAy3NSM,1511
+microsoft_agents_a365/observability/extensions/openai/trace_instrumentor.py,sha256=qvZY7vwDfD4n0sRu06VMGhX2UUqxyiXyQj_yEfSGIeQ,2450
+microsoft_agents_a365/observability/extensions/openai/trace_processor.py,sha256=aOP6uEz0ECX4C4wu1GUW-TkHVMKzMWMc00nziOhIsVA,7973
+microsoft_agents_a365/observability/extensions/openai/utils.py,sha256=xi7akBeJHnj5F6ayJCUUZS0SRwWJYjOKeMv0p0zwBeo,19607
+microsoft_agents_a365_observability_extensions_openai-0.1.0.dist-info/METADATA,sha256=T29kR5x9GAEExWVGXzWK6U-y12J2pmK-9oAGDpE6Cv4,3627
+microsoft_agents_a365_observability_extensions_openai-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+microsoft_agents_a365_observability_extensions_openai-0.1.0.dist-info/top_level.txt,sha256=G3c2_4sy5_EM_BWO67SbK2tKj4G8XFn-QXRbh8g9Lgk,22
+microsoft_agents_a365_observability_extensions_openai-0.1.0.dist-info/RECORD,,

microsoft_agents_a365_observability_extensions_openai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

microsoft_agents_a365_observability_extensions_openai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+microsoft_agents_a365