agentengine-sdk-python 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

ksadk/conversations/message_projection.py

@@ -18,6 +18,7 @@ def project_session_messages(
     include_reasoning: bool = False,
     include_tool_events: bool = False,
     include_attachments: bool = True,
+    session_id: str | None = None,
 ) -> list[dict[str, Any]]:
     """Project persisted runtime events into the chat history contract.
 
@@ -53,7 +54,17 @@ def project_session_messages(
                 approval_responses=approval_responses,
             )
         )
-    return sorted(messages, key=lambda item: int(item.get("SeqId") or 0))
+    projected = sorted(messages, key=lambda item: int(item.get("SeqId") or 0))
+    if session_id:
+        for message in projected:
+            for attachment in message.get("Attachments") or []:
+                file_uri = str(attachment.get("file_uri") or "")
+                if file_uri.startswith(("ksadk-upload://", "ae-upload://")):
+                    attachment["url"] = (
+                        "/agentengine/api/v1/AttachmentContent?FileUri="
+                        f"{quote(file_uri, safe='')}&SessionId={quote(str(session_id), safe='')}"
+                    )
+    return projected
 
 
 def _project_event_group(
@@ -119,8 +130,7 @@ def _project_event_group(
             # emit a placeholder assistant message for them first.
             if has_pre_assistant_approvals and not assistant_seen:
                 anchor = next(
-                    (e for e in events
-                     if str(e.get("EventType") or "") == "approval_request"),
+                    (e for e in events if str(e.get("EventType") or "") == "approval_request"),
                     events[0],
                 )
                 placeholder = _base_message(anchor, "assistant", content="")
@@ -224,9 +234,7 @@ def _project_interleaved_blocks(
     saw_stream_text = False
     saw_reasoning_after_stream_text = False
     tools_by_seq_id = {
-        int(tool.get("SeqId") or 0): tool
-        for tool in tool_events
-        if int(tool.get("SeqId") or 0) > 0
+        int(tool.get("SeqId") or 0): tool for tool in tool_events if int(tool.get("SeqId") or 0) > 0
     }
 
     def append_text(text: str, seq_id: Any) -> None:
@@ -431,6 +439,34 @@ def _tool_event_from_call(event: Mapping[str, Any], metadata: Mapping[str, Any])
     }
 
 
+def _approval_status_from_resume(response: Any, resume_input: Mapping[str, Any]) -> str:
+    """从 approval_response 事件的 resume_input 判断审批结果状态。
+
+    支持两种协议：
+    - mcp_approval_response: resume_input 含 approve/approved bool
+    - ksadk_resume + decisions: resume_input.value.decisions[0].type 为
+      approve/edit/reject（HumanInTheLoopMiddleware 协议）
+    """
+    if response is None:
+        return "paused"
+    # ksadk_resume + decisions 协议
+    value = resume_input.get("value")
+    if isinstance(value, Mapping):
+        decisions = value.get("decisions")
+        if isinstance(decisions, list) and decisions:
+            first = decisions[0]
+            if isinstance(first, Mapping):
+                decision_type = str(first.get("type") or "").strip().lower()
+                if decision_type in {"approve", "edit"}:
+                    return "approved"
+                if decision_type in {"reject", "respond"}:
+                    return "denied"
+    # mcp_approval_response 协议
+    if resume_input.get("approve") or resume_input.get("approved"):
+        return "approved"
+    return "denied"
+
+
 def _project_approval_events(
     events: Sequence[Mapping[str, Any]],
     *,
@@ -438,10 +474,50 @@ def _project_approval_events(
 ) -> list[dict[str, Any]]:
     approvals: list[dict[str, Any]] = []
     for request in events:
-        if request.get("EventType") != "approval_request":
+        event_type = str(request.get("EventType") or "")
+        # 识别归一化后的 approval_request，以及未归一化的 canonical interaction.requested。
+        if event_type not in {"approval_request", "interaction.requested"}:
             continue
         metadata = _event_metadata(request)
+        # 归一化路径：interrupt_info 在 metadata；canonical 路径在
+        # Content.runtime_event.request.detail。
         interrupt_info = metadata.get("interrupt_info")
+        if not isinstance(interrupt_info, Mapping):
+            # 尝试从 canonical event 的 Content.runtime_event 提取
+            raw_content = request.get("Content")
+            content = raw_content if isinstance(raw_content, Mapping) else {}
+            runtime_event = content.get("runtime_event")
+            if isinstance(runtime_event, Mapping):
+                req = runtime_event.get("request") or {}
+                if isinstance(req, Mapping):
+                    detail = req.get("detail")
+                    if isinstance(detail, Mapping):
+                        # 从 detail.action_requests[0] 提取（HumanInTheLoopMiddleware 结构）
+                        action_requests = detail.get("action_requests")
+                        first_action = (
+                            action_requests[0]
+                            if isinstance(action_requests, list) and action_requests
+                            else {}
+                        )
+                        if not isinstance(first_action, Mapping):
+                            first_action = {}
+                        interaction_id = runtime_event.get("interaction_id") or req.get("call_id")
+                        interrupt_info = {
+                            "approval_request_id": interaction_id,
+                            "id": interaction_id,
+                            "tool_name": detail.get("tool_name")
+                            or first_action.get("name")
+                            or req.get("kind"),
+                            "arguments": detail.get("arguments")
+                            or detail.get("args")
+                            or first_action.get("args")
+                            or first_action.get("arguments"),
+                            "description": detail.get("description")
+                            or first_action.get("description"),
+                            "review_configs": detail.get("review_configs"),
+                            "approval_message": detail.get("message")
+                            or first_action.get("description"),
+                        }
         if not isinstance(interrupt_info, Mapping):
             interrupt_info = {}
         request_id = str(
@@ -452,31 +528,47 @@ def _project_approval_events(
         resume_input = response_metadata.get("resume_input")
         if not isinstance(resume_input, Mapping):
             resume_input = {}
-        status = (
-            "paused"
-            if response is None
-            else (
-                "approved"
-                if resume_input.get("approve") or resume_input.get("approved")
-                else "denied"
-            )
+        status = _approval_status_from_resume(response, resume_input)
+        # HumanInTheLoopMiddleware 的 interrupt_info 把 tool_name 嵌在
+        # action_requests[0].name 里，runtime path 存的事件可能没有顶层 tool_name。
+        # 这里统一提取，避免 Name fallback 成 "approval" 导致前端显示不对。
+        action_requests = interrupt_info.get("action_requests")
+        first_action = (
+            action_requests[0] if isinstance(action_requests, list) and action_requests else {}
         )
+        if not isinstance(first_action, Mapping):
+            first_action = {}
+        tool_name = interrupt_info.get("tool_name") or first_action.get("name") or "approval"
         entry: dict[str, Any] = {
             "SeqId": request.get("SeqId"),
             "Type": "approval",
-            "Name": str(interrupt_info.get("tool_name") or "approval"),
+            "Name": str(tool_name),
             "Status": status,
             "ApprovalRequestId": request_id or None,
         }
         if metadata.get("protocol") == "ag-ui":
             entry["Protocol"] = "ag-ui"
+        # arguments/description 优先从顶层取（_get_interrupt_info/归一化已提取），
+        # fallback 到 action_requests[0]（runtime path 存的原始 interrupt_info）。
         arguments = (
             interrupt_info.get("arguments")
             or interrupt_info.get("tool_args")
             or interrupt_info.get("args")
+            or first_action.get("args")
+            or first_action.get("arguments")
         )
         if arguments is not None:
             entry["Args"] = arguments
+        description = interrupt_info.get("description") or first_action.get("description")
+        if description:
+            entry["Description"] = str(description)
+        review_configs = interrupt_info.get("review_configs")
+        if isinstance(review_configs, list) and review_configs:
+            first_review = review_configs[0]
+            if isinstance(first_review, Mapping):
+                allowed = first_review.get("allowed_decisions")
+                if isinstance(allowed, list) and allowed:
+                    entry["AllowedDecisions"] = [str(d) for d in allowed]
         approval_level = interrupt_info.get("approval_level") or interrupt_info.get("risk_level")
         if approval_level:
             entry["ApprovalLevel"] = str(approval_level)
@@ -626,7 +718,7 @@ def _normalize_canonical_event(
             initial = runtime_event.get("initial") or {}
             parts = initial.get("parts") if isinstance(initial, Mapping) else []
             data: Any = {}
-            for part in (parts or []):
+            for part in parts or []:
                 if isinstance(part, Mapping) and part.get("content_type") == "data":
                     data = part.get("data")
                     break
@@ -722,15 +814,30 @@ def _normalize_canonical_event(
             detail = request.get("detail")
             if not isinstance(detail, Mapping):
                 detail = {}
+            # HumanInTheLoopMiddleware 的 detail 把 tool_name/arguments/description
+            # 嵌在 action_requests[0] 里，detail 顶层没有，需要提取。
+            action_requests = detail.get("action_requests")
+            first_action = (
+                action_requests[0] if isinstance(action_requests, list) and action_requests else {}
+            )
+            if not isinstance(first_action, Mapping):
+                first_action = {}
+            review_configs = detail.get("review_configs")
             normalized["EventType"] = "approval_request"
             normalized["Content"] = {"detail": detail}
             normalized_metadata["interrupt_info"] = {
                 "approval_request_id": interaction_id or call_id,
                 "id": interaction_id or call_id,
-                "tool_name": detail.get("tool_name") or kind,
-                "arguments": detail.get("arguments") or detail.get("args"),
-                "approval_level": detail.get("approval_level"),
-                "approval_message": detail.get("message"),
+                "tool_name": detail.get("tool_name") or first_action.get("name") or kind,
+                "arguments": detail.get("arguments")
+                or detail.get("args")
+                or first_action.get("args")
+                or first_action.get("arguments"),
+                "description": detail.get("description") or first_action.get("description"),
+                "review_configs": review_configs if isinstance(review_configs, list) else None,
+                "approval_level": detail.get("approval_level")
+                or first_action.get("approval_level"),
+                "approval_message": detail.get("message") or first_action.get("description"),
             }
             # Preserve ag-ui protocol tag from source metadata.
             source = runtime_event.get("source") or {}
@@ -861,6 +968,11 @@ def _normalize_runtime_event(
             or approval_request.get("args")
             or detail.get("arguments")
             or detail.get("args"),
+            "description": action.get("description")
+            or approval_request.get("description")
+            or detail.get("description"),
+            "review_configs": approval_request.get("review_configs")
+            or detail.get("review_configs"),
             "approval_level": action.get("approval_level")
             or approval_request.get("approval_level")
             or detail.get("approval_level")

ksadk/conversations/normalize.py

@@ -290,7 +290,9 @@ def compact_attachment_for_session(attachment: Dict[str, Any]) -> Dict[str, Any]
     }
 
 
-def attachment_from_part(part: Part) -> Optional[Dict[str, Any]]:
+def attachment_from_part(
+    part: Part, *, owner_scope_ref: str | None = None
+) -> Optional[Dict[str, Any]]:
     inline = part.inlineData
     if inline and inline.data:
         display_name = inline.displayName or "uploaded_file"
@@ -312,7 +314,9 @@ def attachment_from_part(part: Part) -> Optional[Dict[str, Any]]:
     if file_data and (file_data.fileUri or file_data.displayName):
         display_name = file_data.displayName or file_data.fileUri or "uploaded_file"
         mime_type = (file_data.mimeType or "").strip() or "application/octet-stream"
-        storage_path = resolve_attachment_storage_path(file_data.fileUri or "")
+        storage_path = resolve_attachment_storage_path(
+            file_data.fileUri or "", owner_scope_ref=owner_scope_ref
+        )
         try:
             size_bytes = (
                 storage_path.stat().st_size if storage_path and storage_path.exists() else None
@@ -357,9 +361,15 @@ def display_content_from_parts(parts: List[Part]) -> str:
     return "\n\n".join(blocks).strip()
 
 
-def normalize_parts_content(parts: List[Part]) -> dict[str, Any]:
+def normalize_parts_content(
+    parts: List[Part], *, owner_scope_ref: str | None = None
+) -> dict[str, Any]:
     attachments = [
-        attachment for attachment in (attachment_from_part(part) for part in parts) if attachment
+        attachment
+        for attachment in (
+            attachment_from_part(part, owner_scope_ref=owner_scope_ref) for part in parts
+        )
+        if attachment
     ]
     attachment_results = build_attachment_results(attachments)
     display_content = display_content_from_parts(parts)
@@ -383,7 +393,9 @@ def normalize_parts_content(parts: List[Part]) -> dict[str, Any]:
     }
 
 
-def normalize_kop_message_content(content: Any) -> dict[str, Any]:
+def normalize_kop_message_content(
+    content: Any, *, owner_scope_ref: str | None = None
+) -> dict[str, Any]:
     input_content = canonical_input_content_from_message_content(content)
     if isinstance(content, list):
         parts: List[Part] = []
@@ -397,7 +409,7 @@ def normalize_kop_message_content(content: Any) -> dict[str, Any]:
                 parts.append(Part.model_validate(payload))
             except Exception:
                 continue
-        normalized = normalize_parts_content(parts)
+        normalized = normalize_parts_content(parts, owner_scope_ref=owner_scope_ref)
         normalized["input_content"] = input_content
         return normalized
     text = str(content or "")
@@ -411,11 +423,15 @@ def normalize_kop_message_content(content: Any) -> dict[str, Any]:
     }
 
 
-def normalize_kop_messages(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def normalize_kop_messages(
+    messages: List[Dict[str, Any]], *, owner_scope_ref: str | None = None
+) -> List[Dict[str, Any]]:
     normalized: List[Dict[str, Any]] = []
     for message in messages or []:
         role = str(message.get("role") or "user")
-        normalized_content = normalize_kop_message_content(message.get("content", ""))
+        normalized_content = normalize_kop_message_content(
+            message.get("content", ""), owner_scope_ref=owner_scope_ref
+        )
         normalized.append(
             {
                 "role": role,
@@ -430,7 +446,9 @@ def normalize_kop_messages(messages: List[Dict[str, Any]]) -> List[Dict[str, Any
     return normalized
 
 
-def normalize_responses_input(input_payload: Any) -> List[Dict[str, Any]]:
+def normalize_responses_input(
+    input_payload: Any, *, owner_scope_ref: str | None = None
+) -> List[Dict[str, Any]]:
     if isinstance(input_payload, str):
         return [
             {
@@ -446,5 +464,5 @@ def normalize_responses_input(input_payload: Any) -> List[Dict[str, Any]]:
             }
         ]
     if isinstance(input_payload, list):
-        return normalize_kop_messages(input_payload)
+        return normalize_kop_messages(input_payload, owner_scope_ref=owner_scope_ref)
     return []

ksadk/conversations/projector.py

@@ -203,6 +203,7 @@ def project_conversation_item(
         )
         payload = {
             "interactionId": event.interaction_id,
+            "callId": getattr(event.request, "call_id", None),
             "kind": getattr(event.request, "kind", event.interaction_kind),
             "detail": getattr(event.request, "detail", None),
             "prompt": getattr(event.request, "prompt", None),
@@ -250,7 +251,7 @@ def project_conversation_item(
         schema = "conversation.item.error/v1"
         payload = {
             "status": "failed" if isinstance(event, RunFailed) else "canceled",
-            "error": event.error.message if isinstance(event, RunFailed) else event.reason or ""
+            "error": event.error.message if isinstance(event, RunFailed) else event.reason or "",
         }
     elif isinstance(event, (ContinuationCreated, ContinuationResumed)):
         kind = "progress"
@@ -524,9 +525,7 @@ def _item_snapshot(
 def _artifact_payload(snapshot: ContentSnapshot | None) -> dict[str, Any]:
     if snapshot is None:
         return {}
-    artifact = next(
-        (part for part in snapshot.parts if isinstance(part, ArtifactContent)), None
-    )
+    artifact = next((part for part in snapshot.parts if isinstance(part, ArtifactContent)), None)
     if artifact is None:
         return {}
     return {
@@ -583,8 +582,7 @@ def _is_codex_goal_item(event: RuntimeEvent) -> bool:
         isinstance(event, (ItemStarted, ItemUpdated, ItemSnapshotReplaced, ItemCompleted))
         and event.item_kind == "data"
         and event.source.framework == "codex"
-        and event.source.metadata.get("method")
-        in {"thread/goal/updated", "thread/goal/cleared"}
+        and event.source.metadata.get("method") in {"thread/goal/updated", "thread/goal/cleared"}
     )
 
 

ksadk/conversations/runtime_baseline.py

@@ -0,0 +1,37 @@
+"""Context-engine baseline recording kept outside the stream hot path."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Mapping
+from typing import Any
+
+
+def record_baseline_turn(
+    *,
+    prepared: Any,
+    model: str | None,
+    usage: Any,
+    ptl: bool,
+    attempts: int,
+    turn_start_monotonic: float | None,
+) -> None:
+    """Record one env-gated baseline turn without affecting decisions."""
+
+    from ksadk.context_engine.baseline import record_baseline_turn as record
+
+    latency_ms = None
+    if turn_start_monotonic is not None:
+        latency_ms = int((time.monotonic() - turn_start_monotonic) * 1000)
+    record(
+        getattr(prepared, "shadow_context_plan", None),
+        session_id=getattr(prepared, "session_id", ""),
+        invocation_id=getattr(prepared, "invocation_id", ""),
+        model=str(model or ""),
+        usage=usage if isinstance(usage, Mapping) else None,
+        compaction_triggered=bool(getattr(prepared, "compaction_triggered", False)),
+        compaction_trigger=str(getattr(prepared, "compaction_trigger", "") or ""),
+        prompt_too_long=ptl,
+        retry_attempts=attempts,
+        turn_latency_ms=latency_ms,
+    )

ksadk/conversations/runtime_invocation.py

@@ -40,6 +40,7 @@ from ksadk.conversations.runtime_observability import (
     _set_conversation_usage_attributes,
     _set_prompt_cache_attributes,
     _set_prompt_source_attributes,
+    _set_skill_eval_result_attributes,
     _span_feedback_metadata,
 )
 from ksadk.conversations.runtime_persistence import (
@@ -55,7 +56,10 @@ from ksadk.conversations.runtime_resume import (
     _merge_agentengine_metadata,
 )
 from ksadk.model_policy import fallback_model_for_exception, model_policy_options_for_model
+from ksadk.runtime.skill_eval_result import skill_eval_response_fields
 from ksadk.runtime_context import (
+    TRUSTED_IDENTITY_METADATA_KEY,
+    PlatformIdentityContext,
     PlatformInvocationContext,
     platform_invocation_scope,
     tool_execution_scope,
@@ -123,6 +127,7 @@ async def invoke_conversation_once(
     agent_system: str = "",
     agent_task: str = "",
     prompt_integration_mode: str = "",
+    resume_lifecycle_prepared: bool = False,
 ) -> tuple[str, dict[str, Any]]:
     """非流式 turn 编排入口。
 
@@ -159,6 +164,7 @@ async def invoke_conversation_once(
             agent_system=agent_system,
             agent_task=agent_task,
             prompt_integration_mode=prompt_integration_mode,
+            resume_lifecycle_prepared=resume_lifecycle_prepared,
         )
         # prepared 之后的 run_status 写入复用 prepared 的 mode/trigger
         run_mode = prepared.run_mode
@@ -178,15 +184,22 @@ async def invoke_conversation_once(
             )
         raise
     _inject_runner_deferred_tools_for_request(runner, prepared)
+    effective_user_id = prepared.user_id or user_id
+    invocation_identity = PlatformIdentityContext.from_payload(
+        dict(request_metadata or {}).get(TRUSTED_IDENTITY_METADATA_KEY)
+    )
     ambient_contexts = _build_runner_ambient_contexts(
         runner=runner,
-        user_id=user_id,
+        user_id=effective_user_id,
         user_input=prepared.user_input,
     )
     prepared.memory_recall_events = ambient_contexts.get("memory_recall_events", [])
+    from ksadk.session_context import SessionContext
+
     runtime_context = PlatformInvocationContext(
+        session=SessionContext.from_payload(prepared.session_context),
         agent_id=agent_id,
-        user_id=user_id,
+        user_id=effective_user_id,
         account_id=str(account_id or ""),
         session_id=prepared.session_id,
         history=list(prepared.history),
@@ -205,13 +218,14 @@ async def invoke_conversation_once(
         kb_context=ambient_contexts.get("kb_context"),
         memory_context=ambient_contexts.get("memory_context"),
         tool_approval_mode=str(prepared.request_metadata.get("tool_approval_mode") or ""),
+        identity=invocation_identity,
     )
     runner_name = _runner_name(runner)
     async with _conversation_span_scope(runner_name) as span:
         _set_conversation_span_attributes(
             span,
             agent_id=agent_id,
-            user_id=user_id,
+            user_id=effective_user_id,
             session_id=prepared.session_id,
             invocation_id=prepared.invocation_id,
             runner_name=runner_name,
@@ -349,6 +363,9 @@ async def invoke_conversation_once(
         if last_invoke_error is not None:
             raise last_invoke_error
         result = result or {}
+        result_fields = skill_eval_response_fields(result)
+        if result_fields:
+            _set_skill_eval_result_attributes(span, result_fields["skill_eval_result"])
         output_text = strip_reasoning_markup(str(result.get("output", "")))
         result_usage = _normalize_usage_payload(result.get("usage"))
         result_last_usage = _normalize_usage_payload(
@@ -429,7 +446,7 @@ async def invoke_conversation_once(
         )
         await _auto_save_ltm_turn(
             agent_id=agent_id,
-            user_id=user_id,
+            user_id=effective_user_id,
             prepared=prepared,
             output_text=output_text,
             runner_type=runtime_context.runner_type,
@@ -445,6 +462,7 @@ async def invoke_conversation_once(
             run_trigger=run_trigger,
         )
         result_payload: dict[str, Any] = {
+            **result_fields,
             "output_text": output_text,
             "model": model,
             "metadata": {

ksadk/conversations/runtime_observability.py

@@ -45,6 +45,8 @@ def _normalize_usage_payload(usage: Mapping[str, Any] | None) -> dict[str, Any]:
         "total_tokens",
         "prompt_tokens",
         "completion_tokens",
+        "cached_tokens",
+        "reasoning_tokens",
     ):
         value = usage.get(key)
         if value is None:
@@ -57,6 +59,23 @@ def _normalize_usage_payload(usage: Mapping[str, Any] | None) -> dict[str, Any]:
         value = usage.get(key)
         if isinstance(value, Mapping):
             normalized[key] = dict(value)
+    for source_key, target_key in (
+        ("input_tokens_details", "input_token_details"),
+        ("output_tokens_details", "output_token_details"),
+    ):
+        value = usage.get(source_key)
+        if isinstance(value, Mapping) and target_key not in normalized:
+            normalized[target_key] = dict(value)
+    cached_tokens = normalized.get("cached_tokens")
+    if cached_tokens is not None:
+        input_details = normalized.setdefault("input_token_details", {})
+        if not any(key in input_details for key in ("cached_tokens", "cached", "cache_read")):
+            input_details["cached"] = cached_tokens
+    reasoning_tokens = normalized.get("reasoning_tokens")
+    if reasoning_tokens is not None:
+        output_details = normalized.setdefault("output_token_details", {})
+        if not any(key in output_details for key in ("reasoning_tokens", "reasoning")):
+            output_details["reasoning"] = reasoning_tokens
     prompt_details = usage.get("prompt_tokens_details")
     if isinstance(prompt_details, Mapping):
         normalized["prompt_tokens_details"] = dict(prompt_details)
@@ -339,10 +358,21 @@ def _set_conversation_output_attributes(span: Any | None, output_text: str | Non
         _set_span_attribute(span, key, text)
 
 
+def _set_skill_eval_result_attributes(span: Any | None, result: Mapping[str, Any]) -> None:
+    """Attach structured evidence without changing trace/observation output text."""
+    payload = json.dumps({"skill_eval_result": dict(result)}, ensure_ascii=False)
+    _set_span_attribute(span, "metadata", payload)
+    _set_span_attribute(
+        span, "langfuse.trace.metadata.skill_eval_result",
+        json.dumps(dict(result), ensure_ascii=False),
+    )
+
+
 def _set_conversation_usage_attributes(
     span: Any | None,
     usage: Mapping[str, Any] | None,
 ) -> None:
+    """Write run-level usage as KsADK diagnostics, never as model generation usage."""
     normalized = _normalize_usage_payload(usage)
     if not normalized:
         return
@@ -372,19 +402,14 @@ def _set_conversation_usage_attributes(
         )
 
     attributes = {
-        "gen_ai.usage.input_tokens": input_tokens,
-        "gen_ai.usage.output_tokens": output_tokens,
-        "gen_ai.usage.total_tokens": total_tokens,
-        "llm.usage.prompt_tokens": input_tokens,
-        "llm.usage.completion_tokens": output_tokens,
-        "llm.usage.total_tokens": total_tokens,
+        "ksadk.runtime.usage.input_tokens": input_tokens,
+        "ksadk.runtime.usage.output_tokens": output_tokens,
+        "ksadk.runtime.usage.total_tokens": total_tokens,
     }
     if cache_read_tokens:
-        attributes["gen_ai.usage.cache_read.input_tokens"] = cache_read_tokens
-        attributes["llm.usage.cache_read.input_tokens"] = cache_read_tokens
+        attributes["ksadk.runtime.usage.cache_read.input_tokens"] = cache_read_tokens
     if reasoning_tokens:
-        attributes["gen_ai.usage.reasoning.output_tokens"] = reasoning_tokens
-        attributes["llm.usage.reasoning_tokens"] = reasoning_tokens
+        attributes["ksadk.runtime.usage.reasoning.output_tokens"] = reasoning_tokens
 
     for key, value in attributes.items():
         if value:
@@ -405,6 +430,10 @@ def _set_conversation_span_attributes(
     if span is None:
         return
     try:
+        # A conversation span wraps the whole run. Real token-bearing model
+        # calls are separate child generations; keep this span out of the
+        # generation namespace so trace aggregation does not double-count.
+        span.set_attribute("openinference.span.kind", "AGENT")
         span.set_attribute("ksadk.agent_id", agent_id)
         span.set_attribute("ksadk.user_id", user_id)
         span.set_attribute("ksadk.session_id", session_id)

ksadk/conversations/runtime_payloads.py

@@ -15,6 +15,8 @@ from ksadk.conversations.runtime_observability import (
     _responses_usage_payload,
     _usage_from_metadata,
 )
+from ksadk.runtime.skill_eval_result import skill_eval_response_fields
+from ksadk.runtime.timing import normalize_timing
 from ksadk.sessions import SessionEvent
 
 
@@ -91,6 +93,7 @@ class PreparedConversationTurn:
     memory_write_mode: str = "candidate"
     flush_before_compaction: bool = True
     provider_ref: str = "local-default"
+    session_context: dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass
@@ -130,6 +133,8 @@ def build_responses_payload(
     status: str = "completed",
     metadata: Mapping[str, Any] | None = None,
     usage: Mapping[str, Any] | None = None,
+    timing: Mapping[str, Any] | None = None,
+    skill_eval_result: Mapping[str, Any] | None = None,
     incomplete_details: Mapping[str, Any] | None = None,
     error: Mapping[str, Any] | None = None,
     output_items: Sequence[Mapping[str, Any]] | None = None,
@@ -173,7 +178,11 @@ def build_responses_payload(
         "tools": [],
         "output": output,
         "output_text": output_text,
+        **skill_eval_response_fields({"skill_eval_result": skill_eval_result}),
         "usage": usage_payload,
+        **(
+            {"timing": normalized_timing} if (normalized_timing := normalize_timing(timing)) else {}
+        ),
         "session_id": session_id,
     }