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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flare-kernel
-Version: 0.2.1
+Version: 0.2.2
 Summary: FLARE kernel runtime package
 License: Proprietary
 Classifier: Development Status :: 3 - Alpha
@@ -22,6 +22,11 @@ Requires-Dist: qdrant-client<2,>=1.9
 
 通用编排与执行内核。
 
+边界文档：
+
+1. `packages/flare-kernel/docs/KERNEL-BOUNDARY.md`
+2. `docs/contracts/agent-contract-v1.md`
+
 职责：
 
 1. Decision 路由与策略入口。

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

@@ -2,6 +2,11 @@
 
 通用编排与执行内核。
 
+边界文档：
+
+1. `packages/flare-kernel/docs/KERNEL-BOUNDARY.md`
+2. `docs/contracts/agent-contract-v1.md`
+
 职责：
 
 1. Decision 路由与策略入口。

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flare-kernel"
-version = "0.2.1"
+version = "0.2.2"
 description = "FLARE kernel runtime package"
 readme = "README.md"
 requires-python = ">=3.11"

{flare_kernel-0.2.1 → flare_kernel-0.2.2}/src/flare_kernel/contracts/kernel_contract.py

@@ -108,6 +108,9 @@ class KnowledgeIngestResponse(BaseModel):
     chunk_count: int
     status: Literal["stored", "partial", "failed"]
     details: dict[str, Any] = Field(default_factory=dict)
+    source_id: str | None = None
+    error_code: str | None = None
+    error_message: str | None = None
 
 
 class KnowledgeSearchRequest(BaseModel):

{flare_kernel-0.2.1 → flare_kernel-0.2.2}/src/flare_kernel/router/canonical/canonical_state_context_analysis.py

@@ -13,6 +13,12 @@ from flare_kernel.router.canonical.canonical_state_projection import (
     build_next_actions_projection,
     resolve_analysis_readiness_metrics,
 )
+from flare_kernel.router.intent.compat_aliases import (
+    project_compat_intent_type,
+    project_domain_relevance,
+    resolve_domain_intent_type,
+    resolve_domain_relevance,
+)
 
 
 def build_canonical_state_context_output(
@@ -109,6 +115,8 @@ def build_canonical_state_context_output(
         if isinstance(context_inputs.get("planner"), dict)
         else {}
     )
+    domain_relevance = resolve_domain_relevance(context_inputs)
+    intent_type_domain = resolve_domain_intent_type(context_inputs, default="qa_only")
     return {
         "active_fields": active_fields,
         "analysis_assumptions": analysis_assumptions,
@@ -131,11 +139,11 @@ def build_canonical_state_context_output(
         "intake_session_completed": bool(context_session["intake_session_completed"]),
         "intake_session_id": context_session["intake_session_id"],
         "intake_session_state": context_session["intake_session_state"],
-        "intent_type": str(context_inputs["intent_type"] or ""),
+        **project_compat_intent_type(intent_type_domain),
         "missing_key_fields": list(context_inputs["missing_key_fields"]),
         "next_actions": next_actions,
         "planner": planner,
-        "procurement_relevance": bool(context_inputs["procurement_relevance"]),
+        **project_domain_relevance(domain_relevance),
         "recommended_next_step": str(context_inputs["recommended_next_step"] or ""),
         "required_coverage": required_coverage,
         "required_missing": list(context_inputs["required_missing"]),

{flare_kernel-0.2.1 → flare_kernel-0.2.2}/src/flare_kernel/router/canonical/canonical_state_context_inputs.py

@@ -7,6 +7,12 @@ from typing import Any, Callable
 from flare_kernel.router.canonical.canonical_state_projection import (
     collect_confirmed_field_values,
 )
+from flare_kernel.router.intent.compat_aliases import (
+    project_compat_intent_type,
+    project_domain_relevance,
+    resolve_domain_intent_type,
+    resolve_domain_relevance,
+)
 
 
 def resolve_canonical_state_context_inputs(
@@ -38,15 +44,17 @@ def resolve_canonical_state_context_inputs(
         orchestration_status=orchestration_status,
         is_field_entity_confirmed_fn=is_field_entity_confirmed_fn,
     )
-    procurement_relevance = bool(
-        orchestration_status.get("procurement_relevance")
-        or str(resolved_intent or "").strip() in {"requirement_canvas", "intelligent_sourcing"}
-        or str(resolved_mode or "").strip() in {"requirement_canvas", "intelligent_sourcing"}
+    domain_relevance = resolve_domain_relevance(
+        orchestration_status,
+        default=(
+            str(resolved_intent or "").strip() in {"requirement_canvas", "intelligent_sourcing"}
+            or str(resolved_mode or "").strip() in {"requirement_canvas", "intelligent_sourcing"}
+        ),
+    )
+    intent_type_domain = resolve_domain_intent_type(
+        orchestration_status,
+        default=("qa_only" if not domain_relevance else "domain_requirement_intake"),
     )
-    intent_type = str(
-        orchestration_status.get("intent_type")
-        or ("qa_only" if not procurement_relevance else "procurement_requirement_intake")
-    ).strip()
     escalation_target = str(orchestration_status.get("escalation_target") or "").strip()
     intake_candidate = bool(orchestration_status.get("intake_candidate"))
     clarification_recommended = bool(orchestration_status.get("clarification_recommended"))
@@ -99,11 +107,11 @@ def resolve_canonical_state_context_inputs(
         "fields": fields,
         "inferred_stage": inferred_stage,
         "intake_candidate": intake_candidate,
-        "intent_type": intent_type,
+        **project_compat_intent_type(intent_type_domain),
         "hypotheses": hypotheses,
         "missing_key_fields": missing_key_fields,
         "planner": planner,
-        "procurement_relevance": procurement_relevance,
+        **project_domain_relevance(domain_relevance),
         "recommended_next_step": recommended_next_step,
         "required_missing": required_missing,
     }

{flare_kernel-0.2.1 → flare_kernel-0.2.2}/src/flare_kernel/router/canonical/canonical_state_flow.py

@@ -2,9 +2,82 @@
 
 from __future__ import annotations
 
+import re
 from typing import Any, Callable
 
 
+_OPTION_LINE_PREFIX_RE = re.compile(r"^\s*(?:[-*•]|\d+[\.\)）])\s*")
+
+
+def _normalize_option_text(value: str) -> str:
+    text = str(value or "").strip()
+    if not text:
+        return ""
+    text = _OPTION_LINE_PREFIX_RE.sub("", text)
+    text = text.lstrip("→> ")
+    text = re.sub(r"`+", "", text)
+    text = re.sub(r"\*\*|__", "", text)
+    text = text.strip(" \t-:：,，。！？!?")
+    if not text:
+        return ""
+    parts = re.split(r"[：:（(\-]", text, maxsplit=1)
+    head = str(parts[0] if parts else text).strip()
+    if not head:
+        return ""
+    return head[:30]
+
+
+def _extract_question_options_from_assistant_text(
+    *,
+    assistant_text: str,
+    field_key: str,
+    max_options: int = 3,
+) -> list[str]:
+    raw_text = str(assistant_text or "").strip()
+    if not raw_text:
+        return []
+    normalized_field = str(field_key or "").strip().lower()
+    field_hints = {
+        "goal": ("目标", "结果", "价值", "成功"),
+        "scope": ("范围", "边界", "模块", "系统"),
+        "constraints": ("时间", "预算", "合规", "技术", "资源", "限制", "许可", "标准"),
+        "parameters": ("数量", "配置", "规格", "性能", "参数", "预算", "许可", "版本", "协议", "兼容"),
+    }.get(normalized_field, ())
+    lines = [str(item or "").strip() for item in raw_text.splitlines()]
+
+    def _collect_candidates(*, apply_field_hints: bool) -> list[str]:
+        candidates: list[str] = []
+        seen: set[str] = set()
+        for line in lines:
+            if not line:
+                continue
+            if not (
+                _OPTION_LINE_PREFIX_RE.match(line)
+                or line.startswith("→")
+                or line.startswith("•")
+            ):
+                continue
+            normalized = _normalize_option_text(line)
+            if len(normalized) < 2:
+                continue
+            if any(token in normalized for token in ("例如", "比如", "请", "说明", "描述")):
+                continue
+            if apply_field_hints and field_hints and not any(hint in normalized for hint in field_hints):
+                continue
+            if normalized in seen:
+                continue
+            seen.add(normalized)
+            candidates.append(normalized)
+            if len(candidates) >= max_options:
+                break
+        return candidates
+
+    with_hints = _collect_candidates(apply_field_hints=True)
+    if with_hints:
+        return with_hints
+    return _collect_candidates(apply_field_hints=False)
+
+
 def resolve_flow_activation(
     *,
     command: str,
@@ -25,7 +98,14 @@ def resolve_flow_activation(
         "activate_requirement_intake",
         "submit_intake_answer",
         "generate_analysis",
-    } or mode_source in {"intent_override", "active_intake", "intent_and_escalation_classifier"}
+    } or mode_source in {
+        "intent_override",
+        "active_intake",
+        "intent_and_escalation_classifier",
+        "manual_hint",
+        "current_hint",
+        "command",
+    }
     should_activate_requirement_flow = bool(
         (
             external_mode == "requirement_intake"
@@ -95,11 +175,40 @@ def normalize_stage_status_and_question(
         resolved_question = None
         if status_key in {"collecting", "blocked"}:
             status_key = "idle"
-    elif isinstance(resolved_question, dict) and intake_session_id:
+    elif (
+        resolved_question is None
+        and required_missing
+        and stage_key == "requirement_intake"
+        and status_key in {"collecting", "blocked"}
+    ):
+        primary_field_key = str(required_missing[0] or "").strip()
+        if primary_field_key:
+            resolved_question = {
+                "field_key": primary_field_key,
+                "field_label": primary_field_key,
+                "question_text": f"请补充「{primary_field_key}」相关信息",
+                "options": [],
+                "step_index": 1,
+                "step_total": len(required_missing),
+            }
+    if isinstance(resolved_question, dict) and intake_session_id:
         resolved_question = {
             **resolved_question,
             "intake_session_id": intake_session_id,
         }
+    if isinstance(resolved_question, dict):
+        existing_options = resolved_question.get("options")
+        has_options = isinstance(existing_options, list) and any(str(item).strip() for item in existing_options)
+        if not has_options and stage_key == "requirement_intake" and status_key in {"collecting", "blocked"}:
+            extracted_options = _extract_question_options_from_assistant_text(
+                assistant_text=assistant_text,
+                field_key=str(resolved_question.get("field_key") or "").strip(),
+            )
+            if extracted_options:
+                resolved_question = {
+                    **resolved_question,
+                    "options": extracted_options,
+                }
     return stage_key, status_key, resolved_question
 
 

{flare_kernel-0.2.1 → flare_kernel-0.2.2}/src/flare_kernel/router/canonical/canonical_state_payload.py

@@ -5,6 +5,15 @@ from __future__ import annotations
 from typing import Any, Callable
 
 from flare_kernel.contracts import KernelRequest
+from flare_kernel.router.intake.intake_status_projection import (
+    build_round_projection,
+)
+from flare_kernel.router.intent.compat_aliases import (
+    project_compat_intent_type,
+    project_domain_relevance,
+    resolve_domain_intent_type,
+    resolve_domain_relevance,
+)
 
 
 def build_canonical_payload(
@@ -30,6 +39,56 @@ def build_canonical_payload(
     can_generate = bool(canonical_context.get("can_generate"))
     explicit_activation = bool(canonical_context.get("explicit_activation"))
     activated_mode = str(canonical_context.get("activated_mode") or "auto").strip() or "auto"
+    stage_key = str(canonical_context.get("stage_key") or "").strip()
+    status_key = str(canonical_context.get("status_key") or "").strip()
+    current_question = canonical_context.get("current_question") if isinstance(canonical_context.get("current_question"), dict) else None
+    next_actions = canonical_context.get("next_actions") if isinstance(canonical_context.get("next_actions"), list) else []
+    question_field_key = str((current_question or {}).get("field_key") or "").strip()
+    primary_missing_field = str((required_missing[0] if required_missing else "") or "").strip()
+    chooser_kind = "none"
+    chooser_visible = False
+    if activated_mode != "auto":
+        if (
+            stage_key == "requirement_intake"
+            and isinstance(current_question, dict)
+        ):
+            chooser_kind = "question"
+            chooser_visible = True
+        elif stage_key == "requirement_intake" and status_key == "ready_for_submit":
+            chooser_kind = "decision_point"
+            chooser_visible = True
+        elif (
+            stage_key == "requirement_intake"
+            and status_key in {"collecting", "blocked"}
+            and bool(required_missing)
+        ):
+            chooser_kind = "question"
+            chooser_visible = True
+    chooser_state = {
+        "kind": chooser_kind,
+        "visible": chooser_visible,
+        "requires_explicit_user_action": chooser_visible,
+        "source": "authoritative",
+        "current_field_key": question_field_key or primary_missing_field,
+        "blocking_fields": [str(item) for item in required_missing if str(item).strip()],
+        "next_action_keys": [
+            str(item.get("action_key") or item.get("type") or "").strip()
+            for item in next_actions
+            if isinstance(item, dict)
+            and str(item.get("action_key") or item.get("type") or "").strip()
+        ],
+    }
+    round_projection = build_round_projection(
+        intake_session_id=intake_session_id,
+        stage_key=stage_key,
+        status_key=status_key,
+        intake_session_state=intake_session_state,
+        current_question=current_question,
+        checkpoint=canonical_context.get("checkpoint") if isinstance(canonical_context.get("checkpoint"), dict) else {},
+        next_actions=next_actions,
+    )
+    domain_relevance = resolve_domain_relevance(canonical_context)
+    intent_type_domain = resolve_domain_intent_type(canonical_context, default="qa_only")
 
     return {
         "contract_version": str(req.contract_version or "flare.v1"),
@@ -51,21 +110,23 @@ def build_canonical_payload(
                 "is_activation_explicit": explicit_activation and activated_mode != "auto",
                 "activation_source": mode_source if explicit_activation else "none",
             },
-            "stage": str(canonical_context.get("stage_key") or ""),
-            "status": str(canonical_context.get("status_key") or ""),
+            "stage": stage_key,
+            "status": status_key,
+            "chooser_state": chooser_state,
             "intake_session_id": intake_session_id,
             "intake_session_state": intake_session_state,
             "intake_session_completed": intake_session_completed,
             "checkpoint": canonical_context.get("checkpoint"),
+            **round_projection,
         },
         "checkpoint": canonical_context.get("checkpoint"),
         "intent_state": {
-            "intent_type": str(canonical_context.get("intent_type") or ""),
+            **project_compat_intent_type(intent_type_domain),
             "session_intent_stage": str(canonical_context.get("session_intent_stage") or ""),
             "conversation_intent_state": str(canonical_context.get("conversation_intent_state") or ""),
-            "procurement_relevance": bool(canonical_context.get("procurement_relevance")),
+            **project_domain_relevance(domain_relevance),
             "escalation_target": str(canonical_context.get("escalation_target") or "")
-            or ("qa_only" if not bool(canonical_context.get("procurement_relevance")) else "intake_candidate"),
+            or ("qa_only" if not domain_relevance else "intake_candidate"),
             "intake_candidate": bool(canonical_context.get("intake_candidate")),
             "clarification_recommended": bool(canonical_context.get("clarification_recommended")),
             "analysis_ready": bool(canonical_context.get("analysis_ready")),
@@ -79,12 +140,10 @@ def build_canonical_payload(
                 canonical_context.get("resolved_intent_escalation_policy_source") or "default"
             ),
         },
-        "question": canonical_context.get("current_question"),
+        "question": current_question,
         "confirmed_fields": build_confirmed_fields_schema_fn(fields, field_entities),
         "missing_fields": build_missing_fields_schema_fn([str(item) for item in required_missing if str(item).strip()]),
-        "next_actions": canonical_context.get("next_actions")
-        if isinstance(canonical_context.get("next_actions"), list)
-        else [],
+        "next_actions": next_actions,
         "analysis": {
             "readiness": {
                 "can_generate": can_generate,

{flare_kernel-0.2.1 → flare_kernel-0.2.2}/src/flare_kernel/router/canonical/canonical_state_projection.py

@@ -10,6 +10,7 @@ from flare_kernel.router.canonical.canonical_state_analysis import (
 from flare_kernel.router.canonical.canonical_state_checkpoint import (
     build_checkpoint_projection,
 )
+from flare_kernel.router.next_actions_guard import dedupe_next_actions_by_action_key
 
 
 def normalize_retrieved_knowledge(
@@ -72,7 +73,7 @@ def build_next_actions_projection(
         if isinstance(orchestration_status.get("next_actions"), list)
         else []
     )
-    for action in raw_actions:
+    for action in dedupe_next_actions_by_action_key(raw_actions):
         if not isinstance(action, dict):
             continue
         action_key = str(action.get("action_key") or action.get("type") or "").strip()

{flare_kernel-0.2.1 → flare_kernel-0.2.2}/src/flare_kernel/router/completion_response_builder.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any, Callable
 
 from flare_kernel.contracts import KernelResponse
+from flare_kernel.router.next_actions_guard import dedupe_next_actions_by_action_key
 
 
 def apply_completion_content_policy(
@@ -36,6 +37,9 @@ def build_run_result_payload(
     mode_switch_reason: dict[str, Any],
     build_knowledge_citations_fn: Callable[[list[dict[str, Any]]], list[dict[str, Any]]],
 ) -> dict[str, Any]:
+    next_actions = dedupe_next_actions_by_action_key(
+        orchestration_status.get("next_actions", runtime_snapshot["next_actions"])
+    )
     return {
         "message": content_text,
         "provider": completion_provider,
@@ -59,7 +63,7 @@ def build_run_result_payload(
             },
         },
         "mode_events": runtime_snapshot["mode_events"],
-        "next_actions": orchestration_status.get("next_actions", runtime_snapshot["next_actions"]),
+        "next_actions": next_actions,
         "retrieved_knowledge": structured_retrieved_knowledge,
         "knowledge_citation": build_knowledge_citations_fn(structured_retrieved_knowledge),
         "orchestration_status": orchestration_status,
@@ -80,6 +84,9 @@ def build_action_result_payload(
     action_status: str | None,
     action_reason: str | None,
 ) -> dict[str, Any]:
+    next_actions = dedupe_next_actions_by_action_key(
+        orchestration_status.get("next_actions", runtime_snapshot["next_actions"])
+    )
     return {
         "message": content_text,
         "provider": completion_provider,
@@ -102,7 +109,7 @@ def build_action_result_payload(
             },
         },
         "mode_events": runtime_snapshot["mode_events"],
-        "next_actions": orchestration_status.get("next_actions", runtime_snapshot["next_actions"]),
+        "next_actions": next_actions,
         "orchestration_status": orchestration_status,
         "selected_action": {
             "action_key": action_key,
@@ -120,10 +127,13 @@ def build_kernel_success_response(
     runtime_snapshot: dict[str, Any],
     orchestration_status: dict[str, Any],
 ) -> KernelResponse:
+    next_actions = dedupe_next_actions_by_action_key(
+        orchestration_status.get("next_actions", runtime_snapshot["next_actions"])
+    )
     return KernelResponse(
         trace_id=trace_id,
         state="SUCCEEDED",
         events=[],
         result=result,
-        next_actions=orchestration_status.get("next_actions", runtime_snapshot["next_actions"]),
+        next_actions=next_actions,
     )

{flare_kernel-0.2.1 → flare_kernel-0.2.2}/src/flare_kernel/router/endpoint_context.py

@@ -7,6 +7,36 @@ from typing import Any, Callable
 from flare_kernel.contracts import KernelRequest
 
 
+def _normalize_plan_action_command(*, action_command: str, action_key: str | None) -> str:
+    if isinstance(action_key, str) and action_key.strip():
+        return action_key.strip()
+    normalized = str(action_command or "").strip()
+    if normalized in {"", "send_message", "apply_field_candidate"}:
+        return ""
+    return normalized
+
+
+def _sanitize_plan_mode_action_payload(
+    *,
+    payload: dict[str, Any],
+    target_mode: str,
+    action_command: str,
+    action_key: str | None,
+) -> dict[str, Any]:
+    if str(target_mode or "").strip() != "plan_mode":
+        return dict(payload)
+
+    normalized = _normalize_plan_action_command(action_command=action_command, action_key=action_key)
+    sanitized = dict(payload)
+    for key in ("command", "action_key", "selected_action_key", "next_action"):
+        sanitized.pop(key, None)
+    if normalized:
+        sanitized["action_command"] = normalized
+    else:
+        sanitized.pop("action_command", None)
+    return sanitized
+
+
 def unpack_kernel_turn_context(turn: dict[str, Any]) -> dict[str, Any]:
     return {
         "trace_id": str(turn["trace_id"]),
@@ -61,6 +91,12 @@ def prepare_action_turn_context(
     action_command = resolve_command_fn(req)
     action_target_mode = resolve_action_target_mode_fn(req)
     action_payload = build_action_payload_fn(req, action_target_mode)
+    action_payload = _sanitize_plan_mode_action_payload(
+        payload=action_payload,
+        target_mode=action_target_mode,
+        action_command=action_command,
+        action_key=req.action_key if isinstance(req.action_key, str) else None,
+    )
     if isinstance(req.project_id, str) and req.project_id.strip():
         action_payload["project_id"] = req.project_id.strip()
     if isinstance(req.user_id, str) and req.user_id.strip():
@@ -73,6 +109,12 @@ def prepare_action_turn_context(
         resolved_mode=action_target_mode,
         retrieved_knowledge=[],
     )
+    action_payload = _sanitize_plan_mode_action_payload(
+        payload=action_payload,
+        target_mode=action_target_mode,
+        action_command=action_command,
+        action_key=req.action_key if isinstance(req.action_key, str) else None,
+    )
     runtime_snapshot = build_kernel_runtime_fn(
         trace_id=trace_id,
         tenant_id=req.tenant_id,

flare_kernel-0.2.2/src/flare_kernel/router/guided_completion.py

@@ -0,0 +1,68 @@
+"""Guided-session completion helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from flare_kernel.contracts import KernelRequest
+from flare_kernel.runtime.llm.llm_provider import LLMCompletion
+
+
+def _is_collecting_question_phase(orchestration_status: dict[str, Any]) -> bool:
+    status = orchestration_status if isinstance(orchestration_status, dict) else {}
+    current_stage = str(status.get("current_stage") or "").strip().lower()
+    if not current_stage.startswith("requirement_intake"):
+        return False
+    chooser_state = status.get("chooser_state") if isinstance(status.get("chooser_state"), dict) else {}
+    chooser_kind = str(chooser_state.get("kind") or "").strip().lower()
+    has_current_question = isinstance(status.get("current_question"), dict)
+    if has_current_question:
+        return True
+    if chooser_kind == "question":
+        return True
+    if bool(status.get("has_active_question")):
+        return True
+    state = str(status.get("intake_session_state") or "").strip().lower()
+    if state in {"collecting", "blocked"}:
+        return True
+    return False
+
+
+def resolve_guided_orchestrated_completion(
+    *,
+    req: KernelRequest,
+    command: str,
+    resolved_mode: str,
+    mode_source: str,
+    runtime_snapshot: dict[str, Any],
+    orchestration_status: dict[str, Any],
+) -> LLMCompletion | None:
+    _ = (req, mode_source, runtime_snapshot)
+    normalized_mode = str(resolved_mode or "").strip()
+    normalized_command = str(command or "").strip()
+    if normalized_mode != "requirement_canvas":
+        return None
+    if normalized_command not in {"send_message", "submit_intake_answer", "activate_requirement_intake"}:
+        return None
+    if not _is_collecting_question_phase(orchestration_status):
+        return None
+    _ = req
+    return LLMCompletion(
+        provider="kernel_guardrail",
+        model="guided_session",
+        content="",
+        status="orchestrated",
+        details={
+            "reason": "guided_session_patch_only",
+            "phase": "collecting_question",
+            "mode": normalized_mode,
+            "command": normalized_command,
+        },
+    )
+
+
+def should_persist_memory_record(*, completion: LLMCompletion) -> bool:
+    details = completion.details if isinstance(completion.details, dict) else {}
+    if str(details.get("reason") or "").strip() == "guided_session_patch_only":
+        return False
+    return True

{flare_kernel-0.2.1 → flare_kernel-0.2.2}/src/flare_kernel/router/intake/intake_authority_hydration.py

@@ -18,10 +18,20 @@ def hydrate_payload_from_authoritative_intake_session(
     persisted = dict(persisted_payload) if isinstance(persisted_payload, dict) else {}
     status = dict(persisted_status) if isinstance(persisted_status, dict) else {}
 
-    if not merged.get("fields") and isinstance(persisted.get("fields"), dict):
-        merged["fields"] = dict(persisted.get("fields"))
-    if not merged.get("field_sources") and isinstance(persisted.get("field_sources"), dict):
-        merged["field_sources"] = dict(persisted.get("field_sources"))
+    persisted_fields = persisted.get("fields") if isinstance(persisted.get("fields"), dict) else {}
+    incoming_fields = merged.get("fields") if isinstance(merged.get("fields"), dict) else {}
+    if persisted_fields or incoming_fields:
+        merged["fields"] = {
+            **dict(persisted_fields),
+            **dict(incoming_fields),
+        }
+    persisted_sources = persisted.get("field_sources") if isinstance(persisted.get("field_sources"), dict) else {}
+    incoming_sources = merged.get("field_sources") if isinstance(merged.get("field_sources"), dict) else {}
+    if persisted_sources or incoming_sources:
+        merged["field_sources"] = {
+            **dict(persisted_sources),
+            **dict(incoming_sources),
+        }
 
     for key in (
         "required_fields",