agentengine-sdk-python 0.8.4__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:
@@ -493,9 +501,7 @@ def _project_approval_events(
                         )
                         if not isinstance(first_action, Mapping):
                             first_action = {}
-                        interaction_id = runtime_event.get("interaction_id") or req.get(
-                            "call_id"
-                        )
+                        interaction_id = runtime_event.get("interaction_id") or req.get("call_id")
                         interrupt_info = {
                             "approval_request_id": interaction_id,
                             "id": interaction_id,
@@ -528,17 +534,11 @@ def _project_approval_events(
         # 这里统一提取，避免 Name fallback 成 "approval" 导致前端显示不对。
         action_requests = interrupt_info.get("action_requests")
         first_action = (
-            action_requests[0]
-            if isinstance(action_requests, list) and action_requests
-            else {}
+            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"
-        )
+        tool_name = interrupt_info.get("tool_name") or first_action.get("name") or "approval"
         entry: dict[str, Any] = {
             "SeqId": request.get("SeqId"),
             "Type": "approval",
@@ -559,10 +559,7 @@ def _project_approval_events(
         )
         if arguments is not None:
             entry["Args"] = arguments
-        description = (
-            interrupt_info.get("description")
-            or first_action.get("description")
-        )
+        description = interrupt_info.get("description") or first_action.get("description")
         if description:
             entry["Description"] = str(description)
         review_configs = interrupt_info.get("review_configs")
@@ -721,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
@@ -821,9 +818,7 @@ def _normalize_canonical_event(
             # 嵌在 action_requests[0] 里，detail 顶层没有，需要提取。
             action_requests = detail.get("action_requests")
             first_action = (
-                action_requests[0]
-                if isinstance(action_requests, list) and action_requests
-                else {}
+                action_requests[0] if isinstance(action_requests, list) and action_requests else {}
             )
             if not isinstance(first_action, Mapping):
                 first_action = {}
@@ -833,20 +828,16 @@ def _normalize_canonical_event(
             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 first_action.get("name")
-                or kind,
+                "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"),
+                "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"),
+                "approval_message": detail.get("message") or first_action.get("description"),
             }
             # Preserve ag-ui protocol tag from source metadata.
             source = runtime_event.get("source") or {}

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/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,
@@ -180,9 +184,13 @@ 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", [])
@@ -191,7 +199,7 @@ async def invoke_conversation_once(
     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),
@@ -210,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,
@@ -354,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(
@@ -434,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,
@@ -450,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
 
 
@@ -131,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,
@@ -174,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,
     }
 

ksadk/conversations/runtime_persistence.py

@@ -19,7 +19,13 @@ from ksadk.conversations.runtime_constants import (
     EVENT_SCAN_PAGE_SIZE,
 )
 from ksadk.conversations.runtime_observability import _extract_deferred_tool_names
+from ksadk.runtime_context import TRUSTED_IDENTITY_METADATA_KEY, PlatformIdentityContext
 from ksadk.sessions import Session, SessionEvent, resolve_session_service
+from ksadk.sessions.invocation_identity import (
+    bind_or_validate_session_identity,
+    identity_native_user_id,
+    require_complete_platform_identity,
+)
 
 
 async def ensure_conversation_session(
@@ -28,20 +34,110 @@ async def ensure_conversation_session(
     user_id: str,
     session_id: Optional[str],
     session_service_provider: Callable[[], Any] | None = None,
+    invocation_identity: Any = None,
+    allow_agent_alias: bool = False,
 ) -> Session:
-    """确保会话存在，并在显式 session_id 冲突时做 owner 校验。"""
+    """确保会话存在，并在读取历史前校验可信业务 owner。"""
     service = (session_service_provider or resolve_session_service)()
+    identity = require_complete_platform_identity(invocation_identity)
     if session_id:
-        existing = await service.get_session(session_id)
+        # Ownership is decided from metadata/state before any transcript read.
+        existing = await service.get_session_metadata(session_id)
         if existing:
-            if existing.agent_id != agent_id or existing.user_id != user_id:
-                raise HTTPException(
-                    status_code=409,
-                    detail="Session id belongs to a different agent or user",
+            if existing.agent_id != agent_id:
+                if allow_agent_alias and not identity.is_empty:
+                    # Hosted workers receive an internal instance alias while
+                    # the control plane persists the public AgentId. The
+                    # worker is already scoped to this session store; adopt
+                    # the persisted owner before validating business identity.
+                    agent_id = existing.agent_id
+                elif not identity.is_empty:
+                    raise HTTPException(status_code=404, detail="Session not found")
+                else:
+                    raise HTTPException(
+                        status_code=409,
+                        detail="Session id belongs to a different agent or user",
+                    )
+            if existing.agent_id == agent_id:
+                return await bind_or_validate_session_identity(
+                    service=service,
+                    session=existing,
+                    identity=identity,
+                    requested_user_id=user_id,
                 )
-            return existing
-        return await service.create_session(agent_id, user_id, session_id=session_id)
-    return await service.create_session(agent_id, user_id)
+        native_user_id = identity_native_user_id(identity) or user_id
+        created = await service.create_session(agent_id, native_user_id, session_id=session_id)
+        if created.agent_id != agent_id:
+            raise HTTPException(status_code=404, detail="Session not found")
+        return await bind_or_validate_session_identity(
+            service=service,
+            session=created,
+            identity=identity,
+            requested_user_id=user_id,
+        )
+    native_user_id = identity_native_user_id(identity) or user_id
+    created = await service.create_session(agent_id, native_user_id)
+    return await bind_or_validate_session_identity(
+        service=service,
+        session=created,
+        identity=identity,
+        requested_user_id=user_id,
+    )
+
+
+async def require_conversation_session(
+    *,
+    agent_id: str,
+    user_id: str,
+    session_id: str,
+    session_service_provider: Callable[[], Any] | None = None,
+    invocation_identity: Any = None,
+) -> Session:
+    """Authorize an existing session without creating state on a read/control path."""
+
+    service = (session_service_provider or resolve_session_service)()
+    identity = require_complete_platform_identity(invocation_identity)
+    existing = await service.get_session_metadata(session_id)
+    if existing is None:
+        raise HTTPException(status_code=404, detail="Session not found")
+    if existing.agent_id != agent_id:
+        if not identity.is_empty:
+            raise HTTPException(status_code=404, detail="Session not found")
+        raise HTTPException(
+            status_code=409,
+            detail="Session id belongs to a different agent or user",
+        )
+    return await bind_or_validate_session_identity(
+        service=service,
+        session=existing,
+        identity=identity,
+        requested_user_id=user_id,
+    )
+
+
+async def prepare_stream_identity_session(
+    *,
+    agent_id: str,
+    user_id: str,
+    session_id: str | None,
+    request_metadata: Mapping[str, Any] | None,
+    session_service_provider: Callable[[], Any] | None = None,
+) -> tuple[str, str | None, PlatformIdentityContext, dict[str, Any]]:
+    """Authorize a stream before preview reads and hide its private identity carrier."""
+
+    public_metadata = dict(request_metadata or {})
+    identity_payload = public_metadata.pop(TRUSTED_IDENTITY_METADATA_KEY, None)
+    identity = PlatformIdentityContext.from_payload(identity_payload)
+    if not identity_payload:
+        return user_id, session_id, identity, public_metadata
+    session = await ensure_conversation_session(
+        agent_id=agent_id,
+        user_id=user_id,
+        session_id=session_id,
+        session_service_provider=session_service_provider,
+        invocation_identity=identity_payload,
+    )
+    return session.user_id, session.id, identity, public_metadata
 
 
 async def append_conversation_event(

ksadk/conversations/runtime_preparation.py

@@ -73,6 +73,8 @@ from ksadk.conversations.runtime_resume import (
 )
 from ksadk.ids import new_run_id
 from ksadk.model_policy import model_policy_options_for_model
+from ksadk.runtime_context import TRUSTED_IDENTITY_METADATA_KEY, PlatformIdentityContext
+from ksadk.session_context import split_session_context
 from ksadk.sessions import SessionEvent, resolve_session_service
 
 logger = logging.getLogger(__name__)
@@ -122,25 +124,25 @@ async def build_run_input(
     caller_run_trigger = trigger_from_resume_input(resume_input)
     provider = session_service_provider or resolve_session_service
     service = provider()
-    resolved_user_id = user_id
-    if session_id:
-        existing_session = await service.get_session(session_id)
-        if existing_session and existing_session.user_id:
-            resolved_user_id = existing_session.user_id
+    private_request_metadata = dict(request_metadata or {})
+    identity_payload = private_request_metadata.pop(TRUSTED_IDENTITY_METADATA_KEY, None)
+    invocation_identity = PlatformIdentityContext.from_payload(identity_payload)
 
     session = await ensure_conversation_session(
         agent_id=agent_id,
-        user_id=resolved_user_id,
+        user_id=user_id,
         session_id=session_id,
         session_service_provider=provider,
+        invocation_identity=invocation_identity,
     )
+    resolved_user_id = session.user_id
     resolved_session_id = session.id
     resolved_invocation_id = str(invocation_id or new_run_id(resolved_session_id))
     resolved_model_metadata = await _resolve_runtime_model_metadata(
         model,
         model_metadata=model_metadata,
     )
-    session_context, normalized_request_metadata = split_session_context(request_metadata)
+    session_context, normalized_request_metadata = split_session_context(private_request_metadata)
     normalized_custom_metadata = dict(custom_metadata or {})
     policy_model = model or os.getenv("OPENAI_MODEL_NAME") or os.getenv("MODEL_NAME")
     normalized_model_options = {
@@ -205,6 +207,8 @@ async def build_run_input(
                 session_context=session_context.to_payload(),
                 session_id=resolved_session_id,
                 invocation_id=resolved_invocation_id,
+                user_id=resolved_user_id,
+                agent_id=agent_id,
                 user_input="",
                 user_display_input="",
                 history=history,
@@ -323,6 +327,8 @@ async def build_run_input(
             session_context=session_context.to_payload(),
             session_id=resolved_session_id,
             invocation_id=resolved_invocation_id,
+            user_id=resolved_user_id,
+            agent_id=agent_id,
             user_input=resume_text,
             user_display_input=resume_text,
             history=history,