flare-kernel 0.2.8__tar.gz → 0.2.9__tar.gz

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flare-kernel
-Version: 0.2.8
+Version: 0.2.9
 Summary: FLARE kernel runtime package
 License: Proprietary
 Classifier: Development Status :: 3 - Alpha

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/pyproject.toml

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

flare_kernel-0.2.9/src/flare_kernel/router/canonical/composer_ui.py

@@ -0,0 +1,126 @@
+"""Backend-owned composer UI projection helpers.
+
+The frontend renders this projection; it must not infer chooser visibility,
+recommendation visibility, or dismissal semantics from local keys.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def _trim(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _is_requirement_intake_mode(value: str) -> bool:
+    return _trim(value) == "requirement_intake"
+
+
+def _clean_list(values: list[Any]) -> list[str]:
+    return [_trim(item) for item in values if _trim(item)]
+
+
+def _next_action_keys(next_actions: list[Any]) -> list[str]:
+    keys: list[str] = []
+    for item in next_actions:
+        if not isinstance(item, dict):
+            continue
+        key = _trim(item.get("action_key") or item.get("type"))
+        if key:
+            keys.append(key)
+    return keys
+
+
+def _resolve_chooser_visibility(
+    *,
+    activated_mode: str,
+    stage_key: str,
+    status_key: str,
+    current_question: dict[str, Any] | None,
+    required_missing: list[Any],
+) -> tuple[str, bool]:
+    if _trim(activated_mode) == "auto":
+        return "none", False
+    if stage_key == "requirement_intake" and isinstance(current_question, dict):
+        return "question", True
+    if _is_requirement_intake_mode(activated_mode) and isinstance(current_question, dict):
+        return "question", True
+    if stage_key == "requirement_intake" and status_key in {"collecting", "blocked"} and bool(required_missing):
+        return "question", True
+    return "none", False
+
+
+def _build_dismiss_token(
+    *,
+    chooser_kind: str,
+    stage_key: str,
+    status_key: str,
+    current_question: dict[str, Any] | None,
+    required_missing: list[Any],
+) -> str:
+    if chooser_kind == "none":
+        return ""
+    question = current_question if isinstance(current_question, dict) else {}
+    question_ref = _trim(
+        question.get("question_revision")
+        or question.get("revision")
+        or question.get("question_id")
+        or question.get("field_key")
+    )
+    missing_ref = ",".join(_clean_list(required_missing))
+    parts = [chooser_kind, question_ref or missing_ref, _trim(stage_key), _trim(status_key)]
+    return "|".join([part for part in parts if part])
+
+
+def build_composer_ui_projection(
+    *,
+    activated_mode: str,
+    mode_source: str,
+    stage_key: str,
+    status_key: str,
+    current_question: dict[str, Any] | None,
+    required_missing: list[Any],
+    next_actions: list[Any],
+) -> dict[str, Any]:
+    question_field_key = _trim((current_question or {}).get("field_key"))
+    primary_missing_field = _trim(required_missing[0] if required_missing else "")
+    chooser_kind, chooser_visible = _resolve_chooser_visibility(
+        activated_mode=activated_mode,
+        stage_key=stage_key,
+        status_key=status_key,
+        current_question=current_question,
+        required_missing=required_missing,
+    )
+    dismiss_token = _build_dismiss_token(
+        chooser_kind=chooser_kind,
+        stage_key=stage_key,
+        status_key=status_key,
+        current_question=current_question,
+        required_missing=required_missing,
+    )
+    chooser_state = {
+        "kind": chooser_kind,
+        "visible": chooser_visible,
+        "requires_explicit_user_action": chooser_visible,
+        "dismissible": chooser_visible,
+        "dismiss_token": dismiss_token,
+        "keep_mode_on_submit": chooser_visible,
+        "source": "authoritative",
+        "current_field_key": question_field_key or primary_missing_field,
+        "blocking_fields": _clean_list(required_missing),
+        "next_action_keys": _next_action_keys(next_actions),
+    }
+    active_manual_mode = _trim(activated_mode) not in {"", "auto"}
+    return {
+        "active_mode": _trim(activated_mode) or "auto",
+        "mode_source": _trim(mode_source),
+        "source": "authoritative",
+        "recommendation_panel": {
+            "visible": not active_manual_mode,
+            "source": "authoritative",
+            "reason": "active_mode" if active_manual_mode else "auto_mode",
+        },
+        "composer_chooser": chooser_state,
+        "chooser_state": chooser_state,
+    }

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/src/flare_kernel/router/canonical/payload.py

@@ -15,6 +15,7 @@ from flare_kernel.router.canonical.contract_support import (
     resolve_authoritative_runtime_payload,
     resolve_canvas_analysis_payload,
 )
+from flare_kernel.router.canonical.composer_ui import build_composer_ui_projection
 from flare_kernel.router.canonical.context_authority import build_context_authority_projection
 from flare_kernel.router.canonical.track_actions import build_track_next_actions
 from flare_kernel.router.intake.status.projection import (
@@ -27,10 +28,6 @@ from flare_kernel.router.intent.compat_aliases import (
     resolve_domain_relevance,
 )
 
-def _is_requirement_intake_mode(value: str) -> bool:
-    return str(value or "").strip() == "requirement_intake"
-
-
 def _normalize_canonical_mode(value: str) -> str:
     normalized = str(value or "auto").strip().lower().replace("-", "_").replace(" ", "_")
     return normalized or "auto"
@@ -116,45 +113,16 @@ def build_canonical_payload(
     module_prompt_registry = coerce_action_list(authoritative_runtime_payload.get("module_prompt_registry"))
     current_question = authoritative_current_question
     next_actions = authoritative_next_actions
-    question_field_key = str((current_question or {}).get("field_key") or "").strip()
-    question_kind = str((current_question or {}).get("question_kind") or "").strip().lower()
-    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 (
-            _is_requirement_intake_mode(activated_mode)
-            and isinstance(current_question, dict)
-        ):
-            chooser_kind = "question"
-            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()
-        ],
-    }
+    composer_ui = build_composer_ui_projection(
+        activated_mode=activated_mode,
+        mode_source=mode_source,
+        stage_key=stage_key,
+        status_key=status_key,
+        current_question=current_question,
+        required_missing=required_missing,
+        next_actions=next_actions,
+    )
+    chooser_state = composer_ui["chooser_state"]
     round_projection = build_round_projection(
         intake_session_id=intake_session_id,
         stage_key=stage_key,
@@ -216,7 +184,7 @@ def build_canonical_payload(
     }
     assistant_reply_text = str(assistant_text or "")
     normalized_command = str(command or "").strip().lower()
-    if _is_requirement_intake_mode(activated_mode) and normalized_command not in {"implement", "apply"}:
+    if activated_mode == "requirement_intake" and normalized_command not in {"implement", "apply"}:
         assistant_reply_text = ""
 
     return {
@@ -245,6 +213,7 @@ def build_canonical_payload(
             "stage": stage_key,
             "status": status_key,
             "chooser_state": chooser_state,
+            "composer_ui": composer_ui,
             "intake_session_id": intake_session_id,
             "intake_session_state": intake_session_state,
             "intake_session_completed": intake_session_completed,
@@ -279,6 +248,7 @@ def build_canonical_payload(
         "followup_question": followup_question,
         "question_decision": question_decision,
         "next_actions": authoritative_next_actions,
+        "composer_ui": composer_ui,
         "track_result": track_result,
         "response_strategy_result": response_strategy_result,
         "module_prompt_registry": module_prompt_registry,

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/src/flare_kernel/router/intent/escalation/override.py

@@ -73,8 +73,6 @@ def apply_escalation_mode_override(
         resolved_intent = "requirement_intake"
     elif not str(resolved_intent or "").strip() or str(resolved_intent).strip() == "default":
         resolved_intent = "requirement_intake"
-    resolved_mode = "requirement_intake"
-    mode_source = "intent_and_escalation_classifier"
     intent_source = "intent_and_escalation_classifier"
     intent_confidence = max(float(intent_confidence or 0.0), max(0.0, min(1.0, classifier_confidence)))
     classifier_reason = str(escalation_signal.get("reason") or "").strip()

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/src/flare_kernel/router/kernel_constants/patch.py

@@ -21,6 +21,7 @@ PATCH_SCOPES_AUTHORITATIVE = {
     "track_result",
     "response_strategy_result",
     "module_prompt_registry",
+    "composer_ui",
     "analysis",
     "observation",
     "capabilities.field_retrieval",

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/src/flare_kernel/router/mode/resolution.py

@@ -130,6 +130,15 @@ def _has_source_grounding_route(req: KernelRequest) -> bool:
     route = str(source_grounding.get("route") or "").strip()
     return source_grounding.get("active") is True and route == "source_grounded_answer"
 
+
+def _resolve_mode_from_inferred_intent(resolved_intent: str) -> tuple[str, str]:
+    if not resolved_intent:
+        return "", ""
+    if resolved_intent == "requirement_intake":
+        return "default", "intent_suggestion"
+    return resolved_intent, "intent"
+
+
 def resolve_request_mode(
     req: KernelRequest,
     resolved_intent: str,
@@ -211,7 +220,8 @@ def resolve_request_mode(
         return current_mode, "current_hint"
 
     normalized_resolved_intent = normalize_mode_candidate_fn(resolved_intent)
-    if normalized_resolved_intent:
-        return normalized_resolved_intent, "intent"
+    inferred_mode, inferred_source = _resolve_mode_from_inferred_intent(normalized_resolved_intent)
+    if inferred_source:
+        return inferred_mode, inferred_source
 
     return "default", "fallback"

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/src/flare_kernel/router/streaming/draft/finalize.py

@@ -127,6 +127,7 @@ def iter_canonical_finalize_events(
                 "track_result",
                 "response_strategy_result",
                 "module_prompt_registry",
+                "composer_ui",
                 "analysis",
                 "observation",
                 "capabilities.field_retrieval",
@@ -149,6 +150,7 @@ def iter_canonical_finalize_events(
                 "track_result": canonical.get("track_result"),
                 "response_strategy_result": canonical.get("response_strategy_result"),
                 "module_prompt_registry": canonical.get("module_prompt_registry"),
+                "composer_ui": canonical.get("composer_ui"),
                 "analysis": canonical.get("analysis"),
                 "canvas_analysis_payload": analysis_payload,
                 "analysis_payload": analysis_payload,

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/src/flare_kernel/router/streaming/intake/phase.py

@@ -50,6 +50,7 @@ def iter_intake_state_events(
                 "track_result",
                 "response_strategy_result",
                 "module_prompt_registry",
+                "composer_ui",
             ],
             payload={
                 "mode_key": early_state.get("mode_key"),
@@ -66,6 +67,7 @@ def iter_intake_state_events(
                 "track_result": early_state.get("track_result"),
                 "response_strategy_result": early_state.get("response_strategy_result"),
                 "module_prompt_registry": early_state.get("module_prompt_registry"),
+                "composer_ui": early_state.get("composer_ui"),
                 "canvas_analysis_payload": early_state.get("canvas_analysis_payload"),
                 "analysis_payload": early_state.get("analysis_payload"),
             },

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/src/flare_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flare-kernel
-Version: 0.2.8
+Version: 0.2.9
 Summary: FLARE kernel runtime package
 License: Proprietary
 Classifier: Development Status :: 3 - Alpha

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/src/flare_kernel.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ src/flare_kernel/router/api/update.py
 src/flare_kernel/router/canonical/__init__.py
 src/flare_kernel/router/canonical/analysis.py
 src/flare_kernel/router/canonical/checkpoint.py
+src/flare_kernel/router/canonical/composer_ui.py
 src/flare_kernel/router/canonical/context_authority.py
 src/flare_kernel/router/canonical/contract_support.py
 src/flare_kernel/router/canonical/flow.py

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/tests/test_canonical_state_payload.py

@@ -57,6 +57,10 @@ def test_canonical_payload_uses_question_chooser_when_current_question_exists()
     chooser_state = canonical["primary_flow"]["chooser_state"]
     assert chooser_state["kind"] == "question"
     assert chooser_state["visible"] is True
+    assert chooser_state["dismissible"] is True
+    assert chooser_state["dismiss_token"]
+    assert canonical["composer_ui"]["composer_chooser"] == chooser_state
+    assert canonical["composer_ui"]["recommendation_panel"]["visible"] is False
     assert canonical["primary_flow"]["round_state"] == "completed"
     assert canonical["primary_flow"]["round_id"] == "intake_1"
     assert canonical["question_decision"] == {}
@@ -90,6 +94,8 @@ def test_canonical_payload_stops_stale_runtime_question_after_intake_completed()
     assert canonical["current_question"] is None
     assert canonical["next_actions"] == []
     assert canonical["primary_flow"]["chooser_state"]["visible"] is False
+    assert canonical["composer_ui"]["composer_chooser"]["visible"] is False
+    assert canonical["composer_ui"]["composer_chooser"]["dismiss_token"] == ""
 
 
 def test_canonical_payload_hides_chooser_when_no_question_and_ready() -> None:
@@ -101,6 +107,7 @@ def test_canonical_payload_hides_chooser_when_no_question_and_ready() -> None:
     chooser_state = canonical["primary_flow"]["chooser_state"]
     assert chooser_state["kind"] == "none"
     assert chooser_state["visible"] is False
+    assert canonical["composer_ui"]["composer_chooser"]["visible"] is False
     assert canonical["primary_flow"]["round_state"] == "completed"
     assert canonical["primary_flow"]["round_completed"] is True
 
@@ -296,6 +303,7 @@ def test_canonical_payload_uses_track_decision_as_next_actions_fallback() -> Non
     assert canonical["next_actions"][0]["payload"]["blocking_gaps"] == ["scope"]
     assert canonical["next_actions"][0]["payload"]["non_blocking_gaps"] == ["timeline"]
     assert canonical["assistant_reply"]["text"] == ""
+    assert canonical["composer_ui"]["recommendation_panel"]["visible"] is True
 
 
 def test_canonical_payload_keeps_empty_orchestrated_reply_as_system_notice() -> None:

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/tests/test_flare_v1_patch_contract.py

@@ -169,6 +169,7 @@ def test_stream_emits_patch_event_with_single_final_frame() -> None:
     assert all(item.get("client_request_id") == "req_stream_001" for item in parsed)
     final_payload = finals[0].get("payload") or {}
     assert "primary_flow" in final_payload
+    assert "composer_ui" in final_payload
     assert "intent_state" in final_payload
     assert "assistant_reply" in final_payload
     assert isinstance(final_payload.get("primary_flow", {}).get("intake_session_id"), str)
@@ -176,6 +177,7 @@ def test_stream_emits_patch_event_with_single_final_frame() -> None:
     assert "checkpoint" in (finals[0].get("patch_scope") or [])
     assert "session" in (finals[0].get("patch_scope") or [])
     assert "analysis" in (finals[0].get("patch_scope") or [])
+    assert "composer_ui" in (finals[0].get("patch_scope") or [])
     assert isinstance(final_payload.get("analysis"), dict)
     assert isinstance((final_payload.get("analysis") or {}).get("readiness"), dict)
     assert isinstance(((final_payload.get("analysis") or {}).get("readiness") or {}).get("blocking_fields"), list)

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/tests/test_intent_escalation_classifier.py

@@ -208,7 +208,7 @@ def test_classifier_marks_analysis_running_when_generate_analysis_command() -> N
     assert result.conversation_intent_state == "analysis_running"
 
 
-def test_kernel_mode_override_uses_intent_and_escalation_classifier() -> None:
+def test_kernel_mode_override_keeps_classifier_as_intent_suggestion() -> None:
     resolved = _apply_escalation_mode_override(
         command="send_message",
         resolved_intent="default",
@@ -236,8 +236,8 @@ def test_kernel_mode_override_uses_intent_and_escalation_classifier() -> None:
 
     assert resolved_intent == "requirement_intake"
     assert intent_source == "intent_and_escalation_classifier"
-    assert resolved_mode == "requirement_intake"
-    assert mode_source == "intent_and_escalation_classifier"
+    assert resolved_mode == "default"
+    assert mode_source == "fallback"
     assert intent_confidence >= 0.86
     assert "建议进入梳理候选态" in intent_reason
 

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/tests/test_intent_escalation_override.py

@@ -5,7 +5,7 @@ from flare_kernel.router.intent.escalation.override import (
 )
 
 
-def test_apply_escalation_mode_override_promotes_default_mode() -> None:
+def test_apply_escalation_mode_override_keeps_default_mode() -> None:
     resolved = apply_escalation_mode_override(
         command="send_message",
         resolved_intent="default",
@@ -32,8 +32,8 @@ def test_apply_escalation_mode_override_promotes_default_mode() -> None:
         default_intent_escalation_policy={"auto_mode_override_min_confidence": 0.6},
     )
     assert resolved[0] == "requirement_intake"
-    assert resolved[4] == "requirement_intake"
-    assert resolved[5] == "intent_and_escalation_classifier"
+    assert resolved[4] == "default"
+    assert resolved[5] == "fallback"
 
 
 def test_apply_escalation_mode_override_accepts_domain_relevance_signal_alias() -> None:
@@ -62,4 +62,5 @@ def test_apply_escalation_mode_override_accepts_domain_relevance_signal_alias()
         },
         default_intent_escalation_policy={"auto_mode_override_min_confidence": 0.6},
     )
-    assert resolved[4] == "requirement_intake"
+    assert resolved[0] == "requirement_intake"
+    assert resolved[4] == "default"

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/tests/test_intent_escalation_pipeline.py

@@ -52,7 +52,7 @@ def test_merge_intent_and_escalation_signal_applies_missing_fields() -> None:
     assert merged["session_intent_stage"] == "clarification_in_progress"
 
 
-def test_apply_escalation_mode_override_promotes_default_mode() -> None:
+def test_apply_escalation_mode_override_keeps_default_mode() -> None:
     resolved = apply_escalation_mode_override(
         command="send_message",
         resolved_intent="default",
@@ -79,5 +79,5 @@ def test_apply_escalation_mode_override_promotes_default_mode() -> None:
         default_intent_escalation_policy={"auto_mode_override_min_confidence": 0.6},
     )
     assert resolved[0] == "requirement_intake"
-    assert resolved[4] == "requirement_intake"
-    assert resolved[5] == "intent_and_escalation_classifier"
+    assert resolved[4] == "default"
+    assert resolved[5] == "fallback"

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/tests/test_intent_resolution.py

@@ -144,8 +144,8 @@ def test_resolve_request_mode_without_manual_or_current_uses_resolved_intent() -
     resolved_mode, mode_source = _resolve_request_mode(request, resolved_intent)
 
     assert resolved_intent == "requirement_intake"
-    assert resolved_mode == "requirement_intake"
-    assert mode_source == "intent"
+    assert resolved_mode == "default"
+    assert mode_source == "intent_suggestion"
 
 
 def test_resolve_request_mode_keeps_active_intake_chain_when_auto_mode() -> None:

{flare_kernel-0.2.8 → flare_kernel-0.2.9}/tests/test_mode_resolution.py

@@ -83,6 +83,23 @@ def test_resolve_request_mode_falls_back_to_resolved_intent() -> None:
     assert source == "intent"
 
 
+def test_resolve_request_mode_keeps_requirement_intake_intent_as_suggestion() -> None:
+    req = KernelRequest(intent="default", payload={})
+    resolved_mode, source = resolve_request_mode(
+        req,
+        resolved_intent="requirement_intake",
+        resolve_command_fn=lambda _r: "send_message",
+        should_continue_active_intake_fn=lambda _r, _c: False,
+        resolve_intent_override_fn=lambda _r: "",
+        resolve_manual_mode_fn=lambda _r: "",
+        resolve_current_mode_fn=lambda _r: "",
+        resolve_explicit_intent_fn=lambda _r: "",
+        normalize_mode_candidate_fn=lambda v: "requirement_intake" if v == "requirement_intake" else "",
+    )
+    assert resolved_mode == "default"
+    assert source == "intent_suggestion"
+
+
 def test_resolve_request_mode_prefers_manual_hint_over_inferred_intent() -> None:
     req = KernelRequest(intent="default", manual_mode="requirement_intake", current_mode="requirement_intake", payload={})
     resolved_mode, source = resolve_request_mode(