flare-kernel 0.2.3__tar.gz → 0.2.4__tar.gz

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/PKG-INFO

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

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/pyproject.toml

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

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/contracts/kernel_contract.py

@@ -73,7 +73,7 @@ class KernelRequest(BaseModel):
 
 class AnalysisRouteDecision(BaseModel):
     analysis_type: Literal["requirement", "sourcing"] = "requirement"
-    template_id: str = "analysis_requirement_default"
+    template_id: str = "flare.requirement.rfx.v1"
     reason_codes: list[str] = Field(default_factory=list)
     confidence: float = 0.0
 
@@ -176,6 +176,7 @@ class SourcingSearchResponse(BaseModel):
     all_results: list[dict[str, Any]] = Field(default_factory=list)
     results: list[dict[str, Any]] = Field(default_factory=list)
     shortlist: list[dict[str, Any]] = Field(default_factory=list)
+    canvas_state: dict[str, Any] = Field(default_factory=dict)
     blocked: bool = False
     reason: str = ""
 

flare_kernel-0.2.4/src/flare_kernel/router/analysis_canvas_payload.py

@@ -0,0 +1,74 @@
+"""Analysis canvas payload orchestration bridge."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from flare_engines import build_analysis_canvas_payload
+
+
+def _coerce_context_dict(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+    return {}
+
+
+def _resolve_analysis_context(
+    *,
+    analysis_route: dict[str, Any] | None,
+    orchestration_status: dict[str, Any] | None,
+    runtime_snapshot: dict[str, Any] | None,
+) -> dict[str, Any]:
+    status = _coerce_context_dict(orchestration_status)
+    snapshot = _coerce_context_dict(runtime_snapshot)
+    payload = _coerce_context_dict(snapshot.get("payload"))
+    route = _coerce_context_dict(analysis_route)
+    return {
+        "analysis_type": str(route.get("analysis_type") or "requirement").strip().lower(),
+        "template_id": str(route.get("template_id") or "").strip(),
+        "mode": str(status.get("detected_intent", {}).get("mode") or payload.get("mode") or "").strip(),
+        "intent": str(status.get("detected_intent", {}).get("intent") or "").strip(),
+        "fields": _coerce_context_dict(payload.get("fields")),
+        "field_entities": _coerce_context_dict(status.get("field_entities")),
+        "required_missing": (
+            status.get("required_missing")
+            if isinstance(status.get("required_missing"), list)
+            else (payload.get("required_missing") if isinstance(payload.get("required_missing"), list) else [])
+        ),
+        "retrieved_knowledge": (
+            payload.get("retrieved_knowledge")
+            if isinstance(payload.get("retrieved_knowledge"), list)
+            else []
+        ),
+        "structured_retrieved_knowledge": (
+            status.get("structured_retrieved_knowledge")
+            if isinstance(status.get("structured_retrieved_knowledge"), list)
+            else []
+        ),
+    }
+
+
+def build_canvas_analysis_payload(
+    *,
+    analysis_route: dict[str, Any] | None,
+    content_text: str,
+    previous_payload: dict[str, Any] | None = None,
+    orchestration_status: dict[str, Any] | None = None,
+    runtime_snapshot: dict[str, Any] | None = None,
+) -> tuple[dict[str, Any] | None, list[dict[str, Any]]]:
+    _ = content_text
+    context = _resolve_analysis_context(
+        analysis_route=analysis_route,
+        orchestration_status=orchestration_status,
+        runtime_snapshot=runtime_snapshot,
+    )
+    return build_analysis_canvas_payload(
+        analysis_type=str(context.get("analysis_type") or "requirement"),
+        template_id=str(context.get("template_id") or ""),
+        context=context,
+        previous_payload=previous_payload,
+        placeholder="—",
+    )
+
+
+__all__ = ["build_canvas_analysis_payload"]

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/canonical/canonical_state_payload.py

@@ -16,6 +16,16 @@ from flare_kernel.router.intent.compat_aliases import (
 )
 
 
+def _resolve_analysis_title(*, command: str, can_generate: bool, orchestration_status: dict[str, Any]) -> str:
+    if command != "generate_analysis" or not can_generate:
+        return ""
+    analysis_route = orchestration_status.get("analysis_route")
+    if isinstance(analysis_route, dict):
+        if str(analysis_route.get("analysis_type") or "").strip().lower() == "sourcing":
+            return "寻源分析"
+    return "需求分析"
+
+
 def build_canonical_payload(
     *,
     req: KernelRequest,
@@ -44,6 +54,7 @@ def build_canonical_payload(
     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()
+    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
@@ -54,6 +65,18 @@ def build_canonical_payload(
         ):
             chooser_kind = "question"
             chooser_visible = True
+        elif (
+            activated_mode == "plan_mode"
+            and isinstance(current_question, dict)
+        ):
+            chooser_kind = "question"
+            chooser_visible = True
+        elif (
+            isinstance(current_question, dict)
+            and question_kind == "plan_followup"
+        ):
+            chooser_kind = "question"
+            chooser_visible = True
         elif stage_key == "requirement_intake" and status_key == "ready_for_submit":
             chooser_kind = "decision_point"
             chooser_visible = True
@@ -155,12 +178,26 @@ def build_canonical_payload(
                 "analysis_entry_eligible": bool(canonical_context.get("analysis_entry_eligible")),
                 "analyzability_score": float(canonical_context.get("analyzability_score") or 0.0),
             },
-            "title": "需求分析" if command == "generate_analysis" and can_generate else "",
+            "title": _resolve_analysis_title(
+                command=command,
+                can_generate=can_generate,
+                orchestration_status=orchestration_status,
+            ),
             "sections": [],
             "assumptions": canonical_context.get("analysis_assumptions")
             if isinstance(canonical_context.get("analysis_assumptions"), list)
             else [],
         },
+        "canvas_analysis_payload": (
+            orchestration_status.get("canvas_analysis_payload")
+            if isinstance(orchestration_status.get("canvas_analysis_payload"), dict)
+            else None
+        ),
+        "analysis_slot_patches": (
+            orchestration_status.get("analysis_slot_patches")
+            if isinstance(orchestration_status.get("analysis_slot_patches"), list)
+            else []
+        ),
         "observation": {
             "active_fields": canonical_context.get("active_fields")
             if isinstance(canonical_context.get("active_fields"), list)

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/completion_response_builder.py

@@ -8,6 +8,86 @@ from flare_kernel.contracts import KernelResponse
 from flare_kernel.router.next_actions_guard import dedupe_next_actions_by_action_key
 
 
+def _append_sourcing_preview_lines(
+    *,
+    content_text: str,
+    mode_key: str,
+    mode_state: str,
+    structured_retrieved_knowledge: list[dict[str, Any]],
+) -> str:
+    if mode_key != "intelligent_sourcing" or mode_state != "collecting":
+        return content_text
+    if not isinstance(structured_retrieved_knowledge, list) or not structured_retrieved_knowledge:
+        return content_text
+
+    lines: list[str] = []
+    for item in structured_retrieved_knowledge[:2]:
+        if not isinstance(item, dict):
+            continue
+        title = str(item.get("title") or "").strip()
+        if not title:
+            continue
+        try:
+            confidence = max(0.0, min(1.0, float(item.get("confidence") or item.get("score") or 0.0)))
+        except (TypeError, ValueError):
+            confidence = 0.0
+        url = str(item.get("url") or "").strip()
+        line = f"- {title}（置信度 {confidence:.2f}）"
+        if url:
+            line += f"\n  来源：{url}"
+        lines.append(line)
+    if not lines:
+        return content_text
+
+    extra = "先给您两条预检索参考（补充字段后我会重排）：\n" + "\n".join(lines)
+    base = str(content_text or "").rstrip()
+    return f"{base}\n\n{extra}".strip()
+
+
+def _format_citation_line(citation: dict[str, Any], index: int) -> str:
+    citation_id = str(citation.get("citation_id") or f"cite_{index + 1}").strip()
+    title = str(citation.get("title") or citation.get("source_id") or "引用条目").strip()
+    snippet = str(
+        citation.get("snippet")
+        or citation.get("matched_text")
+        or citation.get("hit_reason")
+        or ""
+    ).strip()
+    url = str(citation.get("url") or citation.get("source_url") or "").strip()
+    try:
+        score_value = float(citation.get("score")) if citation.get("score") is not None else None
+    except (TypeError, ValueError):
+        score_value = None
+    score_suffix = f"（相关度 {score_value:.2f}）" if score_value is not None else ""
+    detail_text = f"：{snippet}" if snippet else ""
+    link_text = f"\n链接：{url}" if url else ""
+    return f"[{citation_id}] {title}{score_suffix}{detail_text}{link_text}".strip()
+
+
+def _build_citation_appendix(citations: list[dict[str, Any]]) -> str:
+    lines = [
+        _format_citation_line(citation, index)
+        for index, citation in enumerate(citations[:3])
+        if isinstance(citation, dict)
+    ]
+    lines = [line for line in lines if line]
+    if not lines:
+        return ""
+    return "引用来源：\n" + "\n\n".join(lines)
+
+
+def _append_citation_lines(*, content_text: str, citations: list[dict[str, Any]]) -> str:
+    appendix = _build_citation_appendix(citations)
+    if not appendix:
+        return str(content_text or "").strip()
+    base = str(content_text or "").strip()
+    if not base:
+        return appendix
+    if appendix in base:
+        return base
+    return f"{base}\n\n{appendix}".strip()
+
+
 def apply_completion_content_policy(
     *,
     orchestration_status: dict[str, Any],
@@ -37,11 +117,22 @@ 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]:
+    knowledge_citation = build_knowledge_citations_fn(structured_retrieved_knowledge)
+    final_message = _append_sourcing_preview_lines(
+        content_text=content_text,
+        mode_key=str(runtime_snapshot["mode_key"]),
+        mode_state=str(runtime_snapshot["mode_state"]),
+        structured_retrieved_knowledge=structured_retrieved_knowledge,
+    )
+    final_message = _append_citation_lines(
+        content_text=final_message,
+        citations=knowledge_citation,
+    )
     next_actions = dedupe_next_actions_by_action_key(
         orchestration_status.get("next_actions", runtime_snapshot["next_actions"])
     )
     return {
-        "message": content_text,
+        "message": final_message,
         "provider": completion_provider,
         "model": completion_model,
         "provider_status": completion_status,
@@ -65,7 +156,7 @@ def build_run_result_payload(
         "mode_events": runtime_snapshot["mode_events"],
         "next_actions": next_actions,
         "retrieved_knowledge": structured_retrieved_knowledge,
-        "knowledge_citation": build_knowledge_citations_fn(structured_retrieved_knowledge),
+        "knowledge_citation": knowledge_citation,
         "orchestration_status": orchestration_status,
     }
 

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/guided_completion.py

@@ -7,6 +7,8 @@ from typing import Any
 from flare_kernel.contracts import KernelRequest
 from flare_kernel.runtime.llm.llm_provider import LLMCompletion
 
+_PLAN_MODE_FINALIZE_COMMANDS = {"implement", "apply"}
+
 
 def _is_collecting_question_phase(orchestration_status: dict[str, Any]) -> bool:
     status = orchestration_status if isinstance(orchestration_status, dict) else {}
@@ -28,6 +30,23 @@ def _is_collecting_question_phase(orchestration_status: dict[str, Any]) -> bool:
     return False
 
 
+def _is_plan_mode_patch_only_phase(*, command: str, orchestration_status: dict[str, Any]) -> bool:
+    if str(command or "").strip() in _PLAN_MODE_FINALIZE_COMMANDS:
+        return False
+    status = orchestration_status if isinstance(orchestration_status, dict) else {}
+    chooser_state = status.get("chooser_state") if isinstance(status.get("chooser_state"), dict) else {}
+    chooser_kind = str(chooser_state.get("kind") or "").strip().lower()
+    if chooser_kind == "question" and chooser_state.get("visible") is True:
+        return True
+    current_question = status.get("current_question")
+    if isinstance(current_question, dict):
+        return True
+    followup_question = status.get("followup_question")
+    if isinstance(followup_question, dict) and str(followup_question.get("question_text") or "").strip():
+        return True
+    return True
+
+
 def resolve_guided_orchestrated_completion(
     *,
     req: KernelRequest,
@@ -40,6 +59,24 @@ def resolve_guided_orchestrated_completion(
     _ = (req, mode_source, runtime_snapshot)
     normalized_mode = str(resolved_mode or "").strip()
     normalized_command = str(command or "").strip()
+    if normalized_mode == "plan_mode":
+        if _is_plan_mode_patch_only_phase(
+            command=normalized_command,
+            orchestration_status=orchestration_status,
+        ):
+            return LLMCompletion(
+                provider="kernel_guardrail",
+                model="guided_session",
+                content="",
+                status="orchestrated",
+                details={
+                    "reason": "plan_mode_patch_only",
+                    "phase": "plan_refinement",
+                    "mode": normalized_mode,
+                    "command": normalized_command,
+                },
+            )
+        return None
     if normalized_mode != "requirement_canvas":
         return None
     if normalized_command not in {"send_message", "submit_intake_answer", "activate_requirement_intake"}:
@@ -63,6 +100,6 @@ def resolve_guided_orchestrated_completion(
 
 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":
+    if str(details.get("reason") or "").strip() in {"guided_session_patch_only", "plan_mode_patch_only"}:
         return False
     return True

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/intake/intake_authority_hydration.py

@@ -41,9 +41,16 @@ def hydrate_payload_from_authoritative_intake_session(
         "optional_fields",
         "optional_missing",
         "question_progress",
+        "plan_context_state",
+        "followup_question",
+        "plan_summary_handoff",
+        "plan_summary_contract",
+        "canvas_analysis_payload",
     ):
         if (key not in merged or merged.get(key) in (None, "", [], {})) and key in persisted:
             merged[key] = persisted.get(key)
+    if (not isinstance(merged.get("canvas_analysis_payload"), dict)) and isinstance(status.get("canvas_analysis_payload"), dict):
+        merged["canvas_analysis_payload"] = status.get("canvas_analysis_payload")
 
     if not str(merged.get("intake_session_id") or "").strip():
         session_id = str(status.get("intake_session_id") or persisted.get("intake_session_id") or "").strip()

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/kernel.py

@@ -14,8 +14,17 @@ from flare_kernel.contracts import (
     KnowledgeIngestResponse,
     KnowledgeSearchRequest,
     KnowledgeSearchResponse,
+    SourcingSearchRequest,
+    SourcingSearchResponse,
 )
 from flare_kernel.router.kernel_compat_exports import *  # noqa: F401,F403
+from flare_kernel.router.kernel_endpoint_handlers_sourcing import (
+    handle_sourcing_search as handle_sourcing_search_from_router,
+)
+from flare_kernel.runtime.infrastructure.sourcing_persistence import persist_sourcing_run_bundle
+from flare_kernel.runtime.infrastructure.sourcing_provider import search_web_sources
+from flare_kernel.runtime.infrastructure.infrastructure import build_sqlalchemy_engine
+from flare_kernel.runtime.orchestration.sourcing_search_runtime import run_sourcing_search
 
 router = APIRouter(prefix="/kernel", tags=["kernel"])
 logger = get_logger("flare_kernel.router.kernel")
@@ -120,3 +129,18 @@ async def kernel_knowledge_search(req: KnowledgeSearchRequest) -> KnowledgeSearc
         resolve_trace_id_fn=resolve_trace_id,
         search_knowledge_records_fn=search_knowledge_records,
     )
+
+
+@router.post("/sourcing/search", response_model=SourcingSearchResponse)
+async def kernel_sourcing_search(req: SourcingSearchRequest) -> SourcingSearchResponse:
+    return handle_sourcing_search_from_router(
+        req,
+        resolve_trace_id_fn=resolve_trace_id,
+        run_sourcing_search_fn=run_sourcing_search,
+        search_knowledge_records_fn=search_knowledge_records,
+        search_web_sources_fn=search_web_sources,
+        persist_sourcing_run_bundle_fn=lambda **kwargs: persist_sourcing_run_bundle(
+            **kwargs,
+            build_sqlalchemy_engine_fn=build_sqlalchemy_engine,
+        ),
+    )

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/kernel_compat_exports_parts/endpoint.py

@@ -44,6 +44,7 @@ from flare_kernel.router.kernel_endpoint_handlers import (
     handle_kernel_stream as handle_kernel_stream_from_router,
     handle_knowledge_ingest as handle_knowledge_ingest_from_router,
     handle_knowledge_search as handle_knowledge_search_from_router,
+    handle_sourcing_search as handle_sourcing_search_from_router,
 )
 
 

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/kernel_endpoint_handlers.py

@@ -11,6 +11,7 @@ from flare_kernel.router.kernel_endpoint_handlers_knowledge import (
     handle_knowledge_ingest,
     handle_knowledge_search,
 )
+from flare_kernel.router.kernel_endpoint_handlers_sourcing import handle_sourcing_search
 from flare_kernel.router.kernel_endpoint_handlers_turn import (
     handle_intent_suggest,
     handle_kernel_action,
@@ -26,4 +27,5 @@ __all__ = [
     "handle_kernel_stream",
     "handle_knowledge_ingest",
     "handle_knowledge_search",
+    "handle_sourcing_search",
 ]

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/kernel_endpoint_handlers_sourcing.py

@@ -12,6 +12,9 @@ def handle_sourcing_search(
     *,
     resolve_trace_id_fn: Callable[[str | None], str],
     run_sourcing_search_fn,
+    search_knowledge_records_fn,
+    search_web_sources_fn,
+    persist_sourcing_run_bundle_fn=None,
 ) -> SourcingSearchResponse:
     trace_id = resolve_trace_id_fn(None)
     source_ids = [str(item).strip() for item in (req.source_ids or []) if str(item).strip()]
@@ -29,6 +32,9 @@ def handle_sourcing_search(
         base_result_ids=req.base_result_ids,
         source_scope=req.source_scope,
         sourcing_enabled=req.sourcing_enabled,
+        search_knowledge_records_fn=search_knowledge_records_fn,
+        search_web_sources_fn=search_web_sources_fn,
+        persist_sourcing_run_bundle_fn=persist_sourcing_run_bundle_fn,
         source_ids=source_ids,
         entities=req.entities,
     )
@@ -52,6 +58,7 @@ def handle_sourcing_search(
         all_results=result.get("all_results") if isinstance(result.get("all_results"), list) else [],
         results=result.get("results") if isinstance(result.get("results"), list) else [],
         shortlist=result.get("shortlist") if isinstance(result.get("shortlist"), list) else [],
+        canvas_state=result.get("canvas_state") if isinstance(result.get("canvas_state"), dict) else {},
         blocked=bool(result.get("blocked")),
         reason=str(result.get("reason") or ""),
     )

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/kernel_facade_turn_context.py

@@ -10,6 +10,9 @@ from typing import Any, Callable
 
 from flare_kernel.contracts import KernelRequest
 from flare_kernel.router.payload_enrichment import extract_source_ids_from_payload
+from flare_kernel.router.turn_context_sourcing_preview import (
+    maybe_append_sourcing_preview_rows,
+)
 
 
 async def prepare_kernel_turn_context_flow(
@@ -36,6 +39,7 @@ async def prepare_kernel_turn_context_flow(
     merge_intent_and_escalation_signal_fn: Callable[..., dict[str, Any]],
     resolve_effective_command_fn: Callable[..., str],
     build_structured_search_results_fn: Callable[..., list[dict[str, Any]]],
+    search_web_sources_fn: Callable[..., list[dict[str, Any]]] | None = None,
     resolve_analysis_route_fn: Callable[..., dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     """Assemble the turn context consumed by kernel run/action/stream handlers."""
@@ -100,6 +104,17 @@ async def prepare_kernel_turn_context_flow(
             min_score=retrieval_config["min_score"],
             source_ids=source_ids or None,
         )
+    retrieved_knowledge = maybe_append_sourcing_preview_rows(
+        retrieved_knowledge=retrieved_knowledge,
+        resolved_mode=resolved_mode,
+        raw_message=raw_message,
+        retrieval_top_k=int(retrieval_config.get("top_k") or 0),
+        trace_id=trace_id,
+        session_id=session_id,
+        project_id=str(project_id or ""),
+        user_id=str(user_id or ""),
+        search_web_sources_fn=search_web_sources_fn,
+    )
 
     if callable(resolve_analysis_route_fn):
         analysis_route = resolve_analysis_route_fn(
@@ -113,12 +128,14 @@ async def prepare_kernel_turn_context_flow(
     else:
         analysis_route = {
             "analysis_type": "requirement",
-            "template_id": "analysis_requirement_default",
+            "template_id": "flare.requirement.rfx.v1",
             "reason_codes": ["ROUTE_SIGNAL_DEFAULT"],
             "confidence": 0.0,
         }
 
     enriched_payload = enrich_payload_fn(req, resolved_mode=resolved_mode, retrieved_knowledge=retrieved_knowledge)
+    if isinstance(enriched_payload, dict):
+        enriched_payload["analysis_route"] = analysis_route
     runtime_snapshot = build_kernel_runtime_fn(
         trace_id=trace_id,
         tenant_id=req.tenant_id,

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/kernel_facade_turn_context_wrapper.py

@@ -23,6 +23,9 @@ from flare_kernel.router.intent.intent_retrieval import (
     build_retrieval_queries as _build_retrieval_queries_from_router,
     search_knowledge_by_queries as _search_knowledge_by_queries,
 )
+from flare_kernel.runtime.infrastructure.sourcing_provider import (
+    search_web_sources as _search_web_sources,
+)
 from flare_kernel.router.intent.intent_routing import (
     resolve_request_intent_with_ai as _resolve_request_intent_with_ai_from_router,
 )
@@ -86,6 +89,7 @@ async def _prepare_kernel_turn_context(
     merge_intent_and_escalation_signal_fn=None,
     resolve_effective_command_fn=None,
     build_structured_search_results_fn=None,
+    search_web_sources_fn=None,
     resolve_analysis_route_fn=None,
 ) -> dict[str, object]:
     """Assemble the kernel turn context for route execution."""
@@ -161,6 +165,7 @@ async def _prepare_kernel_turn_context(
         merge_intent_and_escalation_signal_fn=turn_context_deps["merge_intent_and_escalation_signal_fn"],
         resolve_effective_command_fn=turn_context_deps["resolve_effective_command_fn"],
         build_structured_search_results_fn=turn_context_deps["build_structured_search_results_fn"],
+        search_web_sources_fn=search_web_sources_fn or _search_web_sources,
         resolve_analysis_route_fn=turn_context_deps["resolve_analysis_route_fn"],
     )
 

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/kernel_request_flow.py

@@ -169,6 +169,21 @@ def _resolve_generate_llm_completion_fn():
 def _resolve_command(req: KernelRequest) -> str:
     """Resolve the request command, falling back to the default flow command."""
     command = str(req.command or "").strip()
+    payload = req.payload if isinstance(req.payload, dict) else {}
+    mode_candidates = (
+        req.mode,
+        req.manual_mode,
+        req.current_mode,
+        payload.get("mode"),
+        payload.get("manual_mode"),
+        payload.get("current_mode"),
+        payload.get("function_type"),
+    )
+    is_analysis_mode = any(str(candidate or "").strip() == "analysis_mode" for candidate in mode_candidates)
+    if command and command != "send_message":
+        return command
+    if is_analysis_mode:
+        return "generate_analysis"
     if command:
         return command
     if req.action_key:

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/kernel_request_flow_action.py

@@ -34,6 +34,21 @@ from flare_kernel.router.mode_switch import (
 
 def _resolve_command(req: KernelRequest) -> str:
     command = str(req.command or "").strip()
+    payload = req.payload if isinstance(req.payload, dict) else {}
+    mode_candidates = (
+        req.mode,
+        req.manual_mode,
+        req.current_mode,
+        payload.get("mode"),
+        payload.get("manual_mode"),
+        payload.get("current_mode"),
+        payload.get("function_type"),
+    )
+    is_analysis_mode = any(str(candidate or "").strip() == "analysis_mode" for candidate in mode_candidates)
+    if command and command != "send_message":
+        return command
+    if is_analysis_mode:
+        return "generate_analysis"
     if command:
         return command
     if req.action_key:

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/mode_resolution.py

@@ -28,9 +28,10 @@ _MODE_ALIASES: dict[str, str] = {
     "domain_workflow": "intelligent_sourcing",
     "domain_exploration": "intelligent_sourcing",
     "domain_analysis": "requirement_canvas",
+    "analysis_mode": "requirement_canvas",
     "domain_plan": "plan_mode",
     "sourcing": "intelligent_sourcing",
-    "plan": "requirement_canvas",
+    "plan": "plan_mode",
 }
 
 

{flare_kernel-0.2.3 → flare_kernel-0.2.4}/src/flare_kernel/router/payload_enrichment.py

@@ -229,6 +229,10 @@ def enrich_payload(
         payload["current_mode"] = current_mode
     if retrieved_knowledge:
         payload["retrieved_knowledge"] = retrieved_knowledge
+        if resolved_mode == "intelligent_sourcing":
+            existing_candidates = payload.get("sourcing_candidates")
+            if not isinstance(existing_candidates, list) or not existing_candidates:
+                payload["sourcing_candidates"] = list(retrieved_knowledge)
     source_ids = extract_source_ids_from_payload(payload)
     if source_ids:
         payload["source_ids"] = source_ids