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

microsoft_agents_a365/observability/core/invoke_agent_scope.py

@@ -0,0 +1,166 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+# Invoke agent scope for tracing agent invocation.
+
+from .agent_details import AgentDetails
+from .constants import (
+    GEN_AI_CALLER_AGENT_APPLICATION_ID_KEY,
+    GEN_AI_CALLER_AGENT_ID_KEY,
+    GEN_AI_CALLER_AGENT_NAME_KEY,
+    GEN_AI_CALLER_AGENT_TENANT_ID_KEY,
+    GEN_AI_CALLER_AGENT_UPN_KEY,
+    GEN_AI_CALLER_AGENT_USER_ID_KEY,
+    GEN_AI_CALLER_ID_KEY,
+    GEN_AI_CALLER_NAME_KEY,
+    GEN_AI_CALLER_TENANT_ID_KEY,
+    GEN_AI_CALLER_UPN_KEY,
+    GEN_AI_CALLER_USER_ID_KEY,
+    GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY,
+    GEN_AI_EXECUTION_SOURCE_ID_KEY,
+    GEN_AI_EXECUTION_SOURCE_NAME_KEY,
+    GEN_AI_EXECUTION_TYPE_KEY,
+    GEN_AI_INPUT_MESSAGES_KEY,
+    GEN_AI_OUTPUT_MESSAGES_KEY,
+    INVOKE_AGENT_OPERATION_NAME,
+    SERVER_ADDRESS_KEY,
+    SERVER_PORT_KEY,
+    SESSION_ID_KEY,
+)
+from .invoke_agent_details import InvokeAgentDetails
+from .models.caller_details import CallerDetails
+from .opentelemetry_scope import OpenTelemetryScope
+from .request import Request
+from .tenant_details import TenantDetails
+from .utils import safe_json_dumps
+
+
+class InvokeAgentScope(OpenTelemetryScope):
+    """Provides OpenTelemetry tracing scope for AI agent invocation operations."""
+
+    @staticmethod
+    def start(
+        invoke_agent_details: InvokeAgentDetails,
+        tenant_details: TenantDetails,
+        request: Request | None = None,
+        caller_agent_details: AgentDetails | None = None,
+        caller_details: CallerDetails | None = None,
+    ) -> "InvokeAgentScope":
+        """Create and start a new scope for agent invocation tracing.
+
+        Args:
+            invoke_agent_details: The details of the agent invocation including endpoint,
+                                agent information, and session context
+            tenant_details: The details of the tenant
+            request: Optional request details for additional context
+            caller_agent_details: Optional details of the caller agent
+            caller_details: Optional details of the non-agentic caller
+
+        Returns:
+            A new InvokeAgentScope instance
+        """
+        return InvokeAgentScope(
+            invoke_agent_details, tenant_details, request, caller_agent_details, caller_details
+        )
+
+    def __init__(
+        self,
+        invoke_agent_details: InvokeAgentDetails,
+        tenant_details: TenantDetails,
+        request: Request | None = None,
+        caller_agent_details: AgentDetails | None = None,
+        caller_details: CallerDetails | None = None,
+    ):
+        """Initialize the agent invocation scope.
+
+        Args:
+            invoke_agent_details: The details of the agent invocation
+            tenant_details: The details of the tenant
+            request: Optional request details for additional context
+            caller_agent_details: Optional details of the caller agent
+            caller_details: Optional details of the non-agentic caller
+        """
+        activity_name = INVOKE_AGENT_OPERATION_NAME
+        if invoke_agent_details.details.agent_name:
+            activity_name = (
+                f"{INVOKE_AGENT_OPERATION_NAME} {invoke_agent_details.details.agent_name}"
+            )
+
+        super().__init__(
+            kind="Client",
+            operation_name=INVOKE_AGENT_OPERATION_NAME,
+            activity_name=activity_name,
+            agent_details=invoke_agent_details.details,
+            tenant_details=tenant_details,
+        )
+
+        endpoint, _, session_id = (
+            invoke_agent_details.endpoint,
+            invoke_agent_details.details,
+            invoke_agent_details.session_id,
+        )
+
+        self.set_tag_maybe(SESSION_ID_KEY, session_id)
+        if endpoint:
+            self.set_tag_maybe(SERVER_ADDRESS_KEY, endpoint.hostname)
+
+            # Only record port if it is different from 443
+            if endpoint.port and endpoint.port != 443:
+                self.set_tag_maybe(SERVER_PORT_KEY, endpoint.port)
+
+        # Set request metadata if provided
+        if request:
+            if request.source_metadata:
+                self.set_tag_maybe(GEN_AI_EXECUTION_SOURCE_ID_KEY, request.source_metadata.id)
+                self.set_tag_maybe(GEN_AI_EXECUTION_SOURCE_NAME_KEY, request.source_metadata.name)
+                self.set_tag_maybe(
+                    GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY, request.source_metadata.description
+                )
+
+            self.set_tag_maybe(
+                GEN_AI_EXECUTION_TYPE_KEY,
+                request.execution_type.value if request.execution_type else None,
+            )
+
+        # Set caller details tags
+        if caller_details:
+            self.set_tag_maybe(GEN_AI_CALLER_ID_KEY, caller_details.caller_id)
+            self.set_tag_maybe(GEN_AI_CALLER_UPN_KEY, caller_details.caller_upn)
+            self.set_tag_maybe(GEN_AI_CALLER_NAME_KEY, caller_details.caller_name)
+            self.set_tag_maybe(GEN_AI_CALLER_USER_ID_KEY, caller_details.caller_user_id)
+            self.set_tag_maybe(GEN_AI_CALLER_TENANT_ID_KEY, caller_details.tenant_id)
+
+        # Set caller agent details tags
+        if caller_agent_details:
+            self.set_tag_maybe(GEN_AI_CALLER_AGENT_NAME_KEY, caller_agent_details.agent_name)
+            self.set_tag_maybe(GEN_AI_CALLER_AGENT_ID_KEY, caller_agent_details.agent_id)
+            self.set_tag_maybe(
+                GEN_AI_CALLER_AGENT_APPLICATION_ID_KEY, caller_agent_details.agent_blueprint_id
+            )
+            self.set_tag_maybe(GEN_AI_CALLER_AGENT_USER_ID_KEY, caller_agent_details.agent_auid)
+            self.set_tag_maybe(GEN_AI_CALLER_AGENT_UPN_KEY, caller_agent_details.agent_upn)
+            self.set_tag_maybe(GEN_AI_CALLER_AGENT_TENANT_ID_KEY, caller_agent_details.tenant_id)
+
+    def record_response(self, response: str) -> None:
+        """Record response information for telemetry tracking.
+
+        Args:
+            response: The response string to record
+        """
+        self.record_output_messages([response])
+
+    def record_input_messages(self, messages: list[str]) -> None:
+        """Record the input messages for telemetry tracking.
+
+        Args:
+            messages: List of input messages to record
+        """
+        self.set_tag_maybe(GEN_AI_INPUT_MESSAGES_KEY, safe_json_dumps(messages))
+
+    def record_output_messages(self, messages: list[str]) -> None:
+        """Record the output messages for telemetry tracking.
+
+        Args:
+            messages: List of output messages to record
+        """
+        self.set_tag_maybe(GEN_AI_OUTPUT_MESSAGES_KEY, safe_json_dumps(messages))

microsoft_agents_a365/observability/core/middleware/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Middleware components for Microsoft Agent 365 SDK.
+
+from .baggage_builder import BaggageBuilder
+
+__all__ = ["BaggageBuilder"]

microsoft_agents_a365/observability/core/middleware/baggage_builder.py

@@ -0,0 +1,319 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+# Per request baggage builder for OpenTelemetry context propagation.
+
+from typing import Any
+
+from opentelemetry import baggage, context
+
+from ..constants import (
+    CORRELATION_ID_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_UPN_KEY,
+    GEN_AI_CALLER_ID_KEY,
+    GEN_AI_CALLER_NAME_KEY,
+    GEN_AI_CALLER_UPN_KEY,
+    GEN_AI_CONVERSATION_ID_KEY,
+    GEN_AI_CONVERSATION_ITEM_LINK_KEY,
+    GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY,
+    GEN_AI_EXECUTION_SOURCE_ID_KEY,
+    GEN_AI_EXECUTION_SOURCE_NAME_KEY,
+    HIRING_MANAGER_ID_KEY,
+    OPERATION_SOURCE_KEY,
+    TENANT_ID_KEY,
+)
+from .turn_context_baggage import from_turn_context
+
+
+class BaggageBuilder:
+    """Per request baggage builder.
+
+    This class provides a fluent API for setting baggage values that will be
+    propagated in the OpenTelemetry context.
+
+    Example:
+        >>> with BaggageBuilder() \
+        ...     .tenant_id("tenant-123") \
+        ...     .agent_id("agent-456") \
+        ...     .correlation_id("corr-789") \
+        ...     .build():
+        ...     # Baggage is set in this context
+        ...     pass
+        >>> # Baggage is restored after exiting the context
+    """
+
+    def __init__(self):
+        """Initialize the baggage builder."""
+        self._pairs: dict[str, str] = {}
+
+    def operation_source(self, value: str | None) -> "BaggageBuilder":
+        """Set the operation source baggage value.
+
+        Args:
+            value: The operation source value
+
+        Returns:
+            Self for method chaining
+        """
+        self._set(OPERATION_SOURCE_KEY, value)
+        return self
+
+    def tenant_id(self, value: str | None) -> "BaggageBuilder":
+        """Set the tenant ID baggage value.
+
+        Args:
+            value: The tenant ID
+
+        Returns:
+            Self for method chaining
+        """
+        self._set(TENANT_ID_KEY, value)
+        return self
+
+    def agent_id(self, value: str | None) -> "BaggageBuilder":
+        """Set the agent ID baggage value.
+
+        Args:
+            value: The agent ID
+
+        Returns:
+            Self for method chaining
+        """
+        self._set(GEN_AI_AGENT_ID_KEY, value)
+        return self
+
+    def agent_auid(self, value: str | None) -> "BaggageBuilder":
+        """Set the agent AUID baggage value.
+
+        Args:
+            value: The agent AUID
+
+        Returns:
+            Self for method chaining
+        """
+        self._set(GEN_AI_AGENT_AUID_KEY, value)
+        return self
+
+    def agent_upn(self, value: str | None) -> "BaggageBuilder":
+        """Set the agent UPN baggage value.
+
+        Args:
+            value: The agent UPN
+
+        Returns:
+            Self for method chaining
+        """
+        self._set(GEN_AI_AGENT_UPN_KEY, value)
+        return self
+
+    def agent_blueprint_id(self, value: str | None) -> "BaggageBuilder":
+        """Set the agent blueprint ID baggage value.
+
+        Args:
+            value: The agent blueprint ID
+
+        Returns:
+            Self for method chaining
+        """
+        self._set(GEN_AI_AGENT_BLUEPRINT_ID_KEY, value)
+        return self
+
+    def correlation_id(self, value: str | None) -> "BaggageBuilder":
+        """Set the correlation ID baggage value.
+
+        Args:
+            value: The correlation ID
+
+        Returns:
+            Self for method chaining
+        """
+        self._set(CORRELATION_ID_KEY, value)
+        return self
+
+    def caller_id(self, value: str | None) -> "BaggageBuilder":
+        """Set the caller ID baggage value.
+
+        Args:
+            value: The caller ID
+
+        Returns:
+            Self for method chaining
+        """
+        self._set(GEN_AI_CALLER_ID_KEY, value)
+        return self
+
+    def hiring_manager_id(self, value: str | None) -> "BaggageBuilder":
+        """Set the hiring manager ID baggage value.
+
+        Args:
+            value: The hiring manager ID
+
+        Returns:
+            Self for method chaining
+        """
+        self._set(HIRING_MANAGER_ID_KEY, value)
+        return self
+
+    def agent_name(self, value: str | None) -> "BaggageBuilder":
+        """Set the agent name baggage value."""
+        self._set(GEN_AI_AGENT_NAME_KEY, value)
+        return self
+
+    def agent_description(self, value: str | None) -> "BaggageBuilder":
+        """Set the agent description baggage value."""
+        self._set(GEN_AI_AGENT_DESCRIPTION_KEY, value)
+        return self
+
+    def caller_name(self, value: str | None) -> "BaggageBuilder":
+        """Set the caller name baggage value."""
+        self._set(GEN_AI_CALLER_NAME_KEY, value)
+        return self
+
+    def caller_upn(self, value: str | None) -> "BaggageBuilder":
+        """Set the caller UPN baggage value."""
+        self._set(GEN_AI_CALLER_UPN_KEY, value)
+        return self
+
+    def conversation_id(self, value: str | None) -> "BaggageBuilder":
+        """Set the conversation ID baggage value."""
+        self._set(GEN_AI_CONVERSATION_ID_KEY, value)
+        return self
+
+    def conversation_item_link(self, value: str | None) -> "BaggageBuilder":
+        """Set the conversation item link baggage value."""
+        self._set(GEN_AI_CONVERSATION_ITEM_LINK_KEY, value)
+        return self
+
+    def source_metadata_id(self, value: str | None) -> "BaggageBuilder":
+        """Set the execution source metadata ID (e.g., channel ID)."""
+        self._set(GEN_AI_EXECUTION_SOURCE_ID_KEY, value)
+        return self
+
+    def source_metadata_name(self, value: str | None) -> "BaggageBuilder":
+        """Set the execution source metadata name (e.g., channel name)."""
+        self._set(GEN_AI_EXECUTION_SOURCE_NAME_KEY, value)
+        return self
+
+    def source_metadata_description(self, value: str | None) -> "BaggageBuilder":
+        """Set the execution source metadata description (e.g., channel description)."""
+        self._set(GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY, value)
+        return self
+
+    def from_turn_context(self, turn_context: Any) -> "BaggageBuilder":
+        """
+        Populate baggage from a turn_context (duck-typed).
+        Delegates to baggage_turn_context.from_turn_context.
+        """
+
+        return self.set_pairs(from_turn_context(turn_context))
+
+    def set_pairs(self, pairs: Any) -> "BaggageBuilder":
+        """
+        Accept dict or iterable of (k,v).
+        """
+        if not pairs:
+            return self
+        if isinstance(pairs, dict):
+            iterator = pairs.items()
+        else:
+            iterator = pairs
+        for k, v in iterator:
+            if v is None:
+                continue
+            self._set(str(k), str(v))
+        return self
+
+    def build(self) -> "BaggageScope":
+        """Apply the collected baggage to the current context.
+
+        Returns:
+            A context manager that restores the previous baggage on exit
+        """
+        return BaggageScope(self._pairs)
+
+    def _set(self, key: str, value: str | None) -> None:
+        """Add a baggage key/value if the value is not None or whitespace.
+
+        Args:
+            key: The baggage key
+            value: The baggage value
+        """
+        if value is not None and value.strip():
+            self._pairs[key] = value
+
+    @staticmethod
+    def set_request_context(
+        tenant_id: str | None = None,
+        agent_id: str | None = None,
+        correlation_id: str | None = None,
+    ) -> "BaggageScope":
+        """Convenience method to begin a request baggage scope with common fields.
+
+        Args:
+            tenant_id: The tenant ID
+            agent_id: The agent ID
+            correlation_id: The correlation ID
+
+        Returns:
+            A context manager that restores the previous baggage on exit
+        """
+        return (
+            BaggageBuilder()
+            .tenant_id(tenant_id)
+            .agent_id(agent_id)
+            .correlation_id(correlation_id)
+            .build()
+        )
+
+
+class BaggageScope:
+    """Context manager for baggage scope.
+
+    This class manages the lifecycle of baggage values, setting them on enter
+    and restoring the previous context on exit.
+    """
+
+    def __init__(self, pairs: dict[str, str]):
+        """Initialize the baggage scope.
+
+        Args:
+            pairs: Dictionary of baggage key-value pairs to set
+        """
+        self._pairs = pairs
+        self._previous_context: Any = None
+        self._token: Any = None
+
+    def __enter__(self) -> "BaggageScope":
+        """Enter the context and set baggage values.
+
+        Returns:
+            Self
+        """
+        # Get the current context
+        self._previous_context = context.get_current()
+
+        # Set all baggage values in the new context
+        new_context = self._previous_context
+        for key, value in self._pairs.items():
+            if value and value.strip():
+                new_context = baggage.set_baggage(key, value, context=new_context)
+
+        # Attach the new context
+        self._token = context.attach(new_context)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit the context and restore previous baggage.
+
+        Args:
+            exc_type: Exception type if an exception occurred
+            exc_val: Exception value if an exception occurred
+            exc_tb: Exception traceback if an exception occurred
+        """
+        # Detach and restore previous context
+        if self._token is not None:
+            context.detach(self._token)

microsoft_agents_a365/observability/core/middleware/turn_context_baggage.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Iterable, Iterator, Mapping
+
+from ..constants import (
+    GEN_AI_AGENT_AUID_KEY,
+    GEN_AI_AGENT_DESCRIPTION_KEY,
+    GEN_AI_AGENT_ID_KEY,
+    GEN_AI_AGENT_NAME_KEY,
+    GEN_AI_AGENT_UPN_KEY,
+    GEN_AI_CALLER_ID_KEY,
+    GEN_AI_CALLER_NAME_KEY,
+    GEN_AI_CALLER_TENANT_ID_KEY,
+    GEN_AI_CALLER_UPN_KEY,
+    GEN_AI_CALLER_USER_ID_KEY,
+    GEN_AI_CONVERSATION_ID_KEY,
+    GEN_AI_CONVERSATION_ITEM_LINK_KEY,
+    GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY,
+    GEN_AI_EXECUTION_SOURCE_ID_KEY,
+    GEN_AI_EXECUTION_SOURCE_NAME_KEY,
+    GEN_AI_EXECUTION_TYPE_KEY,
+    TENANT_ID_KEY,
+)
+from ..execution_type import ExecutionType
+
+AGENT_ROLE = "agenticUser"
+CHANNEL_ID_AGENTS = "agents"
+ENTITY_TYPE_WPX_COMMENT = "wpxcomment"
+ENTITY_TYPE_EMAIL_NOTIFICATION = "emailNotification"
+WPX_CONVERSATION_ID_FORMAT = "{document_id}_{parent_comment_id}"
+
+
+def _safe_get(obj: Any, *names: str) -> Any:
+    """Attempt multiple attribute/dict keys; return first non-None."""
+    for n in names:
+        if obj is None:
+            continue
+        # dict-like
+        if isinstance(obj, Mapping) and n in obj:
+            return obj[n]
+        # attribute-like (support both camelCase and snake_case lookups)
+        if hasattr(obj, n):
+            return getattr(obj, n)
+    return None
+
+
+def _extract_channel_data(activity: Any) -> Mapping[str, Any] | None:
+    cd = _safe_get(activity, "channel_data")
+    if cd is None:
+        return None
+    if isinstance(cd, Mapping):
+        return cd
+    if isinstance(cd, str):
+        try:
+            return json.loads(cd)
+        except Exception:
+            return None
+    return None
+
+
+def _iter_caller_pairs(activity: Any) -> Iterator[tuple[str, Any]]:
+    frm = _safe_get(activity, "from")
+    if not frm:
+        return
+    yield GEN_AI_CALLER_ID_KEY, _safe_get(frm, "id")
+    name = _safe_get(frm, "name")
+    yield GEN_AI_CALLER_NAME_KEY, name
+    # Reuse 'name' as UPN if no separate field
+    upn = _safe_get(frm, "upn") or name
+    yield GEN_AI_CALLER_UPN_KEY, upn
+    user_id = _safe_get(frm, "agentic_user_id", "aad_object_id")
+    yield GEN_AI_CALLER_USER_ID_KEY, user_id
+    tenant_id = _safe_get(frm, "tenant_id")
+    yield GEN_AI_CALLER_TENANT_ID_KEY, tenant_id
+
+
+def _is_agentic(entity: Any) -> bool:
+    return bool(
+        _safe_get(
+            entity,
+            "agentic_user_id",
+        )
+        or (
+            (role := _safe_get(entity, "role", "Role"))
+            and isinstance(role, str)
+            and role.lower() == AGENT_ROLE.lower()
+        )
+    )
+
+
+def _iter_execution_type_pair(activity: Any) -> Iterator[tuple[str, Any]]:
+    frm = _safe_get(activity, "from")
+    rec = _safe_get(activity, "recipient")
+    is_agentic_caller = _is_agentic(frm)
+    is_agentic_recipient = _is_agentic(rec)
+    exec_type = (
+        ExecutionType.AGENT_TO_AGENT.value
+        if (is_agentic_caller and is_agentic_recipient)
+        else ExecutionType.HUMAN_TO_AGENT.value
+    )
+    yield GEN_AI_EXECUTION_TYPE_KEY, exec_type
+
+
+def _iter_target_agent_pairs(activity: Any) -> Iterator[tuple[str, Any]]:
+    rec = _safe_get(activity, "recipient")
+    if not rec:
+        return
+    yield GEN_AI_AGENT_ID_KEY, _safe_get(rec, "agentic_app_id")
+    yield GEN_AI_AGENT_NAME_KEY, _safe_get(rec, "name")
+    auid = _safe_get(rec, "agentic_user_id", "aad_object_id")
+    yield GEN_AI_AGENT_AUID_KEY, auid
+    yield GEN_AI_AGENT_UPN_KEY, _safe_get(rec, "upn", "name")
+    yield (
+        GEN_AI_AGENT_DESCRIPTION_KEY,
+        _safe_get(rec, "role"),
+    )
+
+
+def _iter_tenant_id_pair(activity: Any) -> Iterator[tuple[str, Any]]:
+    rec = _safe_get(activity, "recipient")
+    tenant_id = _safe_get(rec, "tenant_id")
+    if not tenant_id:
+        cd_dict = _extract_channel_data(activity)
+        # channelData.tenant.id
+        try:
+            tenant_id = (
+                cd_dict
+                and isinstance(cd_dict.get("tenant"), Mapping)
+                and cd_dict["tenant"].get("id")
+            )
+        except Exception:
+            tenant_id = None
+    yield TENANT_ID_KEY, tenant_id
+
+
+def _iter_source_metadata_pairs(activity: Any) -> Iterator[tuple[str, Any]]:
+    channel_id = _safe_get(activity, "channel_id")
+    yield GEN_AI_EXECUTION_SOURCE_ID_KEY, channel_id
+    yield GEN_AI_EXECUTION_SOURCE_NAME_KEY, channel_id
+    yield GEN_AI_EXECUTION_SOURCE_DESCRIPTION_KEY, _safe_get(activity, "type", "Type")
+
+
+def _iter_conversation_pairs(activity: Any) -> Iterator[tuple[str, Any]]:
+    channel_id = _safe_get(activity, "channel_id")
+    entities = _safe_get(activity, "entities") or []
+    conversation_id = None
+
+    if channel_id == CHANNEL_ID_AGENTS and isinstance(entities, Iterable):
+        # search entities for wpxcomment or emailNotification
+        for e in entities:
+            etype = _safe_get(e, "type", "Type")
+            if etype == ENTITY_TYPE_WPX_COMMENT:
+                document_id = _safe_get(e, "documentId", "document_id")
+                parent_comment_id = _safe_get(e, "parentCommentId", "parent_comment_id")
+                if document_id and parent_comment_id:
+                    conversation_id = WPX_CONVERSATION_ID_FORMAT.format(
+                        document_id=document_id,
+                        parent_comment_id=parent_comment_id,
+                    )
+                    break
+            elif etype == ENTITY_TYPE_EMAIL_NOTIFICATION:
+                conversation_id = _safe_get(e, "conversationId", "conversation_id")
+                if conversation_id:
+                    break
+    if not conversation_id:
+        conv = _safe_get(activity, "conversation")
+        conversation_id = _safe_get(conv, "id", "Id")
+
+    item_link = _safe_get(activity, "service_url")
+
+    yield GEN_AI_CONVERSATION_ID_KEY, conversation_id
+    yield GEN_AI_CONVERSATION_ITEM_LINK_KEY, item_link
+
+
+def _iter_all_pairs(turn_context: Any) -> Iterator[tuple[str, Any]]:
+    activity = _safe_get(
+        turn_context,
+        "activity",
+    )
+    if not activity:
+        return
+    yield from _iter_caller_pairs(activity)
+    yield from _iter_execution_type_pair(activity)
+    yield from _iter_target_agent_pairs(activity)
+    yield from _iter_tenant_id_pair(activity)
+    yield from _iter_source_metadata_pairs(activity)
+    yield from _iter_conversation_pairs(activity)
+
+
+def from_turn_context(turn_context: Any) -> dict:
+    """Populate builder with baggage values extracted from a turn context."""
+    return dict(_iter_all_pairs(turn_context))

microsoft_agents_a365/observability/core/models/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.