fix: align maf autogen genai semantics

Author: sipercai

instrumentation-loongsuite/loongsuite-instrumentation-autogen/src/opentelemetry/instrumentation/autogen/span_processor.py

@@ -220,7 +220,7 @@ def _classify_span(
     if op == GenAIOperation.EXECUTE_TOOL:
         return GenAISpanKind.TOOL, op
     if op == GenAIOperation.CREATE_AGENT:
-        return None, op
+        return GenAISpanKind.AGENT, op
     if op == GenAIOperation.INVOKE_AGENT:
         return GenAISpanKind.AGENT, op
     return GenAISpanKind.CHAIN, op or GenAIOperation.INVOKE_AGENT
@@ -284,7 +284,11 @@ def on_end(self, span: Any) -> None:
 
             if span_kind == GenAISpanKind.LLM:
                 _set_otel_span_kind(live, span, SpanKind.CLIENT)
-            elif span_kind in {GenAISpanKind.AGENT, GenAISpanKind.TOOL}:
+            elif span_kind == GenAISpanKind.AGENT and op_name == (
+                GenAIOperation.INVOKE_AGENT
+            ):
+                _set_otel_span_kind(live, span, SpanKind.INTERNAL)
+            elif span_kind == GenAISpanKind.TOOL:
                 _set_otel_span_kind(live, span, SpanKind.INTERNAL)
         except Exception as exc:  # pragma: no cover - defensive
             logger.warning("AutoGenSemanticProcessor.on_end failed: %s", exc)

instrumentation-loongsuite/loongsuite-instrumentation-autogen/src/opentelemetry/instrumentation/autogen/utils.py

@@ -241,7 +241,7 @@ def provider_name(model_client: Any) -> str:
 
 def _finish_reason(value: Any) -> str:
     reason = _text(value or "unknown")
-    if reason == "function_calls":
+    if reason in {"tool_call", "function_call", "function_calls"}:
         return "tool_calls"
     return reason
 

instrumentation-loongsuite/loongsuite-instrumentation-autogen/tests/test_span_processor.py

@@ -68,7 +68,7 @@ def test_processor_normalizes_native_autogen_invoke_span():
     assert span.kind == SpanKind.INTERNAL
 
 
-def test_processor_keeps_create_agent_as_lifecycle_span():
+def test_processor_marks_create_agent_as_agent_lifecycle_span():
     exporter = InMemorySpanExporter()
     provider = TracerProvider()
     provider.add_span_processor(AutoGenSemanticProcessor())
@@ -91,7 +91,7 @@ def test_processor_keeps_create_agent_as_lifecycle_span():
 
     assert attributes[GEN_AI_PROVIDER_NAME] == AUTOGEN_PROVIDER_NAME
     assert attributes[GEN_AI_OPERATION_NAME] == GenAIOperation.CREATE_AGENT
-    assert GEN_AI_SPAN_KIND not in attributes
+    assert attributes[GEN_AI_SPAN_KIND] == GenAISpanKind.AGENT
     assert GEN_AI_SYSTEM not in attributes
     assert span.kind == SpanKind.CLIENT
 

instrumentation-loongsuite/loongsuite-instrumentation-autogen/tests/test_utils.py

@@ -220,6 +220,22 @@ def test_apply_create_result_normalizes_tool_call_finish_reason():
     assert invocation.output_messages[0].finish_reason == "tool_calls"
 
 
+def test_apply_create_result_normalizes_singular_tool_call_finish_reason():
+    invocation = make_llm_invocation(ModelClient(), [], [])
+
+    apply_create_result(
+        invocation,
+        CreateResult(
+            [FunctionCall("call-1", "lookup", {"q": "x"})],
+            "tool_call",
+            Usage(prompt_tokens=3, completion_tokens=5),
+        ),
+    )
+
+    assert invocation.finish_reasons == ["tool_calls"]
+    assert invocation.output_messages[0].finish_reason == "tool_calls"
+
+
 def test_make_agent_invocation_uses_assistant_metadata():
     class AssistantAgent:
         _name = "assistant"

instrumentation-loongsuite/loongsuite-instrumentation-microsoft-agent-framework/src/opentelemetry/instrumentation/microsoft_agent_framework/react_step_patch.py

@@ -41,6 +41,8 @@
 import contextvars
 import inspect
 import logging
+from dataclasses import dataclass
+from types import TracebackType
 from typing import Any
 
 logger = logging.getLogger(__name__)
@@ -54,13 +56,22 @@
 _maf_react_step_counter: contextvars.ContextVar[int] = contextvars.ContextVar(
     "_maf_react_step_counter", default=0
 )
+_maf_current_react_step: contextvars.ContextVar[Any] = contextvars.ContextVar(
+    "_maf_current_react_step", default=None
+)
 
 _applied = False
 _original_fil_get_response: Any = None
 _original_chat_get_response: Any = None
 _handler: Any = None
 
 
+@dataclass
+class _OpenReactStep:
+    cm: Any
+    invocation: Any
+
+
 def _mark_maf_live_span(invocation: Any) -> None:
     span = getattr(invocation, "span", None)
     if span is None:
@@ -139,11 +150,17 @@ def _fil_wrapper(wrapped, instance, args, kwargs):  # type: ignore[no-untyped-de
         async def _scoped():  # type: ignore[no-untyped-def]
             token_active = _maf_react_loop_active.set(True)
             token_counter = _maf_react_step_counter.set(0)
+            token_step = _maf_current_react_step.set(None)
             try:
                 return await result
+            except Exception as exc:
+                _close_current_react_step(type(exc), exc, exc.__traceback__)
+                raise
             finally:
+                _close_current_react_step()
                 _maf_react_loop_active.reset(token_active)
                 _maf_react_step_counter.reset(token_counter)
+                _maf_current_react_step.reset(token_step)
 
         return _scoped()
 
@@ -166,27 +183,24 @@ def _chat_wrapper(wrapped, instance, args, kwargs):  # type: ignore[no-untyped-d
         local_handler = handler
 
         async def _step_scoped():  # type: ignore[no-untyped-def]
-            from opentelemetry.util.genai.extended_types import (
-                ReactStepInvocation,
-            )
-
-            step_inv = ReactStepInvocation(round=round_num)
-            token_counter = _maf_react_step_counter.set(round_num)
+            previous_step = _close_current_react_step()
+            if previous_step is not None and inspect.isawaitable(
+                previous_step
+            ):
+                await previous_step
+            step_inv = _open_current_react_step(local_handler, round_num)
+            _maf_react_step_counter.set(round_num)
             try:
-                with local_handler.react_step(step_inv) as step:
-                    _mark_maf_live_span(step)
-                    try:
-                        response = await result
-                        # Best-effort finish_reason extraction from the response.
-                        finish = _extract_finish_reason(response)
-                        if finish is not None:
-                            step.finish_reason = finish
-                        return response
-                    except Exception:
-                        step.finish_reason = "error"
-                        raise
-            finally:
-                _maf_react_step_counter.reset(token_counter)
+                response = await result
+                # Best-effort finish_reason extraction from the response.
+                finish = _extract_finish_reason(response)
+                if finish is not None:
+                    step_inv.finish_reason = finish
+                return response
+            except Exception as exc:
+                step_inv.finish_reason = "error"
+                _close_current_react_step(type(exc), exc, exc.__traceback__)
+                raise
 
         return _step_scoped()
 
@@ -228,6 +242,31 @@ def _unwrap_to_function(func: Any) -> Any:
     return cur
 
 
+def _open_current_react_step(handler: Any, round_num: int) -> Any:
+    from opentelemetry.util.genai.extended_types import ReactStepInvocation
+
+    step_inv = ReactStepInvocation(round=round_num)
+    cm = handler.react_step(step_inv)
+    step = cm.__enter__()
+    _mark_maf_live_span(step)
+    _maf_current_react_step.set(_OpenReactStep(cm=cm, invocation=step))
+    return step
+
+
+def _close_current_react_step(
+    exc_type: type[BaseException] | None = None,
+    exc: BaseException | None = None,
+    tb: TracebackType | None = None,
+) -> Any:
+    current = _maf_current_react_step.get()
+    if current is None:
+        return None
+    _maf_current_react_step.set(None)
+    if exc_type is not None and current.invocation.finish_reason is None:
+        current.invocation.finish_reason = "error"
+    return current.cm.__exit__(exc_type, exc, tb)
+
+
 def _is_response_stream(result: Any) -> bool:
     """Return True for MAF ResponseStream-like values.
 
@@ -244,23 +283,38 @@ def _is_response_stream(result: Any) -> bool:
 def _extract_finish_reason(result: Any) -> Any:
     """Best-effort extraction of a finish_reason string from a ChatResponse."""
     try:
+        fr = getattr(result, "finish_reason", None)
+        if fr:
+            return _normalize_finish_reason(fr)
+        raw = getattr(result, "raw_representation", None)
+        if raw is not None:
+            fr = getattr(raw, "finish_reason", None)
+            if fr:
+                return _normalize_finish_reason(fr)
         # MAF ChatResponse.messages[-1].finish_reason or choices[0].finish_reason
         messages = getattr(result, "messages", None)
         if messages:
             last = messages[-1]
             fr = getattr(last, "finish_reason", None)
             if fr:
-                return fr
+                return _normalize_finish_reason(fr)
         choices = getattr(result, "choices", None)
         if choices:
             fr = getattr(choices[0], "finish_reason", None)
             if fr:
-                return fr
+                return _normalize_finish_reason(fr)
     except Exception:
         return None
     return None
 
 
+def _normalize_finish_reason(value: Any) -> str:
+    reason = str(value)
+    if reason in {"tool_call", "function_call", "function_calls"}:
+        return "tool_calls"
+    return reason
+
+
 def revert_react_step_patch() -> None:
     """Revert the ReAct step patch. Safe to call even if not applied."""
     global _applied, _original_fil_get_response, _original_chat_get_response

instrumentation-loongsuite/loongsuite-instrumentation-microsoft-agent-framework/src/opentelemetry/instrumentation/microsoft_agent_framework/span_processor.py

@@ -96,6 +96,7 @@
 _EDGE_GROUP_PROCESS = "edge_group.process"
 _LIVE_SPAN_MAX_AGE_NS = 60 * 1_000_000_000
 _GEN_AI_TOOL_NAME = "gen_ai.tool.name"
+_GEN_AI_OUTPUT_MESSAGES = "gen_ai.output.messages"
 _FRAMEWORK_PROVIDER_NAME = MAF_PROVIDER_NAME
 _GEN_AI_SYSTEM = "gen_ai.system"
 _MAF_LIVE_SPAN_MARKER = MAF_LIVE_SPAN_MARKER
@@ -106,6 +107,9 @@
     _EXECUTOR_PROCESS,
     _EDGE_GROUP_PROCESS,
 )
+_TOOL_CALL_FINISH_REASONS = frozenset(
+    {"tool_call", "tool_calls", "function_call", "function_calls"}
+)
 
 
 def _attr_value(span: Any, key: str) -> Any:
@@ -391,6 +395,18 @@ def _normalize_provider(value: Any) -> Optional[str]:
 def _normalize_finish_reasons(live_span: OtelSpan, readable: Any) -> None:
     """Normalize JSON-encoded finish reasons to an OTel string array."""
     value = _attr_value(readable, GEN_AI_RESPONSE_FINISH_REASONS)
+    if isinstance(value, (list, tuple)) and all(
+        isinstance(item, str) for item in value
+    ):
+        normalized = [_normalize_finish_reason_value(item) for item in value]
+        if list(value) != normalized:
+            _set_attr_on_both(
+                live_span,
+                readable,
+                GEN_AI_RESPONSE_FINISH_REASONS,
+                normalized,
+            )
+        return
     if not isinstance(value, str):
         return
     try:
@@ -400,11 +416,77 @@ def _normalize_finish_reasons(live_span: OtelSpan, readable: Any) -> None:
     if isinstance(parsed, list) and all(
         isinstance(item, str) for item in parsed
     ):
+        parsed = [_normalize_finish_reason_value(item) for item in parsed]
         _set_attr_on_both(
             live_span, readable, GEN_AI_RESPONSE_FINISH_REASONS, parsed
         )
 
 
+def _normalize_output_messages(live_span: OtelSpan, readable: Any) -> None:
+    normalized = _normalized_output_messages_value(
+        _attr_value(readable, _GEN_AI_OUTPUT_MESSAGES)
+    )
+    if normalized is not None:
+        _set_attr_on_both(
+            live_span, readable, _GEN_AI_OUTPUT_MESSAGES, normalized
+        )
+
+
+def _normalized_output_messages_value(value: Any) -> Optional[str]:
+    if value is None:
+        return None
+    try:
+        messages = json.loads(value) if isinstance(value, str) else value
+    except (TypeError, ValueError):
+        return None
+    if not isinstance(messages, list):
+        return None
+    changed = False
+    normalized_messages = []
+    for message in messages:
+        if not isinstance(message, dict):
+            normalized_messages.append(message)
+            continue
+        normalized = dict(message)
+        current = normalized.get("finish_reason")
+        default = _default_finish_reason_for_message(normalized)
+        finish_reason = _normalize_finish_reason_value(
+            current, default=default
+        )
+        if current != finish_reason:
+            normalized["finish_reason"] = finish_reason
+            changed = True
+        normalized_messages.append(normalized)
+    if not changed and isinstance(value, str):
+        return None
+    try:
+        return json.dumps(
+            normalized_messages, ensure_ascii=False, separators=(",", ":")
+        )
+    except (TypeError, ValueError):
+        return None
+
+
+def _default_finish_reason_for_message(message: Mapping[Any, Any]) -> str:
+    parts = message.get("parts")
+    if isinstance(parts, list):
+        for part in parts:
+            if isinstance(part, Mapping) and part.get("type") == "tool_call":
+                return "tool_calls"
+    return "stop"
+
+
+def _normalize_finish_reason_value(
+    value: Any, *, default: str = "stop"
+) -> str:
+    if value is None or value == "":
+        return default
+    reason = str(value)
+    if reason in _TOOL_CALL_FINISH_REASONS:
+        return "tool_calls"
+    return reason
+
+
 def _set_span_kind(live_span: OtelSpan, readable: Any, kind: SpanKind) -> None:
     """Mutate the SDK span kind before downstream exporters receive the span."""
     for target in (readable, live_span):
@@ -1029,6 +1111,7 @@ def _apply_semantic_attributes(
 
         # 5) Normalize finish reasons written by MAF as a JSON string.
         _normalize_finish_reasons(live, readable)
+        _normalize_output_messages(live, readable)
 
         # 6) LLM/embedding spans should use CLIENT OTel span kind.
         if span_kind == GenAISpanKind.LLM: