microsoft-agents-a365-observability-core 0.1.0__py3-none-any.whl

microsoft_agents_a365/observability/core/models/agent_type.py

@@ -0,0 +1,25 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from enum import Enum
+
+
+class AgentType(Enum):
+    """
+    Supported agent types for generative AI.
+    """
+
+    ENTRA_EMBODIED = "EntraEmbodied"
+    """Entra embodied agent."""
+
+    ENTRA_NON_EMBODIED = "EntraNonEmbodied"
+    """Entra non-embodied agent."""
+
+    MICROSOFT_COPILOT = "MicrosoftCopilot"
+    """Microsoft Copilot agent."""
+
+    DECLARATIVE_AGENT = "DeclarativeAgent"
+    """Declarative agent."""
+
+    FOUNDRY = "Foundry"
+    """Foundry agent."""

microsoft_agents_a365/observability/core/models/caller_details.py

@@ -0,0 +1,25 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class CallerDetails:
+    """Details about the caller that invoked an agent."""
+
+    caller_id: Optional[str] = None
+    """The unique identifier for the caller."""
+
+    caller_upn: Optional[str] = None
+    """The User Principal Name (UPN) of the caller."""
+
+    caller_name: Optional[str] = None
+    """The human-readable name of the caller."""
+
+    caller_user_id: Optional[str] = None
+    """The user ID of the caller."""
+
+    tenant_id: Optional[str] = None
+    """The tenant ID of the caller."""

microsoft_agents_a365/observability/core/opentelemetry_scope.py

@@ -0,0 +1,250 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Base class for OpenTelemetry tracing scopes.
+
+import logging
+import os
+import time
+from threading import Lock
+from typing import TYPE_CHECKING, Any
+
+from opentelemetry import baggage, context, trace
+from opentelemetry.trace import Span, SpanKind, Status, StatusCode, Tracer, set_span_in_context
+
+from .constants import (
+    ENABLE_A365_OBSERVABILITY,
+    ENABLE_OBSERVABILITY,
+    ERROR_TYPE_KEY,
+    GEN_AI_AGENT_AUID_KEY,
+    GEN_AI_AGENT_BLUEPRINT_ID_KEY,
+    GEN_AI_AGENT_DESCRIPTION_KEY,
+    GEN_AI_AGENT_ID_KEY,
+    GEN_AI_AGENT_NAME_KEY,
+    GEN_AI_AGENT_TYPE_KEY,
+    GEN_AI_AGENT_UPN_KEY,
+    GEN_AI_CONVERSATION_ID_KEY,
+    GEN_AI_EVENT_CONTENT,
+    GEN_AI_ICON_URI_KEY,
+    GEN_AI_OPERATION_NAME_KEY,
+    GEN_AI_SYSTEM_KEY,
+    GEN_AI_SYSTEM_VALUE,
+    SOURCE_NAME,
+    TENANT_ID_KEY,
+)
+
+if TYPE_CHECKING:
+    from .agent_details import AgentDetails
+    from .tenant_details import TenantDetails
+
+# Create logger for this module - inherits from 'microsoft_agents_a365.observability.core'
+logger = logging.getLogger(__name__)
+
+
+class OpenTelemetryScope:
+    """Base class for OpenTelemetry tracing scopes in the SDK."""
+
+    _tracer: Tracer | None = None
+    _tracer_lock = Lock()
+
+    @classmethod
+    def _get_tracer(cls) -> Tracer:
+        """Get the tracer instance, creating it if necessary."""
+        if cls._tracer is None:
+            with cls._tracer_lock:
+                if cls._tracer is None:
+                    cls._tracer = trace.get_tracer(SOURCE_NAME)
+        return cls._tracer
+
+    @classmethod
+    def _is_telemetry_enabled(cls) -> bool:
+        """Check if telemetry is enabled."""
+        # Check environment variable
+        env_value = os.getenv(ENABLE_OBSERVABILITY, "").lower()
+        enable_observability = os.getenv(ENABLE_A365_OBSERVABILITY, "").lower()
+        return (env_value or enable_observability) in ("true", "1", "yes", "on")
+
+    def __init__(
+        self,
+        kind: str,
+        operation_name: str,
+        activity_name: str,
+        agent_details: "AgentDetails | None" = None,
+        tenant_details: "TenantDetails | None" = None,
+    ):
+        """Initialize the OpenTelemetry scope.
+
+        Args:
+            kind: The kind of activity (Client, Server, Internal, etc.)
+            operation_name: The name of the operation being traced
+            activity_name: The name of the activity for display purposes
+            agent_details: Optional agent details
+            tenant_details: Optional tenant details
+        """
+        self._span: Span | None = None
+        self._start_time = time.time()
+        self._has_ended = False
+        self._error_type: str | None = None
+        self._exception: Exception | None = None
+        self._context_token = None
+
+        if self._is_telemetry_enabled():
+            tracer = self._get_tracer()
+
+            # Map string kind to SpanKind enum
+            activity_kind = SpanKind.INTERNAL
+            if kind.lower() == "client":
+                activity_kind = SpanKind.CLIENT
+            elif kind.lower() == "server":
+                activity_kind = SpanKind.SERVER
+            elif kind.lower() == "producer":
+                activity_kind = SpanKind.PRODUCER
+            elif kind.lower() == "consumer":
+                activity_kind = SpanKind.CONSUMER
+
+            # Get current context for parent relationship
+            current_context = context.get_current()
+
+            self._span = tracer.start_span(
+                activity_name, kind=activity_kind, context=current_context
+            )
+
+            # Log span creation
+            if self._span:
+                span_id = f"{self._span.context.span_id:016x}" if self._span.context else "unknown"
+                logger.info(f"Span started: '{activity_name}' ({span_id})")
+            else:
+                logger.error(f"Failed to create span: '{activity_name}' - tracer returned None")
+
+            # Set common tags
+            if self._span:
+                self._span.set_attribute(GEN_AI_SYSTEM_KEY, GEN_AI_SYSTEM_VALUE)
+                self._span.set_attribute(GEN_AI_OPERATION_NAME_KEY, operation_name)
+
+                # Set agent details if provided
+                if agent_details:
+                    self.set_tag_maybe(GEN_AI_AGENT_ID_KEY, agent_details.agent_id)
+                    self.set_tag_maybe(GEN_AI_AGENT_NAME_KEY, agent_details.agent_name)
+                    self.set_tag_maybe(
+                        GEN_AI_AGENT_DESCRIPTION_KEY, agent_details.agent_description
+                    )
+                    self.set_tag_maybe(GEN_AI_AGENT_AUID_KEY, agent_details.agent_auid)
+                    self.set_tag_maybe(GEN_AI_AGENT_UPN_KEY, agent_details.agent_upn)
+                    self.set_tag_maybe(
+                        GEN_AI_AGENT_BLUEPRINT_ID_KEY, agent_details.agent_blueprint_id
+                    )
+                    self.set_tag_maybe(
+                        GEN_AI_AGENT_TYPE_KEY,
+                        agent_details.agent_type.value if agent_details.agent_type else None,
+                    )
+                    self.set_tag_maybe(TENANT_ID_KEY, agent_details.tenant_id)
+                    self.set_tag_maybe(GEN_AI_CONVERSATION_ID_KEY, agent_details.conversation_id)
+                    self.set_tag_maybe(GEN_AI_ICON_URI_KEY, agent_details.icon_uri)
+
+                # Set tenant details if provided
+                if tenant_details:
+                    self.set_tag_maybe(TENANT_ID_KEY, str(tenant_details.tenant_id))
+
+    def record_error(self, exception: Exception) -> None:
+        """Record an error in the span.
+
+        Args:
+            exception: The exception that occurred
+        """
+        if self._span and self._is_telemetry_enabled():
+            self._error_type = type(exception).__name__
+            self._exception = exception
+            self._span.set_attribute(ERROR_TYPE_KEY, self._error_type)
+            self._span.record_exception(exception)
+            self._span.set_status(Status(StatusCode.ERROR, str(exception)))
+
+    def record_response(self, response: str) -> None:
+        """Record an response in the span.
+
+        Args:
+            response: The response content to record
+        """
+        if self._span and self._is_telemetry_enabled():
+            self._span.set_attribute(GEN_AI_EVENT_CONTENT, response)
+
+    def record_cancellation(self) -> None:
+        """Record task cancellation."""
+        if self._span and self._is_telemetry_enabled():
+            self._error_type = "TaskCanceledException"
+            self._span.set_attribute(ERROR_TYPE_KEY, self._error_type)
+            self._span.set_status(Status(StatusCode.ERROR, "Task was cancelled"))
+
+    def set_tag_maybe(self, name: str, value: Any) -> None:
+        """Set a tag on the span if the value is not None.
+
+        Args:
+            name: The name of the tag
+            value: The value to set (will be skipped if None)
+        """
+        if value is not None and self._span and self._is_telemetry_enabled():
+            self._span.set_attribute(name, value)
+
+    def add_baggage(self, key: str, value: str) -> None:
+        """Add baggage to the current context.
+
+        Args:
+            key: The baggage key
+            value: The baggage value
+        """
+        # Set baggage in the current context
+        if self._is_telemetry_enabled():
+            # Set baggage on the current context
+            # This will be inherited by child spans created within this context
+            baggage_context = baggage.set_baggage(key, value)
+            # The context needs to be made current for child spans to inherit the baggage
+            context.attach(baggage_context)
+
+    def record_attributes(self, attributes: dict[str, Any] | list[tuple[str, Any]]) -> None:
+        """Record multiple attribute key/value pairs for telemetry tracking.
+
+        This method allows setting multiple custom attributes on the span at once.
+
+        Args:
+            attributes: Dictionary or list of tuples containing attribute key-value pairs.
+                       Keys that are None or empty will be skipped.
+        """
+        if not self._is_telemetry_enabled() or self._span is None:
+            return
+
+        # Handle both dict and list of tuples
+        items = attributes.items() if isinstance(attributes, dict) else attributes
+
+        for key, value in items:
+            if key and key.strip():
+                self._span.set_attribute(key, value)
+
+    def _end(self) -> None:
+        """End the span and record metrics."""
+        if self._span and self._is_telemetry_enabled() and not self._has_ended:
+            self._has_ended = True
+            span_id = f"{self._span.context.span_id:016x}" if self._span.context else "unknown"
+            logger.info(f"Span ended: '{self._span.name}' ({span_id})")
+
+            self._span.end()
+
+    def __enter__(self):
+        """Enter the context manager and make span active."""
+        if self._span and self._is_telemetry_enabled():
+            # Make this span the active span in the current context
+            new_context = set_span_in_context(self._span)
+            self._context_token = context.attach(new_context)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the context manager and restore previous context."""
+        try:
+            if exc_type is not None and exc_val is not None:
+                self.record_error(exc_val)
+        finally:
+            # Restore previous context
+            if self._context_token is not None:
+                context.detach(self._context_token)
+            self._end()
+
+    def dispose(self) -> None:
+        """Dispose the scope and finalize telemetry data collection."""
+        self._end()

microsoft_agents_a365/observability/core/request.py

@@ -0,0 +1,19 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Request class.
+
+from dataclasses import dataclass
+
+from .execution_type import ExecutionType
+from .source_metadata import SourceMetadata
+
+
+@dataclass
+class Request:
+    """Request details for agent execution."""
+
+    content: str
+    execution_type: ExecutionType
+    session_id: str | None = None
+    source_metadata: SourceMetadata | None = None
+    payload: str | None = None

microsoft_agents_a365/observability/core/source_metadata.py

@@ -0,0 +1,15 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Source metadata class.
+
+from dataclasses import dataclass
+
+
+@dataclass
+class SourceMetadata:
+    """Source metadata for agent execution context."""
+
+    id: str | None = None
+    name: str | None = None
+    icon_uri: str | None = None
+    description: str | None = None

microsoft_agents_a365/observability/core/tenant_details.py

@@ -0,0 +1,11 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Tenant details class.
+from dataclasses import dataclass
+
+
+@dataclass
+class TenantDetails:
+    """Represents the tenant id attached to the span."""
+
+    tenant_id: str

microsoft_agents_a365/observability/core/tool_call_details.py

@@ -0,0 +1,18 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Data class for tool call details.
+
+from dataclasses import dataclass
+from urllib.parse import ParseResult
+
+
+@dataclass
+class ToolCallDetails:
+    """Details of a tool call made by an agent in the system."""
+
+    tool_name: str
+    arguments: str | None = None
+    tool_call_id: str | None = None
+    description: str | None = None
+    tool_type: str | None = None
+    endpoint: ParseResult | None = None

microsoft_agents_a365/observability/core/tool_type.py

@@ -0,0 +1,13 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Tool type enum.
+
+from enum import Enum
+
+
+class ToolType(Enum):
+    """Enumeration for different tool types for execute tool contexts."""
+
+    FUNCTION = "function"
+    EXTENSION = "extension"
+    DATASTORE = "datastore"

microsoft_agents_a365/observability/core/trace_processor/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""
+Trace Processors
+"""
+
+from .span_processor import SpanProcessor
+
+# Export public API
+__all__ = [
+    # Span processor
+    "SpanProcessor",
+]

microsoft_agents_a365/observability/core/trace_processor/span_processor.py

@@ -0,0 +1,75 @@
+"""Copyright (c) Microsoft. All rights reserved.
+
+Span processor for copying OpenTelemetry baggage entries onto spans.
+
+This implementation assumes `opentelemetry.baggage.get_all` is available with the
+signature `get_all(context: Context | None) -> Mapping[str, object]`.
+
+For every new span:
+  * Retrieve the current (or parent) context
+  * Obtain all baggage entries via `baggage.get_all`
+  * For each (key, value) pair with a truthy value not already present as a span
+    attribute, add it via `span.set_attribute`
+  * Never overwrites existing attributes
+"""
+
+from opentelemetry import baggage, context
+from opentelemetry.sdk.trace import SpanProcessor as BaseSpanProcessor
+
+from ..constants import GEN_AI_OPERATION_NAME_KEY, INVOKE_AGENT_OPERATION_NAME
+from .util import COMMON_ATTRIBUTES, INVOKE_AGENT_ATTRIBUTES
+
+
+class SpanProcessor(BaseSpanProcessor):
+    """Span processor that propagates every baggage key/value to span attributes."""
+
+    def __init__(self):
+        super().__init__()
+
+    def on_start(self, span, parent_context=None):
+        ctx = parent_context or context.get_current()
+        if ctx is None:
+            return super().on_start(span, parent_context)
+
+        try:
+            existing = getattr(span, "attributes", {}) or {}
+        except Exception:
+            existing = {}
+
+        try:
+            baggage_map = baggage.get_all(ctx) or {}
+        except Exception:
+            baggage_map = {}
+
+        operation_name = existing.get(GEN_AI_OPERATION_NAME_KEY)
+        is_invoke_agent = False
+        if operation_name == INVOKE_AGENT_OPERATION_NAME:
+            is_invoke_agent = True
+        elif isinstance(getattr(span, "name", None), str) and span.name.startswith(
+            INVOKE_AGENT_OPERATION_NAME
+        ):
+            is_invoke_agent = True
+
+        # Build target key set (avoid duplicates).
+        target_keys = list(COMMON_ATTRIBUTES)
+        if is_invoke_agent:
+            # Add invoke-agent-only attributes
+            for k in INVOKE_AGENT_ATTRIBUTES:
+                if k not in target_keys:
+                    target_keys.append(k)
+
+        for key in target_keys:
+            if key in existing:
+                continue
+            value = baggage_map.get(key)
+            if not value:
+                continue
+            try:
+                span.set_attribute(key, value)
+            except Exception:
+                continue
+
+        return super().on_start(span, parent_context)
+
+    def on_end(self, span):
+        super().on_end(span)

microsoft_agents_a365/observability/core/trace_processor/util.py

@@ -0,0 +1,44 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from .. import constants as consts
+
+# Generic / common tracing attributes
+COMMON_ATTRIBUTES = [
+    consts.TENANT_ID_KEY,  # tenant.id
+    consts.CUSTOM_PARENT_SPAN_ID_KEY,  # custom.parent.span.id
+    consts.CUSTOM_SPAN_NAME_KEY,  # custom.span.name
+    consts.CORRELATION_ID_KEY,  # correlation.id
+    consts.GEN_AI_CONVERSATION_ID_KEY,  # conversation.id
+    consts.GEN_AI_CONVERSATION_ITEM_LINK_KEY,  # conversation.itemLink
+    consts.GEN_AI_OPERATION_NAME_KEY,  # gen_ai.operation.name
+    consts.GEN_AI_AGENT_ID_KEY,  # gen_ai.agent.id
+    consts.GEN_AI_AGENT_NAME_KEY,  # gen_ai.agent.name
+    consts.GEN_AI_AGENT_DESCRIPTION_KEY,  # gen_ai.agent.description
+    consts.GEN_AI_AGENT_USER_ID_KEY,  # gen_ai.agent.userid
+    consts.GEN_AI_AGENT_UPN_KEY,  # gen_ai.agent.upn
+    consts.GEN_AI_AGENT_BLUEPRINT_ID_KEY,  # gen_ai.agent.applicationid
+    consts.GEN_AI_AGENT_AUID_KEY,
+    consts.GEN_AI_AGENT_TYPE_KEY,
+]
+
+# Invoke Agent–specific attributes
+INVOKE_AGENT_ATTRIBUTES = [
+    # Caller / Invoker attributes
+    consts.GEN_AI_CALLER_ID_KEY,  # gen_ai.caller.id
+    consts.GEN_AI_CALLER_NAME_KEY,  # gen_ai.caller.name
+    consts.GEN_AI_CALLER_UPN_KEY,  # gen_ai.caller.upn
+    consts.GEN_AI_CALLER_USER_ID_KEY,  # gen_ai.caller.userid
+    consts.GEN_AI_CALLER_TENANT_ID_KEY,  # gen_ai.caller.tenantid
+    # Caller Agent (A2A) attributes
+    consts.GEN_AI_CALLER_AGENT_ID_KEY,  # gen_ai.caller.agent.id
+    consts.GEN_AI_CALLER_AGENT_NAME_KEY,  # gen_ai.caller.agent.name
+    consts.GEN_AI_CALLER_AGENT_USER_ID_KEY,  # gen_ai.caller.agent.userid
+    consts.GEN_AI_CALLER_AGENT_UPN_KEY,  # gen_ai.caller.agent.upn
+    consts.GEN_AI_CALLER_AGENT_TENANT_ID_KEY,  # gen_ai.caller.agent.tenantid
+    consts.GEN_AI_CALLER_AGENT_APPLICATION_ID_KEY,  # gen_ai.caller.agent.applicationid
+    # Execution context
+    consts.GEN_AI_EXECUTION_TYPE_KEY,  # gen_ai.execution.type
+    consts.GEN_AI_EXECUTION_SOURCE_ID_KEY,  # gen_ai.execution.sourceMetadata.id
+    consts.GEN_AI_EXECUTION_SOURCE_NAME_KEY,  # gen_ai.execution.sourceMetadata.name
+    consts.GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY,  # gen_ai.execution.sourceMetadata.description
+]

microsoft_agents_a365/observability/core/utils.py

@@ -0,0 +1,151 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import datetime
+import json
+import logging
+import traceback
+from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping
+from enum import Enum
+from threading import RLock
+from typing import Any, Generic, TypeVar, cast
+
+from opentelemetry.semconv.trace import SpanAttributes as OTELSpanAttributes
+from opentelemetry.trace import Span
+from opentelemetry.util.types import AttributeValue
+from wrapt import ObjectProxy
+
+from microsoft_agents_a365.observability.core.constants import ERROR_TYPE_KEY
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+def safe_json_dumps(obj: Any, **kwargs: Any) -> str:
+    return json.dumps(obj, default=str, ensure_ascii=False, **kwargs)
+
+
+def as_utc_nano(dt: datetime.datetime) -> int:
+    return int(dt.astimezone(datetime.UTC).timestamp() * 1_000_000_000)
+
+
+KeyType = TypeVar("KeyType")
+ValueType = TypeVar("ValueType")
+
+
+def get_first_value(
+    mapping: Mapping[KeyType, ValueType], keys: Iterable[KeyType]
+) -> ValueType | None:
+    """
+    Returns the first non-null value corresponding to an input key, or None if
+    no non-null value is found.
+    """
+    if not hasattr(mapping, "get"):
+        return None
+    return next(
+        (value for key in keys if (value := mapping.get(key)) is not None),
+        None,
+    )
+
+
+def stop_on_exception(
+    wrapped: Callable[..., Iterator[tuple[str, Any]]],
+) -> Callable[..., Iterator[tuple[str, Any]]]:
+    def wrapper(*args: Any, **kwargs: Any) -> Iterator[tuple[str, Any]]:
+        try:
+            yield from wrapped(*args, **kwargs)
+        except Exception:
+            logger.exception("Failed to get attribute.")
+
+    return wrapper
+
+
+def record_exception(span: Span, error: BaseException) -> None:
+    if isinstance(error, Exception):
+        span.record_exception(error)
+        return
+    exception_type = error.__class__.__name__
+    exception_message = str(error)
+    if not exception_message:
+        exception_message = repr(error)
+    attributes: dict[str, AttributeValue] = {
+        ERROR_TYPE_KEY: exception_type,
+        OTELSpanAttributes.EXCEPTION_MESSAGE: exception_message,
+    }
+    try:
+        attributes[OTELSpanAttributes.EXCEPTION_STACKTRACE] = traceback.format_exc()
+    except Exception:
+        logger.exception("Failed to record exception stacktrace.")
+    span.add_event(name="exception", attributes=attributes)
+
+
+@stop_on_exception
+def flatten(key_values: Iterable[tuple[str, Any]]) -> Iterator[tuple[str, AttributeValue]]:
+    for key, value in key_values:
+        if value is None:
+            continue
+        if isinstance(value, Mapping):
+            for sub_key, sub_value in flatten(value.items()):
+                yield f"{key}.{sub_key}", sub_value
+        elif isinstance(value, list) and any(isinstance(item, Mapping) for item in value):
+            for index, sub_mapping in enumerate(value):
+                for sub_key, sub_value in flatten(sub_mapping.items()):
+                    yield f"{key}.{index}.{sub_key}", sub_value
+        else:
+            if isinstance(value, Enum):
+                value = value.value
+            yield key, value
+
+
+K = TypeVar("K", bound=Hashable)
+V = TypeVar("V")
+
+
+class DictWithLock(ObjectProxy, Generic[K, V]):  # type: ignore
+    """
+    A wrapped dictionary with lock
+    """
+
+    def __init__(self, wrapped: dict[str, V] | None = None) -> None:
+        super().__init__(wrapped or {})
+        self._self_lock = RLock()
+
+    def get(self, key: K) -> V | None:
+        with self._self_lock:
+            return cast(V | None, self.__wrapped__.get(key))
+
+    def pop(self, key: K, *args: Any) -> V | None:
+        with self._self_lock:
+            return cast(V | None, self.__wrapped__.pop(key, *args))
+
+    def __getitem__(self, key: K) -> V:
+        with self._self_lock:
+            return cast(V, super().__getitem__(key))
+
+    def __setitem__(self, key: K, value: V) -> None:
+        with self._self_lock:
+            super().__setitem__(key, value)
+
+    def __delitem__(self, key: K) -> None:
+        with self._self_lock:
+            super().__delitem__(key)
+
+
+def extract_model_name(span_name: str) -> str | None:
+    """
+    Extract model name from span names like:
+    - 'chat.completions gpt-4o-mini' -> 'gpt-4o-mini'
+    - 'chat.completions gpt-3.5-turbo' -> 'gpt-3.5-turbo'
+    - 'chat.completions' -> None
+    """
+    parts = span_name.split(" ")
+
+    if len(parts) == 2:
+        return parts[1]
+    # If we have more than 2 parts, the model name starts from the 3rd part
+    # Format: "chat.completions model-name" or "chat.completions model-name-with-dashes"
+    elif len(parts) >= 3:
+        # Join everything after "chat.completions" to handle model names with spaces/dashes
+        model_name = " ".join(parts[2:])
+        return model_name.strip()
+
+    return None