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

ksadk/harness/context_manifest.py

@@ -0,0 +1,188 @@
+"""ContextManifest（长任务 Context 与 Memory 增强方案 §6.2）。
+
+ContextManifest 是 ContextPlan 的**可观测、可审计快照**：
+
+- 规划层选择（ContextItem/ContextPlan）与投影层（AssembledInput）已存在；
+- Manifest 只持久化 Hash、引用、选择原因和 Token 构成——**不重复持久化
+  敏感正文**（方案 §6.2 / §12）；
+- Planned / Projected / Actual 三段 Token 在这里闭环：Planned/Projected 在
+  构建 Manifest 时填入，Actual 由引擎在模型返回 usage 后回填
+  （``actual_usage_ref`` 指向 usage.reported 事件）。
+
+设计为纯数据 + 纯函数模块（与 PCM 分层一致），引擎负责接线与持久化。
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from typing import Any
+
+
+def _manifest_id(material: str) -> str:
+    return f"ctxm_{hashlib.sha256(material.encode('utf-8')).hexdigest()[:12]}"
+
+
+@dataclass(frozen=True)
+class ManifestSection:
+    """Manifest 中的单个 Section 条目：只记事实，不记正文。"""
+
+    item_id: str
+    kind: str
+    source_refs: tuple[str, ...] = ()
+    selected_reason: str = ""
+    estimated_tokens: int = 0
+    included: bool = True
+    #: 内容 Hash（不含正文），用于比对两次调用间该段是否变化。
+    content_hash: str = ""
+
+    def to_payload(self) -> dict[str, Any]:
+        return {
+            "item_id": self.item_id,
+            "kind": self.kind,
+            "source_refs": list(self.source_refs),
+            "selected_reason": self.selected_reason,
+            "estimated_tokens": self.estimated_tokens,
+            "included": self.included,
+            "content_hash": self.content_hash,
+        }
+
+
+@dataclass(frozen=True)
+class ContextManifest:
+    """一次模型调用的 Context 快照（可持久化、可审计）。"""
+
+    manifest_id: str
+    run_id: str
+    scope_id: str
+    model_profile_ref: str
+    stable_prompt_hash: str
+    sections: tuple[ManifestSection, ...]
+    context_window_tokens: int
+    reserved_output_tokens: int
+    available_input_tokens: int
+    planned_tokens: int
+    projected_tokens: int
+    #: Actual Token 由引擎在 usage.reported 后回填（输入侧）。
+    actual_input_tokens: int | None = None
+    actual_output_tokens: int | None = None
+    #: 指向 usage.reported 事件的 event_id。
+    actual_usage_ref: str | None = None
+    #: 触发本次重新构建的上一 manifest（如紧急压缩后重建）。
+    supersedes: str | None = None
+
+    def to_payload(self) -> dict[str, Any]:
+        return {
+            "manifest_id": self.manifest_id,
+            "run_id": self.run_id,
+            "scope_id": self.scope_id,
+            "model_profile_ref": self.model_profile_ref,
+            "stable_prompt_hash": self.stable_prompt_hash,
+            "sections": [s.to_payload() for s in self.sections],
+            "budget": {
+                "context_window": self.context_window_tokens,
+                "reserved_output": self.reserved_output_tokens,
+                "available_input": self.available_input_tokens,
+            },
+            "planned_tokens": self.planned_tokens,
+            "projected_tokens": self.projected_tokens,
+            "actual": {
+                "input_tokens": self.actual_input_tokens,
+                "output_tokens": self.actual_output_tokens,
+                "usage_ref": self.actual_usage_ref,
+            },
+            "supersedes": self.supersedes,
+        }
+
+    def with_actual(
+        self,
+        *,
+        input_tokens: int,
+        output_tokens: int,
+        usage_ref: str,
+    ) -> "ContextManifest":
+        """引擎在 usage.reported 后回填 Actual Token（返回新实例）。"""
+        return ContextManifest(
+            manifest_id=self.manifest_id,
+            run_id=self.run_id,
+            scope_id=self.scope_id,
+            model_profile_ref=self.model_profile_ref,
+            stable_prompt_hash=self.stable_prompt_hash,
+            sections=self.sections,
+            context_window_tokens=self.context_window_tokens,
+            reserved_output_tokens=self.reserved_output_tokens,
+            available_input_tokens=self.available_input_tokens,
+            planned_tokens=self.planned_tokens,
+            projected_tokens=self.projected_tokens,
+            actual_input_tokens=input_tokens,
+            actual_output_tokens=output_tokens,
+            actual_usage_ref=usage_ref,
+            supersedes=self.supersedes,
+        )
+
+
+def build_manifest(
+    *,
+    plan: Any,
+    projected_tokens: int,
+    run_id: str,
+    scope_id: str,
+    model_profile_ref: str,
+    supersedes: str | None = None,
+) -> ContextManifest:
+    """从 ContextPlan 构建 Manifest。
+
+    ``plan`` 是 ``ksadk.context_engine.models.ContextPlan``；Section 的
+    ``selected_reason`` 取自 decisions（included/dropped + reason），未出现在
+    decisions 中的 required 项标注 "required"。
+    """
+    decisions = {d.item_id: d for d in plan.decisions}
+    sections: list[ManifestSection] = []
+    for item in plan.selected:
+        decision = decisions.get(item.item_id)
+        reason = (decision.reason if decision else "") or "selected"
+        action = decision.action if decision else "included"
+        content = item.content if isinstance(item.content, str) else repr(item.content)
+        sections.append(
+            ManifestSection(
+                item_id=item.item_id,
+                kind=str(item.kind),
+                source_refs=(str(item.source),),
+                selected_reason=f"{action}:{reason}" if reason != "required" else "required",
+                estimated_tokens=int(item.estimated_tokens or 0),
+                included=True,
+                content_hash="sha256:" + hashlib.sha256(content.encode("utf-8")).hexdigest()
+                if content
+                else "",
+            )
+        )
+    for item_id, decision in decisions.items():
+        if decision.action == "dropped":
+            sections.append(
+                ManifestSection(
+                    item_id=item_id,
+                    kind="dropped",
+                    selected_reason=f"dropped:{decision.reason}",
+                    estimated_tokens=0,
+                    included=False,
+                )
+            )
+    material = f"{run_id}:{plan.plan_id}:{plan.stable_prefix_hash}:{projected_tokens}"
+    budget = plan.budget
+    return ContextManifest(
+        manifest_id=_manifest_id(material),
+        run_id=run_id,
+        scope_id=scope_id,
+        model_profile_ref=model_profile_ref,
+        stable_prompt_hash=str(plan.stable_prefix_hash or ""),
+        sections=tuple(sections),
+        context_window_tokens=int(budget.context_window_tokens) if budget else 0,
+        reserved_output_tokens=int(budget.reserved_output_tokens) if budget else 0,
+        available_input_tokens=int(budget.max_input_tokens) if budget else 0,
+        planned_tokens=int(plan.planned_input_tokens or 0),
+        projected_tokens=int(projected_tokens),
+        supersedes=supersedes,
+    )
+
+
+__all__ = ["ContextManifest", "ManifestSection", "build_manifest"]

ksadk/harness/context_tuning.py

@@ -0,0 +1,168 @@
+"""Context 策略调优建议（只读、可解释、不会自动改线上配置）。
+
+Harness 已经通过 :func:`context_inspection` 暴露预算、压缩、缓存、Memory
+召回和恢复信号。本模块把这些稳定指标转换为 Studio 可展示的建议。它只输出
+建议与证据，不直接修改 ``HarnessSpec``；策略变更仍须经过 Draft、Revision
+和验证，避免单次异常 Run 静默改变线上行为。
+"""
+
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+from ksadk.harness.events import RuntimeEvent
+from ksadk.harness.observability import context_inspection
+
+
+def context_tuning_recommendations(
+    events: Sequence[RuntimeEvent],
+) -> dict[str, Any]:
+    """生成 JSON 兼容的 Context 调优建议。
+
+    输出不包含 Prompt、消息、Memory、Tool 返回或底层错误正文，可以直接供
+    Studio 和发布评审消费。建议按 ``critical/high/medium/low`` 排序；没有
+    证据时返回空列表，而不是猜测配置。
+    """
+
+    inspection = context_inspection(events)
+    current = inspection["current"]
+    cache = inspection["cache"]
+    compaction = inspection["compaction"]
+    memory = inspection["memory"]
+    recoveries = inspection["recoveries"]
+    recommendations: list[dict[str, Any]] = []
+
+    utilization = float(current.get("utilization_ratio") or 0.0)
+    if utilization > 1.0:
+        recommendations.append(
+            _recommendation(
+                "context_budget_exceeded",
+                "critical",
+                "降低常驻 Context 或提高模型上下文预算",
+                "实际或预计输入已超过本次预算，存在 Context Overflow 风险。",
+                {"utilization_ratio": utilization},
+                "review_context_budget",
+            )
+        )
+    elif utilization >= 0.85:
+        recommendations.append(
+            _recommendation(
+                "context_budget_near_limit",
+                "high",
+                "提前整理 Working Context",
+                "Context 使用率已接近预算上限，建议在下一轮前主动压缩。",
+                {"utilization_ratio": utilization},
+                "lower_compaction_threshold",
+            )
+        )
+
+    quality_failures = len(compaction.get("quality_failures") or ())
+    if quality_failures:
+        recommendations.append(
+            _recommendation(
+                "compaction_quality_failed",
+                "critical",
+                "暂停自动放宽压缩并检查摘要质量",
+                "压缩质量门禁失败；应先修复事实或工具配对保留问题。",
+                {"quality_failure_count": quality_failures},
+                "inspect_compaction_trace",
+            )
+        )
+    elif int(compaction.get("count") or 0) >= 3:
+        recommendations.append(
+            _recommendation(
+                "frequent_compaction",
+                "medium",
+                "减少重复注入并整理稳定 Prompt",
+                "同一观测窗口发生多次压缩，可能存在历史重复注入或常驻段过大。",
+                {"compaction_count": int(compaction["count"])},
+                "review_context_sections",
+            )
+        )
+
+    diagnostics = int(cache.get("diagnostic_count") or 0)
+    break_count = int(cache.get("break_count") or 0)
+    hit_ratio = float(cache.get("provider_hit_ratio") or 0.0)
+    if break_count:
+        recommendations.append(
+            _recommendation(
+                "prompt_cache_breaks",
+                "medium",
+                "稳定 Prompt 前缀与缓存边界",
+                "观测到 Provider Prompt Cache 边界变化。",
+                {"break_count": break_count, "provider_hit_ratio": hit_ratio},
+                "inspect_cache_diagnostics",
+            )
+        )
+    elif diagnostics >= 3 and hit_ratio < 0.2:
+        recommendations.append(
+            _recommendation(
+                "low_prompt_cache_hit_ratio",
+                "low",
+                "检查稳定 Prompt 是否混入动态内容",
+                "已有多次缓存诊断，但 Provider 缓存命中率偏低。",
+                {"diagnostic_count": diagnostics, "provider_hit_ratio": hit_ratio},
+                "review_stable_prompt_boundary",
+            )
+        )
+
+    candidates = int(memory.get("candidate_count") or 0)
+    injected = int(memory.get("injected_count") or 0)
+    if candidates >= 5 and injected == 0:
+        recommendations.append(
+            _recommendation(
+                "memory_candidates_not_injected",
+                "medium",
+                "检查 Memory 召回阈值和作用域",
+                "召回已有候选，但没有任何记录进入 Context。",
+                {"candidate_count": candidates, "injected_count": injected},
+                "inspect_memory_recall",
+            )
+        )
+
+    recovery_count = int(recoveries.get("count") or 0)
+    if recovery_count:
+        recommendations.append(
+            _recommendation(
+                "context_recovery_observed",
+                "high",
+                "检查 Context 降级与恢复原因",
+                "本观测窗口发生过 Context 恢复或降级，正式发布前应确认原因。",
+                {
+                    "recovery_count": recovery_count,
+                    "reason_codes": list(recoveries.get("reason_codes") or ()),
+                },
+                "inspect_recovery_events",
+            )
+        )
+
+    order = {"critical": 0, "high": 1, "medium": 2, "low": 3}
+    recommendations.sort(key=lambda item: (order[item["severity"]], item["code"]))
+    return {
+        "schema_version": 1,
+        "status": "action_required" if recommendations else "healthy",
+        "auto_apply": False,
+        "recommendation_count": len(recommendations),
+        "recommendations": recommendations,
+    }
+
+
+def _recommendation(
+    code: str,
+    severity: str,
+    title: str,
+    rationale: str,
+    evidence: dict[str, Any],
+    action: str,
+) -> dict[str, Any]:
+    return {
+        "code": code,
+        "severity": severity,
+        "title": title,
+        "rationale": rationale,
+        "evidence": evidence,
+        "suggested_action": action,
+    }
+
+
+__all__ = ["context_tuning_recommendations"]

ksadk/harness/draft_runtime.py

@@ -0,0 +1,322 @@
+"""Draft Runtime 调试通路（P2/P2.1「保存即可试用」）。
+
+不改变 KsADK 正式生命周期（Revision → Build → Approval → Deploy →
+Activate），增加一条调试路径::
+
+    创建或修改 Draft → 保存时完成 Runtime 编译 → 立即打开测试对话
+
+P2.1 收口：
+
+- **DraftConversation 稳定多轮会话**：同一草稿内多轮测试对话共享上下文
+  （历史经 ``conversation_history`` 注入，与 Studio Playground 同一通路）；
+- **审批可恢复**：MCP 高风险调用进入 awaiting_approval 时保留 Handle，
+  ``approve()/reject()`` 经引擎 resume 通道续跑，草稿内审批照常工作；
+- **保存时完成全部 Runtime 校验**：``compile()`` 异步完成
+  ``engine.compile(spec)``（工具名冲突、required MCP 无 Runtime 等编译期
+  校验在保存时即暴露，不拖到首次发消息）；
+- **TTL / 关闭 / 替换清理**：会话惰性过期、显式关闭、同 draft_id 重新
+  保存自动替换旧会话。
+
+P2.2 补强连续审批、恢复失败重试、TTL 挂起句柄确定性释放，并与
+ContextEngine 的 current input 去重约定对齐。
+
+隔离不变：draft 引用命名空间（``agent-revision://draft-<id>@1``）、
+``draft:`` 会话前缀、metadata 标记、正式生命周期零感知。
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass
+from typing import Any
+
+from ksadk.harness.compiler import compile_revision_payload
+from ksadk.harness.spec import HarnessSpec
+
+#: Draft Revision 引用前缀——合法 agent-revision 引用内的草稿命名空间
+#: （``agent-revision://draft-<id>@1``），与正式 Revision 隔离但不破坏引用校验。
+DRAFT_REF_PREFIX = "agent-revision://draft-"
+
+#: Draft 会话前缀——正式对话永不落入该命名空间。
+DRAFT_SESSION_PREFIX = "draft:"
+
+#: 默认会话 TTL（秒）：超时未活动的 Draft 会话被惰性清理。
+DEFAULT_SESSION_TTL_SECONDS = 3600.0
+
+
+class DraftRuntimeError(RuntimeError):
+    """Draft 编译失败或非法操作。"""
+
+
+@dataclass
+class _PendingApproval:
+    """awaiting_approval 的挂起 Run（Handle 保留，等待决策）。"""
+
+    handle: Any
+    call_id: str
+
+
+class DraftConversation:
+    """一个草稿的稳定多轮测试会话。"""
+
+    def __init__(self, draft_id: str, spec: HarnessSpec, engine: Any,
+                 warnings: tuple[str, ...] = ()) -> None:
+        self.draft_id = draft_id
+        self.spec = spec
+        self.engine = engine
+        self.warnings = warnings
+        self.turns = 0
+        #: 跨轮共享的对话历史（role/content 投影）。
+        self.history: list[dict[str, str]] = []
+        #: 挂起的审批（awaiting_approval 时非空）。
+        self.pending: _PendingApproval | None = None
+        self._compiled: Any | None = None
+        self._session_id = f"{DRAFT_SESSION_PREFIX}{draft_id}"
+        self.last_active: float = time.monotonic()
+
+    @property
+    def draft_ref(self) -> str:
+        return f"{DRAFT_REF_PREFIX}{self.draft_id}@1"
+
+    @property
+    def awaiting_approval(self) -> bool:
+        return self.pending is not None
+
+    # ------------------------------------------------------------- 对话
+
+    async def converse(self, message: str, *, user_id: str = "draft-user") -> list[Any]:
+        """一轮测试对话。多轮共享上下文；有挂起审批时必须先决策。"""
+        if self.pending is not None:
+            raise DraftRuntimeError(
+                "存在挂起审批，先调用 approve()/reject() 或 discard_approval()"
+            )
+        handle = await self._start_run(message, user_id=user_id)
+        events = await self._drain(handle)
+        return events
+
+    # ------------------------------------------------------------- 审批
+
+    async def approve(self) -> list[Any]:
+        """批准挂起的高风险调用并续跑。"""
+        return await self._resolve_approval("approved")
+
+    async def reject(self) -> list[Any]:
+        """拒绝挂起的高风险调用并续跑（工具收到拒绝，Run 正常收尾）。"""
+        return await self._resolve_approval("rejected")
+
+    async def discard_approval(self) -> None:
+        """放弃挂起的 Run（不决策，直接丢弃）。"""
+        if self.pending is None:
+            raise DraftRuntimeError("没有挂起的审批")
+        await self.engine.close(self.pending.handle)
+        self.pending = None
+
+    # ------------------------------------------------------------- 关闭
+
+    async def close(self) -> None:
+        """即用即弃：释放挂起 Handle（正常轮次已逐轮关闭）。"""
+        if self.pending is not None:
+            await self.engine.close(self.pending.handle)
+            self.pending = None
+
+    # ------------------------------------------------------------ 内部
+
+    async def ensure_compiled(self) -> None:
+        if self._compiled is None:
+            self._compiled = await self.engine.compile(self.spec)
+
+    async def _start_run(self, message: str, *, user_id: str) -> Any:
+        from ksadk.runtime import StartRequest
+
+        await self.ensure_compiled()
+        # 历史含本轮输入（与 evaluation/Playground 的注入约定一致）。
+        history = list(self.history)
+        history.append({"role": "user", "content": str(message)})
+        self.turns += 1
+        self.last_active = time.monotonic()
+        return await self.engine.start(
+            StartRequest(
+                agent_id=f"draft-{self.draft_id}",
+                user_id=user_id,
+                session_id=self._session_id,
+                input=message,
+                metadata={
+                    "draft": True,
+                    "draft_id": self.draft_id,
+                    "conversation_history": history,
+                },
+            ),
+            self._compiled,
+        )
+
+    async def _drain(self, handle: Any) -> list[Any]:
+        events = [event async for event in self.engine.stream(handle)]
+        from ksadk.harness.events import EventType
+
+        approval = next(
+            (
+                e for e in reversed(events)
+                if e.event_type == EventType.APPROVAL_REQUESTED
+            ),
+            None,
+        )
+        if approval is not None:
+            # 审批挂起：保留 Handle 等决策，历史不推进。
+            self.pending = _PendingApproval(
+                handle=handle,
+                call_id=str(approval.payload.get("call_id") or ""),
+            )
+            return events
+        self._absorb(handle)
+        await self.engine.close(handle)
+        return events
+
+    async def _resolve_approval(self, decision: str) -> list[Any]:
+        if self.pending is None:
+            raise DraftRuntimeError("没有挂起的审批")
+        from ksadk.runtime import ResumePayload, ResumeTarget
+
+        pending = self.pending
+        handle = pending.handle
+        call_id = pending.call_id
+        self.last_active = time.monotonic()
+        try:
+            await self.engine.resume(
+                handle,
+                ResumeTarget(kind="thread_id", id=handle.native_ref["thread_id"]),
+                ResumePayload(kind="approval_decision", call_id=call_id, data=decision),
+            )
+        except Exception:
+            # Resume 失败时保留 pending，调用方可重试或显式放弃；
+            # 不得在引擎拒绝恢复时丢失审批决策入口。
+            self.pending = pending
+            raise
+        self.pending = None
+        # 续跑后可能再次命中高风险工具；统一回到 _drain，
+        # 使同一 Run 的连续审批仍保留 Handle，而不是误关闭。
+        return await self._drain(handle)
+
+    def _absorb(self, handle: Any) -> None:
+        """把本轮完整对话投影并入跨轮历史。"""
+        run = self.engine._runs.get(handle.run_id)
+        if run is None:
+            return
+        self.history = [
+            {"role": m.role.value, "content": str(m.content)}
+            for m in run.state.messages
+        ]
+
+
+class DraftRuntime:
+    """Draft → 保存时编译 → 测试对话的编排入口（生命周期外调试通路）。"""
+
+    def __init__(
+        self,
+        *,
+        reasoner: Any | None = None,
+        local_dir: str | None = None,
+        cache_dir: str | None = None,
+        checkpointer: Any | None = None,
+        session_ttl_seconds: float = DEFAULT_SESSION_TTL_SECONDS,
+        **engine_kwargs: Any,
+    ) -> None:
+        self._reasoner = reasoner
+        self._local_dir = local_dir
+        self._cache_dir = cache_dir
+        self._checkpointer = checkpointer
+        self._session_ttl_seconds = session_ttl_seconds
+        self._engine_kwargs = engine_kwargs
+        self._sessions: dict[str, DraftConversation] = {}
+
+    # ------------------------------------------------------------- 编译
+
+    async def compile(
+        self,
+        draft_payload: dict[str, Any],
+        *,
+        draft_id: str | None = None,
+    ) -> DraftConversation:
+        """Draft payload → HarnessSpec → **保存时即完成 Runtime 编译**。
+
+        校验三段全走正式路径：compile_revision_payload（payload 校验）→
+        engine 装配（Skill 解析/MCP 绑定）→ engine.compile(spec)（工具名
+        冲突、required MCP 无 Runtime 等运行时校验）。失败抛
+        DraftRuntimeError——Studio 保存时即可暴露全部问题。
+        """
+        await self._expire_stale()
+        draft_id = draft_id or f"draft_{uuid.uuid4().hex[:12]}"
+        revision_ref = f"{DRAFT_REF_PREFIX}{draft_id}@1"
+        try:
+            spec = compile_revision_payload(draft_payload, revision_ref=revision_ref)
+        except Exception as exc:  # noqa: BLE001
+            raise DraftRuntimeError(f"draft 编译失败: {exc}") from exc
+        engine, warnings = self._compose(spec)
+        session = DraftConversation(draft_id, spec, engine, warnings=tuple(warnings))
+        try:
+            await session.ensure_compiled()
+        except Exception as exc:  # noqa: BLE001
+            raise DraftRuntimeError(f"draft runtime 校验失败: {exc}") from exc
+        # 同 draft_id 重新保存：替换旧会话（旧挂起 Handle 先释放）。
+        old = self._sessions.get(draft_id)
+        if old is not None:
+            await old.close()
+        self._sessions[draft_id] = session
+        return session
+
+    async def session(self, draft_id: str) -> DraftConversation:
+        """返回未过期的 Draft 会话，并确定性关闭所有过期句柄。"""
+        await self._expire_stale()
+        if draft_id not in self._sessions:
+            raise DraftRuntimeError(f"unknown draft: {draft_id!r}")
+        return self._sessions[draft_id]
+
+    # ------------------------------------------------------------- 清理
+
+    async def close_session(self, draft_id: str) -> None:
+        session = self._sessions.pop(draft_id, None)
+        if session is not None:
+            await session.close()
+
+    async def close(self) -> None:
+        """销毁全部 Draft 会话（Studio 关闭调试面板时调用）。"""
+        for session in self._sessions.values():
+            await session.close()
+        self._sessions.clear()
+
+    async def _expire_stale(self) -> None:
+        """TTL 惰性清理：先移出索引，再确定性关闭挂起 Handle。"""
+        now = time.monotonic()
+        stale: list[DraftConversation] = []
+        for draft_id in list(self._sessions):
+            session = self._sessions[draft_id]
+            if now - session.last_active > self._session_ttl_seconds:
+                self._sessions.pop(draft_id, None)
+                stale.append(session)
+        for session in stale:
+            await session.close()
+
+    # ------------------------------------------------------------ 内部
+
+    def _compose(self, spec: HarnessSpec) -> tuple[Any, list[str]]:
+        from ksadk.harness.skill_composition import compose_engine
+
+        engine = compose_engine(
+            spec,
+            reasoner=self._reasoner,
+            local_dir=self._local_dir,
+            cache_dir=self._cache_dir,
+            checkpointer=self._checkpointer,
+            **self._engine_kwargs,
+        )
+        return engine, list(getattr(engine, "skill_warnings", ()))
+
+
+__all__ = [
+    "DEFAULT_SESSION_TTL_SECONDS",
+    "DRAFT_REF_PREFIX",
+    "DRAFT_SESSION_PREFIX",
+    "DraftConversation",
+    "DraftRuntime",
+    "DraftRuntimeError",
+]