flare-kernel 0.1.0__tar.gz → 0.2.1__tar.gz

{flare_kernel-0.1.0 → flare_kernel-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flare-kernel
-Version: 0.1.0
+Version: 0.2.1
 Summary: FLARE kernel runtime package
 License: Proprietary
 Classifier: Development Status :: 3 - Alpha
@@ -8,10 +8,15 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: flare-engines<0.2.0,>=0.1.0
+Requires-Dist: flare-engines<0.3.0,>=0.2.0
 Requires-Dist: fastapi<1.0,>=0.115
 Requires-Dist: pydantic<3,>=2
 Requires-Dist: uvicorn<1.0,>=0.30
+Requires-Dist: httpx<1.0,>=0.27
+Requires-Dist: sqlalchemy<3,>=2
+Requires-Dist: psycopg2-binary<3,>=2.9
+Requires-Dist: redis<6,>=5
+Requires-Dist: qdrant-client<2,>=1.9
 
 # flare-kernel
 
@@ -37,21 +42,22 @@ Requires-Dist: uvicorn<1.0,>=0.30
 1. `POST /kernel/run`
 2. `POST /kernel/stream`
 3. `GET /kernel/health`
+4. `POST /kernel/knowledge/ingest`
+5. `POST /kernel/knowledge/search`
 
 kernel 现已输出 mode/context 运行时占位事件与字段。
 
-## Instance 注入（品牌信息）
+## 品牌注入（可选）
 
-1. kernel 支持从 instance 的 domain-pack 读取品牌配置：
+1. kernel 支持从 domain-pack 读取品牌配置：
    `branding/instance-branding.json`
-2. 读取优先级：
-   - 环境变量 `FLARE_DOMAIN_PACK_ROOT`
-   - 自动探测 `apps/<instance_id>/domain-pack`
+2. 读取方式：
+   - 仅通过环境变量 `FLARE_DOMAIN_PACK_ROOT` 显式指定
 3. 注入位置：
    - `POST /kernel/run` 响应 `result.instance_profile`
    - `POST /kernel/stream` SSE 事件 `instance_profile`
 
-说明：品牌注入仅在 instance 层配置，core 不写死产品名、logo、标签。
+说明：品牌注入通过外部 domain-pack 配置，core 不写死产品名、logo、标签。
 
 本地启动（示例）：
 
@@ -59,6 +65,29 @@ kernel 现已输出 mode/context 运行时占位事件与字段。
 uvicorn flare_kernel.main:app --app-dir packages/flare-kernel/src --host 0.0.0.0 --port 8002
 ```
 
+环境变量（真实链路）：
+
+1. `DASHSCOPE_API_KEY`（必填，真实百炼调用）
+2. `LLM_PROVIDER_BACKEND`（默认 `dashscope`）
+3. `FLARE_POSTGRES_DSN`
+4. `FLARE_REDIS_URL`
+5. `FLARE_QDRANT_URL`
+
+健康检查会输出依赖状态：
+
+1. `llm_ready`
+2. `postgres_ready`
+3. `redis_ready`
+4. `qdrant_ready`
+
+模式决策优先级（`/kernel/run` 与 `/kernel/stream`）：
+
+1. `intent_override`（外部业务侧注入）
+2. 消息意图识别（内置关键词）
+3. `manual_mode`
+4. `current_mode`
+5. fallback（`intent/default`）
+
 ## 最小发布说明
 
 1. 当前包版本：`0.1.0`

{flare_kernel-0.1.0 → flare_kernel-0.2.1}/README.md

@@ -22,21 +22,22 @@
 1. `POST /kernel/run`
 2. `POST /kernel/stream`
 3. `GET /kernel/health`
+4. `POST /kernel/knowledge/ingest`
+5. `POST /kernel/knowledge/search`
 
 kernel 现已输出 mode/context 运行时占位事件与字段。
 
-## Instance 注入（品牌信息）
+## 品牌注入（可选）
 
-1. kernel 支持从 instance 的 domain-pack 读取品牌配置：
+1. kernel 支持从 domain-pack 读取品牌配置：
    `branding/instance-branding.json`
-2. 读取优先级：
-   - 环境变量 `FLARE_DOMAIN_PACK_ROOT`
-   - 自动探测 `apps/<instance_id>/domain-pack`
+2. 读取方式：
+   - 仅通过环境变量 `FLARE_DOMAIN_PACK_ROOT` 显式指定
 3. 注入位置：
    - `POST /kernel/run` 响应 `result.instance_profile`
    - `POST /kernel/stream` SSE 事件 `instance_profile`
 
-说明：品牌注入仅在 instance 层配置，core 不写死产品名、logo、标签。
+说明：品牌注入通过外部 domain-pack 配置，core 不写死产品名、logo、标签。
 
 本地启动（示例）：
 
@@ -44,6 +45,29 @@ kernel 现已输出 mode/context 运行时占位事件与字段。
 uvicorn flare_kernel.main:app --app-dir packages/flare-kernel/src --host 0.0.0.0 --port 8002
 ```
 
+环境变量（真实链路）：
+
+1. `DASHSCOPE_API_KEY`（必填，真实百炼调用）
+2. `LLM_PROVIDER_BACKEND`（默认 `dashscope`）
+3. `FLARE_POSTGRES_DSN`
+4. `FLARE_REDIS_URL`
+5. `FLARE_QDRANT_URL`
+
+健康检查会输出依赖状态：
+
+1. `llm_ready`
+2. `postgres_ready`
+3. `redis_ready`
+4. `qdrant_ready`
+
+模式决策优先级（`/kernel/run` 与 `/kernel/stream`）：
+
+1. `intent_override`（外部业务侧注入）
+2. 消息意图识别（内置关键词）
+3. `manual_mode`
+4. `current_mode`
+5. fallback（`intent/default`）
+
 ## 最小发布说明
 
 1. 当前包版本：`0.1.0`

{flare_kernel-0.1.0 → flare_kernel-0.2.1}/pyproject.toml

@@ -4,15 +4,20 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flare-kernel"
-version = "0.1.0"
+version = "0.2.1"
 description = "FLARE kernel runtime package"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-    "flare-engines>=0.1.0,<0.2.0",
+    "flare-engines>=0.2.0,<0.3.0",
     "fastapi>=0.115,<1.0",
     "pydantic>=2,<3",
     "uvicorn>=0.30,<1.0",
+    "httpx>=0.27,<1.0",
+    "sqlalchemy>=2,<3",
+    "psycopg2-binary>=2.9,<3",
+    "redis>=5,<6",
+    "qdrant-client>=1.9,<2",
 ]
 license = { text = "Proprietary" }
 classifiers = [

flare_kernel-0.2.1/src/flare_kernel/contracts/__init__.py

@@ -0,0 +1,23 @@
+"""Kernel contracts."""
+
+from flare_kernel.contracts.kernel_contract import (
+    HealthResponse,
+    IntentSuggestResponse,
+    KernelRequest,
+    KernelResponse,
+    KnowledgeIngestRequest,
+    KnowledgeIngestResponse,
+    KnowledgeSearchRequest,
+    KnowledgeSearchResponse,
+)
+
+__all__ = [
+    "KernelRequest",
+    "KernelResponse",
+    "HealthResponse",
+    "IntentSuggestResponse",
+    "KnowledgeIngestRequest",
+    "KnowledgeIngestResponse",
+    "KnowledgeSearchRequest",
+    "KnowledgeSearchResponse",
+]

flare_kernel-0.2.1/src/flare_kernel/contracts/kernel_contract.py

@@ -0,0 +1,133 @@
+"""Kernel API contracts."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class IntakeFieldValue(BaseModel):
+    kind: Literal["single_choice", "multi_choice", "free_text", "number", "range", "candidate_ref"]
+    value: Any = None
+    display_value: str | None = None
+    values: list[Any] | None = None
+    text: str | None = None
+    number: float | int | None = None
+    min: float | int | None = None
+    max: float | int | None = None
+    unit: str | None = None
+    currency: str | None = None
+    candidate_id: str | None = None
+
+    @model_validator(mode="after")
+    def validate_shape(self) -> "IntakeFieldValue":
+        if self.kind == "single_choice" and self.value in (None, ""):
+            raise ValueError("single_choice requires value")
+        if self.kind == "multi_choice" and not isinstance(self.values, list):
+            raise ValueError("multi_choice requires values[]")
+        if self.kind == "free_text" and not str(self.text or "").strip():
+            raise ValueError("free_text requires text")
+        if self.kind == "number" and self.number is None:
+            raise ValueError("number requires number")
+        if self.kind == "range" and (self.min is None or self.max is None):
+            raise ValueError("range requires min and max")
+        if self.kind == "candidate_ref" and not str(self.candidate_id or "").strip():
+            raise ValueError("candidate_ref requires candidate_id")
+        return self
+
+
+class KernelRequest(BaseModel):
+    contract_version: str = "flare.v1"
+    client_request_id: str | None = None
+    tenant_id: str = "default"
+    instance_id: str = "default"
+    domain_pack_version: str = "v1"
+    session_id: str | None = None
+    last_turn_id: str | None = None
+    command: str | None = None
+    intent: str = "default"
+    intent_override: str | None = None
+    mode: str | None = None
+    manual_mode: str | None = None
+    current_mode: str | None = None
+    project_id: str | None = None
+    user_id: str | None = None
+    retrieval_config: dict[str, Any] = Field(default_factory=dict)
+    canvas_config: dict[str, Any] = Field(default_factory=dict)
+    plan_config: dict[str, Any] = Field(default_factory=dict)
+    payload: dict[str, Any] = Field(default_factory=dict)
+    context_refs: list[Any] = Field(default_factory=list)
+    knowledge_refs: list[str] = Field(default_factory=list)
+    action_key: str | None = None
+    target_mode: str | None = None
+    action_status: str | None = None
+    action_reason: str | None = None
+    trace_id: str | None = None
+    question_id: str | None = None
+    field_key: str | None = None
+    field_value: IntakeFieldValue | None = None
+
+
+class KernelResponse(BaseModel):
+    trace_id: str
+    state: Literal["RUNNING", "SUCCEEDED", "FAILED"]
+    events: list[dict[str, Any]] = Field(default_factory=list)
+    result: dict[str, Any] = Field(default_factory=dict)
+    next_actions: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class HealthResponse(BaseModel):
+    status: Literal["healthy"]
+    service: str
+    trace_id: str
+    llm_ready: bool
+    postgres_ready: bool
+    redis_ready: bool
+    qdrant_ready: bool
+    canvas_ready: bool
+    rag_ready: bool
+    plan_ready: bool
+
+
+class KnowledgeIngestRequest(BaseModel):
+    project_id: str = "default"
+    user_id: str = "default"
+    session_id: str = "default"
+    source_id: str | None = None
+    title: str | None = None
+    content: str
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class KnowledgeIngestResponse(BaseModel):
+    trace_id: str
+    project_id: str
+    user_id: str
+    record_id: str
+    chunk_count: int
+    status: Literal["stored", "partial", "failed"]
+    details: dict[str, Any] = Field(default_factory=dict)
+
+
+class KnowledgeSearchRequest(BaseModel):
+    project_id: str = "default"
+    user_id: str = "default"
+    query: str
+    top_k: int = 5
+
+
+class KnowledgeSearchResponse(BaseModel):
+    trace_id: str
+    project_id: str
+    user_id: str
+    query: str
+    results: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class IntentSuggestResponse(BaseModel):
+    trace_id: str
+    suggested_mode: str
+    confidence: float = 0.0
+    reason: str = ""
+    source: Literal["intent_override", "manual", "current", "llm", "keywords", "fallback"] = "fallback"

flare_kernel-0.2.1/src/flare_kernel/router/__init__.py

@@ -0,0 +1,45 @@
+"""Kernel routers.
+
+This package keeps ``kernel_router`` as the public entrypoint and also provides
+legacy module-name compatibility for recently grouped router modules.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+
+from flare_kernel.router.kernel import router as kernel_router
+
+__all__ = ["kernel_router"]
+
+
+def _resolve_legacy_group(module_name: str) -> str | None:
+    if module_name.startswith("canonical_state_"):
+        return "canonical"
+    if module_name.startswith("orchestration_"):
+        return "orchestration"
+    if module_name.startswith("streaming_"):
+        return "streaming"
+    if module_name.startswith("intake_"):
+        return "intake"
+    if module_name == "session_intent" or module_name.startswith("session_intent_"):
+        return "intent"
+    if module_name.startswith("intent_"):
+        return "intent"
+    if module_name.startswith("retrieval_"):
+        return "retrieval"
+    return None
+
+
+def __getattr__(name: str):
+    """Resolve legacy ``flare_kernel.router.<module>`` access to grouped modules."""
+    group = _resolve_legacy_group(name)
+    if not group:
+        raise AttributeError(f"module 'flare_kernel.router' has no attribute {name!r}")
+
+    target = f"flare_kernel.router.{group}.{name}"
+    module = importlib.import_module(target)
+    # Register alias so direct imports by the legacy module path also resolve.
+    sys.modules.setdefault(f"flare_kernel.router.{name}", module)
+    return module

flare_kernel-0.2.1/src/flare_kernel/router/action_payload.py

@@ -0,0 +1,148 @@
+"""Action target mode and payload shaping helpers."""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Callable
+
+from flare_kernel.contracts import KernelRequest
+
+_LEGACY_SOURCING_BASE_FIELDS_ENV = "FLARE_COMPAT_ENABLE_LEGACY_SOURCING_BASE_FIELDS"
+_LEGACY_SOURCING_BASE_FIELDS = ("category", "region")
+
+
+def resolve_action_target_mode(req: KernelRequest) -> str:
+    target_mode = req.target_mode
+    if isinstance(target_mode, str):
+        normalized = target_mode.strip()
+        if normalized in {"requirement_canvas", "intelligent_sourcing", "plan_mode"}:
+            return normalized
+
+    action_key = req.action_key if isinstance(req.action_key, str) else ""
+    if action_key == "handoff_to_sourcing":
+        return "intelligent_sourcing"
+    if action_key == "handoff_to_domain_flow":
+        return "intelligent_sourcing"
+    if action_key == "continue_collection":
+        return "requirement_canvas"
+    if action_key == "confirm_plan":
+        return "plan_mode"
+    if action_key == "confirm_sourcing":
+        return "intelligent_sourcing"
+    if action_key == "confirm_domain_flow":
+        return "intelligent_sourcing"
+
+    return req.intent if isinstance(req.intent, str) and req.intent.strip() else "default"
+
+
+def _normalize_key(value: Any) -> str:
+    if value is None:
+        return ""
+    return str(value).strip().lower().replace("-", "_").replace(" ", "_")
+
+
+def _extract_value(raw_value: Any) -> Any:
+    if isinstance(raw_value, dict):
+        for candidate in ("value", "content", "text"):
+            candidate_value = raw_value.get(candidate)
+            if candidate_value not in (None, "", [], {}):
+                return candidate_value
+    return raw_value
+
+
+def _legacy_sourcing_base_fields_enabled() -> bool:
+    raw = os.getenv(_LEGACY_SOURCING_BASE_FIELDS_ENV)
+    if raw is None:
+        return False
+    value = raw.strip().lower()
+    return value not in {"0", "false", "off", "no"}
+
+
+def _resolve_sourcing_base_field_keys(payload: dict[str, Any]) -> tuple[str, ...]:
+    explicit = payload.get("sourcing_base_field_keys")
+    if isinstance(explicit, list):
+        normalized = [str(item).strip() for item in explicit if str(item).strip()]
+        if normalized:
+            return tuple(dict.fromkeys(normalized))
+    if _legacy_sourcing_base_fields_enabled():
+        return _LEGACY_SOURCING_BASE_FIELDS
+    return ()
+
+
+def collect_sourcing_base_fields_from_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    base_field_keys = _resolve_sourcing_base_field_keys(payload)
+    if not base_field_keys:
+        return {}
+
+    raw_base_fields = payload.get("base_fields")
+    if isinstance(raw_base_fields, dict):
+        return dict(raw_base_fields)
+
+    base_fields: dict[str, Any] = {}
+    raw_fields = payload.get("fields")
+
+    if isinstance(raw_fields, dict):
+        for key in base_field_keys:
+            if key not in raw_fields:
+                continue
+            value = _extract_value(raw_fields.get(key))
+            if value not in (None, "", [], {}):
+                base_fields[key] = value
+    elif isinstance(raw_fields, list):
+        for raw_item in raw_fields:
+            if not isinstance(raw_item, dict):
+                continue
+            field_key = ""
+            for candidate in ("field_key", "name", "id", "key", "label"):
+                candidate_value = raw_item.get(candidate)
+                if isinstance(candidate_value, str) and candidate_value.strip():
+                    field_key = candidate_value.strip()
+                    break
+            normalized_key = _normalize_key(field_key)
+            if normalized_key not in set(base_field_keys):
+                continue
+            value = _extract_value(raw_item.get("value", raw_item.get("content", raw_item.get("text"))))
+            if value not in (None, "", [], {}):
+                base_fields[normalized_key] = value
+
+    for key in base_field_keys:
+        if key in base_fields:
+            continue
+        value = payload.get(key)
+        if value not in (None, "", [], {}):
+            base_fields[key] = value
+
+    return base_fields
+
+
+def build_action_payload(
+    req: KernelRequest,
+    target_mode: str,
+    *,
+    collect_sourcing_base_fields: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    payload = dict(req.payload) if isinstance(req.payload, dict) else {}
+    payload["function_type"] = target_mode
+    payload["target_mode"] = target_mode
+    if isinstance(req.action_key, str) and req.action_key.strip():
+        payload["action_key"] = req.action_key.strip()
+    if isinstance(req.action_status, str) and req.action_status.strip():
+        payload["action_status"] = req.action_status.strip()
+    if isinstance(req.action_reason, str) and req.action_reason.strip():
+        payload["action_reason"] = req.action_reason.strip()
+    if isinstance(req.action_key, str) and req.action_key.strip() == "confirm_sourcing":
+        payload["sourcing_confirmed"] = True
+    if isinstance(req.retrieval_config, dict) and req.retrieval_config:
+        payload["retrieval_config"] = dict(req.retrieval_config)
+    if isinstance(req.canvas_config, dict) and req.canvas_config:
+        payload["canvas_config"] = dict(req.canvas_config)
+    if isinstance(req.plan_config, dict) and req.plan_config:
+        payload["plan_config"] = dict(req.plan_config)
+
+    if target_mode == "intelligent_sourcing":
+        collect_fn = collect_sourcing_base_fields or collect_sourcing_base_fields_from_payload
+        base_fields = collect_fn(payload)
+        if base_fields:
+            payload["base_fields"] = base_fields
+
+    return payload

flare_kernel-0.2.1/src/flare_kernel/router/canonical/__init__.py

@@ -0,0 +1 @@
+"""Router canonical module group."""

flare_kernel-0.2.1/src/flare_kernel/router/canonical/canonical_state_analysis.py

@@ -0,0 +1,53 @@
+"""Analysis/retrieval projection helpers for canonical state."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def apply_analysis_and_retrieval_projection(
+    *,
+    canonical: dict[str, Any],
+    command: str,
+    can_generate: bool,
+    assistant_text: str,
+    normalized_retrieved_knowledge: list[dict[str, Any]],
+) -> None:
+    if command == "generate_analysis" and can_generate and assistant_text:
+        canonical["analysis"]["sections"].append({"id": "analysis", "title": "需求分析", "content": assistant_text})
+    if command == "generate_analysis" and normalized_retrieved_knowledge:
+        evidence_rows = normalized_retrieved_knowledge[:3]
+        evidence_titles = [str(item.get("title") or item.get("candidate_value") or item.get("snippet") or "证据") for item in evidence_rows]
+        evidence_summary = f"检索到 {len(normalized_retrieved_knowledge)} 条证据"
+        if evidence_titles:
+            evidence_summary = f"{evidence_summary}，重点参考：{'；'.join(evidence_titles[:3])}"
+        canonical["analysis"]["sections"].append(
+            {
+                "id": "evidence",
+                "title": "检索证据",
+                "content": evidence_summary,
+            }
+        )
+    if not normalized_retrieved_knowledge:
+        return
+    comparison_rows: list[dict[str, Any]] = []
+    for item in normalized_retrieved_knowledge[:3]:
+        comparison_rows.append(
+            {
+                "record_id": item.get("record_id"),
+                "chunk_id": item.get("chunk_id"),
+                "title": str(item.get("title") or item.get("candidate_value") or "证据条目"),
+                "source": str(item.get("source") or item.get("source_type") or "local"),
+                "score": item.get("score"),
+                "snippet": str(item.get("snippet") or item.get("content") or "")[:220],
+                "matched_field": str(item.get("matched_field") or ""),
+                "candidate_value": str(item.get("candidate_value") or ""),
+                "confidence": item.get("confidence"),
+                "why_relevant": str(item.get("why_relevant") or ""),
+            }
+        )
+    canonical["capabilities"]["field_retrieval"]["comparison_rows"] = comparison_rows
+    canonical["capabilities"]["field_retrieval"]["recommendation_summary"] = (
+        f"已检索到 {len(normalized_retrieved_knowledge)} 条候选证据，优先查看 "
+        + "；".join(str(item.get("title") or item.get("candidate_value") or "证据条目") for item in comparison_rows)
+    )

flare_kernel-0.2.1/src/flare_kernel/router/canonical/canonical_state_builder.py

@@ -0,0 +1,82 @@
+"""Canonical state projection builder for router responses."""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from flare_kernel.contracts import KernelRequest
+from flare_kernel.router.canonical.canonical_state_context import (
+    resolve_canonical_state_context,
+)
+from flare_kernel.router.canonical.canonical_state_payload import (
+    build_canonical_payload,
+)
+from flare_kernel.router.canonical.canonical_state_projection import (
+    apply_analysis_and_retrieval_projection,
+    normalize_retrieved_knowledge,
+)
+
+
+def build_canonical_state(
+    *,
+    req: KernelRequest,
+    command: str,
+    resolved_intent: str,
+    resolved_mode: str,
+    mode_source: str,
+    orchestration_status: dict[str, Any],
+    runtime_snapshot: dict[str, Any],
+    assistant_text: str,
+    provider_status: str,
+    structured_retrieved_knowledge: list[dict[str, Any]] | None = None,
+    map_external_mode_fn: Callable[[str], str],
+    resolve_session_intent_stage_fn: Callable[..., str],
+    coerce_intent_escalation_policy_fn: Callable[[Any], dict[str, Any]],
+    normalize_stage_status_fn: Callable[..., tuple[str, str]],
+    build_confirmed_fields_schema_fn: Callable[[dict[str, Any], dict[str, Any]], dict[str, Any]],
+    build_missing_fields_schema_fn: Callable[[list[str]], dict[str, Any]],
+    is_field_entity_confirmed_fn: Callable[[Any], bool],
+    extract_user_message_fn: Callable[[dict[str, Any] | None], str],
+    normalize_intake_session_id_fn: Callable[[Any], str],
+    resolve_trace_id_fn: Callable[[str | None], str],
+    safe_session_id_fn: Callable[[Any], str],
+) -> dict[str, Any]:
+    _ = runtime_snapshot
+    normalized_retrieved_knowledge = normalize_retrieved_knowledge(structured_retrieved_knowledge)
+    canonical_context = resolve_canonical_state_context(
+        req=req,
+        command=command,
+        resolved_intent=resolved_intent,
+        resolved_mode=resolved_mode,
+        mode_source=mode_source,
+        orchestration_status=orchestration_status,
+        assistant_text=assistant_text,
+        map_external_mode_fn=map_external_mode_fn,
+        resolve_session_intent_stage_fn=resolve_session_intent_stage_fn,
+        coerce_intent_escalation_policy_fn=coerce_intent_escalation_policy_fn,
+        normalize_stage_status_fn=normalize_stage_status_fn,
+        is_field_entity_confirmed_fn=is_field_entity_confirmed_fn,
+        extract_user_message_fn=extract_user_message_fn,
+        normalize_intake_session_id_fn=normalize_intake_session_id_fn,
+    )
+    canonical = build_canonical_payload(
+        req=req,
+        command=command,
+        mode_source=mode_source,
+        orchestration_status=orchestration_status,
+        assistant_text=assistant_text,
+        provider_status=provider_status,
+        canonical_context=canonical_context,
+        build_confirmed_fields_schema_fn=build_confirmed_fields_schema_fn,
+        build_missing_fields_schema_fn=build_missing_fields_schema_fn,
+        resolve_trace_id_fn=resolve_trace_id_fn,
+        safe_session_id_fn=safe_session_id_fn,
+    )
+    apply_analysis_and_retrieval_projection(
+        canonical=canonical,
+        command=command,
+        can_generate=bool(canonical_context.get("can_generate")),
+        assistant_text=assistant_text,
+        normalized_retrieved_knowledge=normalized_retrieved_knowledge,
+    )
+    return canonical