agentengine-sdk-python 0.8.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

ksadk/conversations/runtime_preparation.py

@@ -1,13 +1,19 @@
 from __future__ import annotations
 
+import logging
 import os
 from typing import Any, Callable, Dict, Mapping, Optional, Sequence
 
+from ksadk.context_engine.shadow_plan import (
+    build_shadow_context_plan_dict,
+    minimal_shadow_context_plan_dict,
+)
 from ksadk.conversations.attachments import compact_attachment_result_for_session
 from ksadk.conversations.context import (
     build_history_from_events,
     build_request_history,
     build_responses_history_from_messages,
+    canonical_event_type,
     project_responses_history,
 )
 from ksadk.conversations.model_options import normalize_model_options
@@ -66,7 +72,9 @@ 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.sessions import resolve_session_service
+from ksadk.sessions import SessionEvent, resolve_session_service
+
+logger = logging.getLogger(__name__)
 
 
 async def build_run_input(
@@ -87,6 +95,21 @@ async def build_run_input(
     governance_state: RuntimeGovernanceState | None = None,
     session_service_provider: Callable[[], Any] | None = None,
     run_mode: str = RUN_MODE_FOREGROUND,
+    runner: Any | None = None,
+    runtime_type: str | None = None,
+    agent_system: str = "",
+    agent_task: str = "",
+    prompt_integration_mode: str = "",
+    context_engine_rollout: str | None = None,
+    memory_recall_enabled: bool | None = None,
+    memory_write_rollout: str | None = None,
+    memory_enabled: bool | None = None,
+    memory_write_mode: str = "candidate",
+    flush_before_compaction: bool = True,
+    provider_ref: str = "local-default",
+    deployment_mode: str = "local",
+    agent_max_input_tokens: int | None = None,
+    agent_reserve_output_tokens: int | None = None,
 ) -> PreparedConversationTurn:
     """构建一次 turn 的标准运行输入，并在进入模型前做上下文投影/压缩。
 
@@ -124,6 +147,26 @@ async def build_run_input(
     }
     normalized_instructions = str(instructions or "").strip()
 
+    # PR A：当 agent_system/agent_task 非空时，编译真实 CompiledPrompt（含 stable section）。
+    # 仅用于 hash/trace/future projection，不改 Runner 输入（payload["instructions"] 不变）。
+    # platform_policy_source 默认 EnvPlatformPolicySource（env 未设→不产 platform_safety）。
+    compiled_prompt: dict[str, Any] | None = None
+    if (agent_system or "").strip() or (agent_task or "").strip():
+        from ksadk.prompts.resolved import (
+            ResolvedPromptSources,
+            compile_resolved_prompt_dict,
+            get_default_platform_policy_source,
+        )
+
+        compiled_prompt = compile_resolved_prompt_dict(
+            ResolvedPromptSources(
+                agent_system=agent_system,
+                agent_task=agent_task,
+                request_instructions=normalized_instructions,
+                platform_policy_source=get_default_platform_policy_source(),
+            )
+        )
+
     if resume_input is not None:
         if not session_id:
             raise ValueError("Responses resume input requires session_id")
@@ -184,6 +227,16 @@ async def build_run_input(
                 resume_input=normalized_resume_input,
                 run_mode=caller_run_mode,
                 run_trigger=RUN_TRIGGER_CHECKPOINT_RESUME,
+                shadow_context_plan=minimal_shadow_context_plan_dict(
+                    runner=runner, runtime_type=runtime_type, deployment_mode=deployment_mode
+                ),
+                compiled_prompt=None,
+                memory_write_rollout=memory_write_rollout,
+                memory_enabled=memory_enabled,
+                memory_recall_enabled=memory_recall_enabled,
+                memory_write_mode=memory_write_mode,
+                flush_before_compaction=flush_before_compaction,
+                provider_ref=provider_ref,
             )
 
         is_approval_resume = _is_approval_resume_input(normalized_resume_input)
@@ -287,6 +340,23 @@ async def build_run_input(
             resume_input=effective_resume_input,
             run_mode=caller_run_mode,
             run_trigger=RUN_TRIGGER_APPROVAL_RESUME,
+            shadow_context_plan=build_shadow_context_plan_dict(
+                instructions=normalized_instructions,
+                history=history,
+                user_input=resume_text,
+                request_metadata=normalized_request_metadata,
+                runner=runner,
+                runtime_type=runtime_type,
+                model_metadata=resolved_model_metadata,
+                deployment_mode=deployment_mode,
+            ),
+            compiled_prompt=None,
+            memory_write_rollout=memory_write_rollout,
+            memory_enabled=memory_enabled,
+            memory_recall_enabled=memory_recall_enabled,
+            memory_write_mode=memory_write_mode,
+            flush_before_compaction=flush_before_compaction,
+            provider_ref=provider_ref,
         )
 
     normalized_messages = _normalized_conversation_messages(messages)
@@ -349,6 +419,17 @@ async def build_run_input(
         user_input=user_input or user_display_input,
     )
 
+    # compaction_owner 硬门控（方案 §6.2）：从 capability 取 owner，非 ksadk 时不走双阈值
+    from ksadk.context_engine.capabilities import (
+        capabilities_for_runner,
+        capabilities_for_runtime_type,
+    )
+
+    _caps = (
+        capabilities_for_runner(runner)
+        if runner is not None
+        else capabilities_for_runtime_type(runtime_type)
+    )
     checkpoint = await _compact_conversation_history_with_governance(
         governance_state,
         session_id=resolved_session_id,
@@ -357,6 +438,9 @@ async def build_run_input(
         model=model,
         model_metadata=resolved_model_metadata,
         session_service_provider=provider,
+        # PR D1：双阈值门控透传。ksadk_hosted → soft/hard proactive compact；否则旧单阈值。
+        prompt_integration_mode=prompt_integration_mode,
+        compaction_owner=_caps.compaction_owner,
     )
     event_history = await service.get_events(resolved_session_id)
     history = build_history_from_events(event_history)
@@ -372,10 +456,32 @@ async def build_run_input(
         request_responses_history,
         responses_history,
     )
+    # The current user event is persisted before context construction so an
+    # interrupted turn remains auditable.  That event belongs to
+    # ``current_input`` though, not to prior history.  Keep the legacy
+    # ``prepared.history`` contract unchanged for non-hosted paths, while the
+    # KsADK-owned planner receives only events from earlier invocations.  Using
+    # invocation_id (instead of text equality) also handles users deliberately
+    # repeating the same message across turns.
+    hosted_history = _merge_request_history_with_session_history(
+        request_history,
+        build_history_from_events(
+            [event for event in event_history if event.invocation_id != resolved_invocation_id]
+        ),
+    )
+    # PR D2：取最新 checkpoint 的 WorkingState（仅 ksadk_hosted 路径重注入）。
+    # 非 ksadk_hosted → working_state=None（零注入，Runner 输入与旧逻辑一致）。
+    # PTL retry 后 _refresh_history 也会重读 events，但此处 build_run_input 首次构建时取一次即可；
+    # PTL 路径若产生新 checkpoint，retry 用 prepared 已有 working_state（保守：不中途换）。
+    working_state: dict[str, Any] | None = None
+    if prompt_integration_mode == "ksadk_hosted":
+        working_state = _latest_checkpoint_working_state(event_history)
 
-    return PreparedConversationTurn(
+    prepared = PreparedConversationTurn(
         session_id=resolved_session_id,
         invocation_id=resolved_invocation_id,
+        user_id=resolved_user_id,
+        agent_id=agent_id,
         user_input=user_input,
         user_display_input=user_display_input or user_input,
         history=history,
@@ -405,7 +511,171 @@ async def build_run_input(
         ),
         run_mode=caller_run_mode,
         run_trigger=caller_run_trigger,
+        shadow_context_plan=build_shadow_context_plan_dict(
+            instructions=normalized_instructions,
+            history=hosted_history if prompt_integration_mode == "ksadk_hosted" else history,
+            user_input=user_input,
+            request_metadata=normalized_request_metadata,
+            runner=runner,
+            runtime_type=runtime_type,
+            model_metadata=resolved_model_metadata,
+            prompt_shadow=compiled_prompt,
+            prompt_integration_mode=prompt_integration_mode,
+            deployment_mode=deployment_mode,
+        ),
+        compiled_prompt=compiled_prompt,
+        prompt_integration_mode=prompt_integration_mode,
+        working_state=working_state,
+        memory_write_rollout=memory_write_rollout,
+        memory_enabled=memory_enabled,
+        memory_recall_enabled=memory_recall_enabled,
+        memory_write_mode=memory_write_mode,
+        flush_before_compaction=flush_before_compaction,
+        provider_ref=provider_ref,
+    )
+    # PR E：ksadk_hosted + V2 开关时运行真实 hosted 链路，回填 context_plan/assembled_input。
+    # 失败回退空字段（prepared 字段语义完整），不阻断主链路。
+    await _maybe_fill_hosted_pipeline(
+        prepared,
+        compiled_prompt=compiled_prompt,
+        user_input=user_input,
+        history=hosted_history,
+        working_state=working_state,
+        model_metadata=resolved_model_metadata,
+        prompt_integration_mode=prompt_integration_mode,
+        context_engine_rollout=context_engine_rollout,
+        memory_recall_enabled=memory_recall_enabled,
+        runtime_type=runtime_type,
+        session_id=resolved_session_id,
+        invocation_id=resolved_invocation_id,
+        user_id=resolved_user_id,
+        agent_id=agent_id,
+        agent_max_input_tokens=agent_max_input_tokens,
+        agent_reserve_output_tokens=agent_reserve_output_tokens,
+    )
+    return prepared
+
+
+async def _maybe_fill_hosted_pipeline(
+    prepared: PreparedConversationTurn,
+    *,
+    compiled_prompt: dict[str, Any] | None,
+    user_input: str,
+    history: list[dict[str, str]],
+    working_state: dict[str, Any] | None,
+    model_metadata: dict[str, Any],
+    prompt_integration_mode: str,
+    context_engine_rollout: str | None,
+    memory_recall_enabled: bool | None,
+    agent_max_input_tokens: int | None = None,
+    agent_reserve_output_tokens: int | None = None,
+    runtime_type: str | None,
+    session_id: str,
+    invocation_id: str,
+    user_id: str,
+    agent_id: str,
+) -> None:
+    """PR E：在 ksadk_hosted + V2 时运行 hosted 链路并回填 plan/assembly。
+
+    门控三重：``KSADK_CONTEXT_ENGINE_V2_ENABLED`` × ``prompt_integration_mode=="ksadk_hosted"``
+    × 已编译出含 prompt_content 的 CompiledPrompt（agent_system/agent_task 非空）。任一不满足
+    → 不回填（走旧 PR B 分支，字节级一致）。
+
+    仅对 ``prompt_owner=ksadk`` 的 runtime（langgraph 系）启用；native_runtime（codex）不进入，
+    保证 Managed Codex 不被接管（方案 §6.2 / PCM-RUNNER-003）。
+    """
+    from ksadk.context_engine.capabilities import (
+        assert_capability_not_circuit_open,
+        capabilities_for_runtime_type,
     )
+    from ksadk.context_engine.hosted_pipeline import (
+        default_hosted_contributors,
+        hosted_pipeline_enabled,
+        run_hosted_pipeline,
+    )
+
+    if (
+        not hosted_pipeline_enabled(rollout=context_engine_rollout)
+        or prompt_integration_mode != "ksadk_hosted"
+    ):
+        return
+    if (
+        not isinstance(compiled_prompt, dict)
+        or not str(compiled_prompt.get("prompt_content") or "").strip()
+    ):
+        return
+    caps = capabilities_for_runtime_type(runtime_type)
+    if caps.prompt_owner != "ksadk":
+        return
+    # 门禁：该 Runner 若已因 capability mismatch 熔断，回退旧路径（方案 §6.1）。不抛给主链路。
+    try:
+        assert_capability_not_circuit_open(runtime_type=runtime_type, label="hosted_pipeline")
+    except Exception:  # noqa: BLE001
+        logger.info("hosted pipeline skipped for session=%s: capability circuit open", session_id)
+        return
+    # PR E：注入默认 Contributors（MemoryRecall 等）进真实链路（方案 §8.7）。
+    contributors = default_hosted_contributors(
+        user_id=user_id,
+        agent_id=agent_id,
+        memory_recall_enabled=memory_recall_enabled,
+    )
+    try:
+        result = await run_hosted_pipeline(
+            compiled_prompt=compiled_prompt,
+            user_input=user_input,
+            history=history,
+            working_state=working_state,
+            model_metadata=model_metadata,
+            contributors=contributors,
+            # 与 shadow_plan 口径一致：ksadk_hosted + prompt_owner=ksadk + langgraph → ksadk_hosted
+            integration_mode=(
+                "ksadk_hosted"
+                if prompt_integration_mode == "ksadk_hosted"
+                and caps.prompt_owner == "ksadk"
+                and runtime_type == "langgraph"
+                else caps.integration_mode
+            ),
+            accounting_accuracy=caps.token_accounting,
+            session_id=session_id,
+            invocation_id=invocation_id,
+            user_id=user_id,
+            agent_id=agent_id,
+            agent_max_input_tokens=agent_max_input_tokens,
+            agent_reserve_output_tokens=agent_reserve_output_tokens,
+        )
+    except Exception:  # noqa: BLE001
+        logger.warning(
+            "hosted pipeline failed for session=%s; falling back to PR B path",
+            session_id,
+        )
+        return
+    if result is None:
+        return
+    prepared.context_plan = result.plan
+    prepared.assembled_input = {
+        "format": result.assembled.format,
+        "system": result.assembled.system,
+        "messages": list(result.assembled.messages),
+        "estimated_tokens": result.assembled.estimated_tokens,
+        "warnings": list(result.assembled.warnings),
+    }
+
+
+def _latest_checkpoint_working_state(events: Sequence[SessionEvent]) -> dict[str, Any] | None:
+    """取最新 context_checkpoint 事件的 working_state（PR D2）。
+
+    checkpoint metadata 由 compact_conversation_history 写入（仅 ksadk_hosted）。
+    无 checkpoint 或无 working_state 键时返回 None。
+    """
+    for event in reversed(list(events)):
+        if canonical_event_type(event.event_type) != "context_checkpoint":
+            continue
+        meta = event.metadata or {}
+        ws = meta.get("working_state")
+        if isinstance(ws, dict):
+            return ws
+        return None
+    return None
 
 
 async def _refresh_history(

ksadk/conversations/runtime_resume.py

@@ -15,7 +15,7 @@ from ksadk.conversations.run_kinds import (
     validate_run_mode,
 )
 from ksadk.conversations.runtime_persistence import append_conversation_event
-from ksadk.events.runtime_event import EventType
+from ksadk.events.v1_compat import EventTypeV1 as EventType
 from ksadk.sessions import SessionEvent
 from ksadk.tools.gateway import (
     build_tool_receipt_idempotency_key,
@@ -81,6 +81,11 @@ def _approval_lifecycle_event_type(event: SessionEvent) -> str:
         return "approval_request"
     if event.event_type == EventType.APPROVAL_RESOLVED:
         return "approval_response"
+    # canonical schema-v2:审批请求/应答是 interaction.* 事件。
+    if event.event_type == "interaction.requested":
+        return "approval_request"
+    if event.event_type in {"interaction.resolved", "approval.resolved"}:
+        return "approval_response"
     return canonical_event_type(
         event.event_type,
         author=event.author,
@@ -102,6 +107,20 @@ def _approval_interrupt_info_from_event(event: SessionEvent) -> dict[str, Any]:
         return dict(legacy_detail)
 
     content = event.content or {}
+    # canonical schema-v2 envelope:content["runtime_event"]["request"]["detail"]
+    canonical_payload = content.get("runtime_event")
+    if isinstance(canonical_payload, Mapping):
+        request = canonical_payload.get("request")
+        if isinstance(request, Mapping):
+            raw_detail = request.get("detail")
+            detail = dict(raw_detail) if isinstance(raw_detail, Mapping) else {}
+            approval_id = request.get("call_id") or canonical_payload.get("interaction_id")
+            if approval_id:
+                detail.setdefault("approval_request_id", approval_id)
+                detail.setdefault("id", approval_id)
+            if request.get("call_id"):
+                detail.setdefault("run_id", request.get("call_id"))
+            return detail
     payload = content.get("payload")
     if not isinstance(payload, Mapping):
         return {}

ksadk/conversations/runtime_stream_events.py

@@ -4,6 +4,7 @@ import asyncio
 import time
 from typing import Any, AsyncIterator, Callable, Dict, Mapping, Optional, Sequence
 
+from ksadk.conversations.context import budget_tool_result_for_event
 from ksadk.conversations.run_kinds import (
     RUN_MODE_FOREGROUND,
     trigger_from_resume_input,
@@ -38,10 +39,13 @@ from ksadk.conversations.runtime_observability import (
     _extract_deferred_tool_names,
     _get_conversation_tracer,
     _normalize_usage_payload,
+    _set_context_plan_attributes,
     _set_conversation_input_attributes,
     _set_conversation_output_attributes,
     _set_conversation_span_attributes,
     _set_conversation_usage_attributes,
+    _set_prompt_cache_attributes,
+    _set_prompt_source_attributes,
     _set_span_attribute,
     _span_current_context,
     _span_feedback_metadata,
@@ -79,6 +83,35 @@ from ksadk.tools.gateway import (
 )
 
 
+def _record_baseline_turn(
+    *,
+    prepared: Any,
+    model: str | None,
+    usage: Any,
+    ptl: bool,
+    attempts: int,
+    turn_start_monotonic: float | None,
+) -> None:
+    """env-gated 旁路采集：未启用时 no-op，启用时记录一条 turn 基线。不进决策路径。"""
+    from ksadk.context_engine.baseline import record_baseline_turn
+
+    latency_ms = None
+    if turn_start_monotonic is not None:
+        latency_ms = int((time.monotonic() - turn_start_monotonic) * 1000)
+    record_baseline_turn(
+        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,
+    )
+
+
 async def _iter_conversation_turn_events(
     *,
     runner: Any,
@@ -100,6 +133,9 @@ async def _iter_conversation_turn_events(
     invocation_id: Optional[str] = None,
     session_service_provider: Callable[[], Any] | None = None,
     run_mode: str = RUN_MODE_FOREGROUND,
+    agent_system: str = "",
+    agent_task: str = "",
+    prompt_integration_mode: str = "",
 ) -> AsyncIterator[dict[str, Any]]:
     """Internal semantic event stream shared by protocol serializers."""
     provider = session_service_provider or resolve_session_service
@@ -117,6 +153,8 @@ async def _iter_conversation_turn_events(
             model=model,
             model_metadata=model_metadata,
             session_service_provider=provider,
+            # PR D1：双阈值门控透传（仅 preview 用，不改会话）。
+            prompt_integration_mode=prompt_integration_mode,
         )
     else:
         compaction_preview = CompactionPlan(
@@ -155,6 +193,11 @@ async def _iter_conversation_turn_events(
             governance_state=governance,
             session_service_provider=provider,
             run_mode=entry_run_mode,
+            runner=runner,
+            runtime_type=_runner_type_name(runner),
+            agent_system=agent_system,
+            agent_task=agent_task,
+            prompt_integration_mode=prompt_integration_mode,
         )
         # prepared 之后的 run_status 写入复用 prepared 的 mode/trigger
         run_mode = prepared.run_mode
@@ -180,6 +223,7 @@ async def _iter_conversation_turn_events(
         user_id=user_id,
         user_input=prepared.user_input,
     )
+    prepared.memory_recall_events = ambient_contexts.get("memory_recall_events", [])
     runtime_context = PlatformInvocationContext(
         agent_id=agent_id,
         user_id=user_id,
@@ -200,9 +244,7 @@ async def _iter_conversation_turn_events(
         model_options=prepared.model_options,
         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 ""
-        ),
+        tool_approval_mode=str(prepared.request_metadata.get("tool_approval_mode") or ""),
     )
     if prepared.compaction_triggered:
         yield {
@@ -254,7 +296,11 @@ async def _iter_conversation_turn_events(
             response_id=response_id,
         )
         _set_conversation_input_attributes(span, prepared.user_input or prepared.user_display_input)
+        _set_context_plan_attributes(span, prepared.shadow_context_plan)
         trace_metadata = _span_feedback_metadata(span)
+        _baseline_turn_start = time.monotonic()
+        _baseline_ptl = False
+        _baseline_attempts = 0
         yield {
             "type": "started",
             "session_id": prepared.session_id,
@@ -558,12 +604,24 @@ async def _iter_conversation_turn_events(
                                 tool_call_id = str(
                                     chunk.get("call_id") or chunk.get("run_id") or tool_run_id
                                 ).strip()
+                                # PR C：tool_result 单项预算（仅 ksadk_hosted 门控）。
+                                # bound 进 content.parts[0].text（下一轮 history → 模型输入的那条），  # noqa: E501
+                                # metadata.tool_output 保留原值（UI/Responses 读取方不受影响）。
+                                # enabled=False → (str(output), {}) 与旧逻辑字节级一致。
+                                _tool_output_raw = chunk.get("tool_output", "")
+                                _budget_enabled = prepared.prompt_integration_mode == "ksadk_hosted"
+                                _budgeted_text, _budget_extras = budget_tool_result_for_event(
+                                    tool_name=tool_name,
+                                    tool_output=_tool_output_raw,
+                                    tool_call_id=tool_call_id,
+                                    enabled=_budget_enabled,
+                                )
                                 checkpoint_metadata = _latest_checkpoint_metadata_for_run(
                                     await provider().get_events(prepared.session_id),
                                     tool_run_id,
                                 )
                                 approval_interrupt_info = approval_interrupt_info_from_result(
-                                    chunk.get("tool_output", ""),
+                                    _tool_output_raw,
                                     fallback_tool_name=tool_name,
                                     tool_args=tool_args,
                                     run_id=tool_run_id,
@@ -602,17 +660,18 @@ async def _iter_conversation_turn_events(
                                     session_id=prepared.session_id,
                                     author=runner_name,
                                     role="user",
-                                    text=str(chunk.get("tool_output", "")),
+                                    text=_budgeted_text,
                                     invocation_id=prepared.invocation_id,
                                     event_type="tool_result",
                                     metadata={
                                         "tool_name": tool_name,
-                                        "tool_output": chunk.get("tool_output", ""),
+                                        "tool_output": _tool_output_raw,
                                         "run_id": tool_run_id,
                                         "tool_call_id": tool_call_id,
                                         "observability": _tool_observability_metadata(
-                                            tool_name, chunk.get("tool_output", "")
+                                            tool_name, _tool_output_raw
                                         ),
+                                        **_budget_extras,
                                         "tool_receipt": _tool_receipt_metadata(
                                             session_id=prepared.session_id,
                                             run_id=tool_run_id,
@@ -624,8 +683,8 @@ async def _iter_conversation_turn_events(
                                             framework_ref=checkpoint_metadata.get("framework_ref"),
                                             status=(
                                                 "failed"
-                                                if isinstance(chunk.get("tool_output"), Mapping)
-                                                and chunk.get("tool_output", {}).get("ok") is False
+                                                if isinstance(_tool_output_raw, Mapping)
+                                                and _tool_output_raw.get("ok") is False
                                                 else "completed"
                                             ),
                                         ),
@@ -723,6 +782,8 @@ async def _iter_conversation_turn_events(
                 return
             except Exception as exc:
                 if attempt == 0 and not emitted_anything and _is_prompt_too_long_error(exc):
+                    _baseline_ptl = True
+                    _baseline_attempts = attempt + 1
                     yield {"type": "compaction", "phase": "start", "trigger": "prompt_too_long"}
                     try:
                         checkpoint = await _compact_conversation_history_with_governance(
@@ -736,6 +797,15 @@ async def _iter_conversation_turn_events(
                             trigger="prompt_too_long",
                             keep_tail_groups=PTL_RETRY_KEEP_TAIL_GROUPS,
                             session_service_provider=provider,
+                            # PR D1：PTL 路径仍 force=True；透传 ownership 便于未来按门控调策略。
+                            prompt_integration_mode=getattr(
+                                prepared, "prompt_integration_mode", ""
+                            ),
+                            compaction_owner=str(
+                                (getattr(prepared, "shadow_context_plan", None) or {}).get(
+                                    "compaction_owner", ""
+                                )
+                            ),
                         )
                     except RuntimeCircuitOpen as circuit_exc:
                         await append_run_status_event(
@@ -887,6 +957,21 @@ async def _iter_conversation_turn_events(
             run_trigger=run_trigger,
         )
         _set_conversation_usage_attributes(span, assistant_metadata.get("usage"))
+        _set_prompt_cache_attributes(
+            span,
+            session_id=prepared.session_id,
+            plan=prepared.shadow_context_plan,
+            usage=assistant_metadata.get("usage"),
+        )
+        _set_prompt_source_attributes(span, getattr(prepared, "compiled_prompt", None))
+        _record_baseline_turn(
+            prepared=prepared,
+            model=model,
+            usage=assistant_metadata.get("usage"),
+            ptl=_baseline_ptl,
+            attempts=_baseline_attempts,
+            turn_start_monotonic=_baseline_turn_start,
+        )
         _finish_span()
         yield {
             "type": "completed",