flare-kernel 1.0.4__tar.gz → 1.0.6__tar.gz

flare_kernel-1.0.6/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: flare-kernel
+Version: 1.0.6
+Summary: FLARE kernel runtime package
+License: Proprietary
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: flare-engines<2.0.0,>=1.0.0
+Requires-Dist: fastapi<1.0,>=0.115
+Requires-Dist: python-multipart<1.0,>=0.0.9
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: pypdf<6,>=4
+Requires-Dist: uvicorn<1.0,>=0.30
+Requires-Dist: httpx<1.0,>=0.27
+Requires-Dist: rapidfuzz<4.0,>=3.14
+Requires-Dist: sqlalchemy<3,>=2
+Requires-Dist: psycopg2-binary<3,>=2.9
+Requires-Dist: redis<6,>=5
+Requires-Dist: qdrant-client<1.15,>=1.13
+
+# flare-kernel
+
+通用编排与执行内核。
+
+边界文档：
+
+1. `packages/flare-kernel/docs/KERNEL-BOUNDARY.md`
+2. `docs/contracts/core/agent.md`
+3. `packages/flare-kernel/docs/replay-snapshot-technical-spec.md`
+
+职责：
+
+1. Decision 路由与策略入口。
+2. Execution 流程推进与状态管理。
+3. Runtime（含重试、超时、追踪）。
+4. 加载 domain pack 并执行。
+
+## Day 2 最小骨架
+
+目录：
+
+1. `src/flare_kernel/router`：接口路由
+2. `src/flare_kernel/runtime`：`trace_id` 与基础日志
+3. `src/flare_kernel/contracts`：请求/响应契约
+
+最小接口：
+
+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 运行时占位事件与字段。
+
+## 品牌注入（可选）
+
+1. kernel 支持从 domain-pack 读取品牌配置：
+   `branding/instance-branding.json`
+2. 读取方式：
+   - 优先通过环境变量 `FLARE_DOMAIN_PACK_ROOT` 显式指定
+   - 本地仓库运行时可回退到仓库根目录下的 `domain-packs/`
+3. 注入位置：
+   - `POST /kernel/run` 响应 `result.instance_profile`
+   - `POST /kernel/stream` SSE 事件 `instance_profile`
+
+说明：品牌注入通过外部 domain-pack 配置，core 不写死产品名、logo、标签。
+
+本地启动（示例）：
+
+```bash
+uvicorn flare_kernel.main:app --app-dir packages/flare-kernel/src --host 0.0.0.0 --port 8002
+```
+
+环境变量（真实链路）：
+
+1. `APIPRO_API_KEY`（必填，真实 APIPro 调用）
+2. `LLM_PROVIDER_BACKEND`（当前本地模板为 `apipro`）
+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`
+2. 发布元数据：`packages/flare-kernel/pyproject.toml`
+3. 本地构建：`python -m build`
+4. 本地安装：`pip install packages/flare-kernel`

flare_kernel-1.0.6/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flare-kernel"
+version = "1.0.6"
+description = "FLARE kernel runtime package"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "flare-engines>=1.0.0,<2.0.0",
+    "fastapi>=0.115,<1.0",
+    "python-multipart>=0.0.9,<1.0",
+    "pydantic>=2,<3",
+    "pypdf>=4,<6",
+    "uvicorn>=0.30,<1.0",
+    "httpx>=0.27,<1.0",
+    "rapidfuzz>=3.14,<4.0",
+    "sqlalchemy>=2,<3",
+    "psycopg2-binary>=2.9,<3",
+    "redis>=5,<6",
+    "qdrant-client>=1.13,<1.15",
+]
+license = { text = "Proprietary" }
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

flare_kernel-1.0.6/src/flare_kernel/router/canonical/workflow_projection.py

@@ -0,0 +1,272 @@
+"""Canonical workflow projection assembly."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from flare_kernel.router.canonical.workflow_projection_policy import build_workflow_projection_policy
+
+
+def _mapping(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _sequence(value: Any) -> list[Any]:
+    return value if isinstance(value, list) else []
+
+
+def _text(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _first_mapping(*values: Any) -> dict[str, Any]:
+    for value in values:
+        item = _mapping(value)
+        if item:
+            return item
+    return {}
+
+
+def _patch_apply_status(canonical: dict[str, Any], orchestration_status: dict[str, Any]) -> dict[str, Any]:
+    return _first_mapping(orchestration_status.get("patch_apply_status"), canonical.get("patch_apply_status"))
+
+
+def _reconciliation_result(canonical: dict[str, Any], orchestration_status: dict[str, Any]) -> dict[str, Any]:
+    return _first_mapping(orchestration_status.get("reconciliation_result"), canonical.get("reconciliation_result"))
+
+
+def _tabs_from_patch_status(patch_status: dict[str, Any]) -> list[str]:
+    for key in ("applied_tabs", "target_tabs", "failed_tabs"):
+        tabs = [_text(item) for item in _sequence(patch_status.get(key)) if _text(item)]
+        if tabs:
+            return tabs
+    return []
+
+
+def _snapshot_artifact(
+    *,
+    snapshots: list[Any],
+    target_tabs: list[str],
+) -> dict[str, Any]:
+    rows = [_mapping(item) for item in snapshots if _mapping(item)]
+    if target_tabs:
+        for row in reversed(rows):
+            if _text(row.get("active_tab")) in target_tabs:
+                return _artifact_projection(row)
+    return _artifact_projection(rows[-1]) if rows else {}
+
+
+def _artifact_projection(row: dict[str, Any]) -> dict[str, Any]:
+    latest_revision = _mapping(row.get("latest_revision"))
+    revision_id = _text(row.get("revision_id") or latest_revision.get("revision_id"))
+    return {
+        "artifact_id": _text(row.get("artifact_id")),
+        "artifact_type": _text(row.get("artifact_type") or row.get("document_kind")),
+        "revision_id": revision_id,
+        "status": _text(row.get("status")) or "accepted",
+    }
+
+
+def _analysis_payload_artifact(canonical: dict[str, Any]) -> dict[str, Any]:
+    analysis_payload = _first_mapping(canonical.get("canvas_analysis_payload"), canonical.get("analysis_payload"))
+    if not analysis_payload:
+        return {}
+    document = _mapping(analysis_payload.get("document"))
+    return {
+        "artifact_id": _text(document.get("artifact_id")) or "analysis_payload",
+        "artifact_type": _text(document.get("artifact_type")) or "analysis_report",
+        "revision_id": _text(document.get("revision_id") or _mapping(document.get("latest_revision")).get("revision_id")),
+        "status": _text(analysis_payload.get("status")) or "accepted",
+    }
+
+
+def _runtime_active_artifact(runtime_snapshot: dict[str, Any]) -> dict[str, Any]:
+    runtime_payload = _mapping(runtime_snapshot.get("payload"))
+    active_context = runtime_payload.get("active_artifact_context")
+    if isinstance(active_context, list):
+        active_context = next((item for item in active_context if isinstance(item, dict)), {})
+    return _artifact_projection(_mapping(active_context))
+
+
+def _post_generation_artifact(canonical: dict[str, Any], orchestration_status: dict[str, Any]) -> dict[str, Any]:
+    result = _first_mapping(orchestration_status.get("post_generation_result"), canonical.get("post_generation_result"))
+    if _text(result.get("status")) != "completed":
+        return {}
+    descriptor = _mapping(result.get("artifact_descriptor"))
+    artifact_id = _text(descriptor.get("artifact_id"))
+    artifact_type = _text(descriptor.get("artifact_type"))
+    if not artifact_id or not artifact_type:
+        return {}
+    return {
+        "artifact_id": artifact_id,
+        "artifact_type": artifact_type,
+        "revision_id": _text(descriptor.get("revision_id")),
+        "status": _text(descriptor.get("status")) or "accepted",
+        "active_tab": _text(descriptor.get("target_tab")) or "artifact",
+    }
+
+
+def _mode_target_tab(canonical: dict[str, Any], runtime_snapshot: dict[str, Any]) -> str:
+    runtime_payload = _mapping(runtime_snapshot.get("payload"))
+    mode = _text(
+        canonical.get("mode_key")
+        or runtime_snapshot.get("mode_key")
+        or runtime_payload.get("mode_key")
+    ).lower()
+    if "analysis" in mode:
+        return "analysis"
+    return ""
+
+
+def _runtime_run_id(runtime_snapshot: dict[str, Any]) -> str:
+    run = _mapping(runtime_snapshot.get("run"))
+    runtime_payload = _mapping(runtime_snapshot.get("payload"))
+    return _text(run.get("run_id") or runtime_payload.get("run_id"))
+
+
+def _runtime_run_events(runtime_snapshot: dict[str, Any]) -> list[dict[str, Any]]:
+    events = []
+    for item in _sequence(runtime_snapshot.get("run_events")):
+        event = _mapping(item)
+        if event:
+            events.append(dict(event))
+    return events
+
+
+def _active_artifact(
+    *,
+    canonical: dict[str, Any],
+    orchestration_status: dict[str, Any],
+    runtime_snapshot: dict[str, Any],
+    target_tabs: list[str],
+    mode_target_tab: str,
+) -> dict[str, Any]:
+    reconciliation = _reconciliation_result(canonical, orchestration_status)
+    snapshot_artifact = _snapshot_artifact(
+        snapshots=_sequence(reconciliation.get("artifact_snapshots")),
+        target_tabs=target_tabs,
+    )
+    analysis_artifact = _analysis_payload_artifact(canonical)
+    post_generation_artifact = _post_generation_artifact(canonical, orchestration_status)
+    runtime_artifact = _runtime_active_artifact(runtime_snapshot)
+    if not target_tabs and mode_target_tab and _artifact_active_tab(
+        active_artifact=runtime_artifact,
+        canonical=canonical,
+        runtime_snapshot=runtime_snapshot,
+    ) != mode_target_tab:
+        runtime_artifact = {}
+    return snapshot_artifact or analysis_artifact or post_generation_artifact or runtime_artifact
+
+
+def _artifact_active_tab(
+    *,
+    active_artifact: dict[str, Any],
+    canonical: dict[str, Any],
+    runtime_snapshot: dict[str, Any],
+) -> str:
+    artifact_id = _text(active_artifact.get("artifact_id"))
+    runtime_payload = _mapping(runtime_snapshot.get("payload"))
+    rows = _sequence(runtime_payload.get("active_artifact_context")) or [_mapping(runtime_payload.get("active_artifact_context"))]
+    for row in rows:
+        item = _mapping(row)
+        if artifact_id and _text(item.get("artifact_id")) == artifact_id:
+            return _text(item.get("active_tab"))
+    if _text(active_artifact.get("active_tab")):
+        return _text(active_artifact.get("active_tab"))
+    if _analysis_payload_artifact(canonical).get("artifact_id") == artifact_id:
+        return "analysis"
+    return ""
+
+
+def _active_tab(
+    *,
+    canonical: dict[str, Any],
+    orchestration_status: dict[str, Any],
+    runtime_snapshot: dict[str, Any],
+    active_artifact: dict[str, Any],
+    target_tabs: list[str],
+    mode_target_tab: str,
+) -> str:
+    if len(target_tabs) == 1:
+        return target_tabs[0]
+    artifact_tab = _artifact_active_tab(
+        active_artifact=active_artifact,
+        canonical=canonical,
+        runtime_snapshot=runtime_snapshot,
+    )
+    if artifact_tab:
+        return artifact_tab
+    if _first_mapping(canonical.get("canvas_analysis_payload"), canonical.get("analysis_payload")):
+        return "analysis"
+    if mode_target_tab:
+        return mode_target_tab
+    canvas_state = _mapping(orchestration_status.get("patch_applied_canvas_state"))
+    return _text(_mapping(canvas_state.get("ui_signal")).get("active_tab"))
+
+
+
+def _phase(canonical: dict[str, Any]) -> str:
+    primary_flow = _mapping(canonical.get("primary_flow"))
+    return _text(canonical.get("mode_state") or primary_flow.get("status") or primary_flow.get("stage"))
+
+def _turn_disposition(orchestration_status: dict[str, Any], runtime_snapshot: dict[str, Any]) -> dict[str, Any]:
+    runtime_payload = _mapping(runtime_snapshot.get("payload"))
+    return _first_mapping(
+        orchestration_status.get("turn_disposition"),
+        runtime_payload.get("turn_disposition"),
+    )
+
+
+def build_workflow_projection(
+    *,
+    canonical: dict[str, Any],
+    orchestration_status: dict[str, Any],
+    runtime_snapshot: dict[str, Any] | None,
+) -> dict[str, Any]:
+    source = _mapping(canonical)
+    status = _patch_apply_status(source, orchestration_status)
+    target_tabs = _tabs_from_patch_status(status)
+    runtime = _mapping(runtime_snapshot)
+    mode_target_tab = _mode_target_tab(source, runtime)
+    artifact = _active_artifact(
+        canonical=source,
+        orchestration_status=orchestration_status,
+        runtime_snapshot=runtime,
+        target_tabs=target_tabs,
+        mode_target_tab=mode_target_tab,
+    )
+    tab = _active_tab(
+        canonical=source,
+        orchestration_status=orchestration_status,
+        runtime_snapshot=runtime,
+        active_artifact=artifact,
+        target_tabs=target_tabs,
+        mode_target_tab=mode_target_tab,
+    )
+    policy = build_workflow_projection_policy(
+        canonical=source,
+        orchestration_status=orchestration_status,
+        patch_status=status,
+    )
+    turn_disposition = _turn_disposition(orchestration_status, runtime)
+    return {
+        "mode": _text(source.get("mode_key")),
+        "phase": _phase(source),
+        "run_id": _runtime_run_id(runtime),
+        "run_events": _runtime_run_events(runtime),
+        "readiness": policy["readiness"],
+        "turn_disposition": _text(turn_disposition.get("turn_disposition")),
+        "artifact_write_allowed": turn_disposition.get("artifact_write_allowed") is True,
+        "output_route": _text(turn_disposition.get("output_route")),
+        "artifact_body_write_allowed": turn_disposition.get("artifact_body_write_allowed") is True,
+        "chat_reply_policy": _text(turn_disposition.get("chat_reply_policy")),
+        "active_canvas": tab,
+        "active_tab": tab,
+        "active_artifact": artifact,
+        "allowed_actions": policy["allowed_actions"],
+        "next_action": policy["next_action"],
+        "reason": policy["reason"],
+    }
+
+
+__all__ = ["build_workflow_projection"]

flare_kernel-1.0.6/src/flare_kernel/router/completion/artifact_regeneration_bridge.py

@@ -0,0 +1,174 @@
+"""Bridge regenerate action completions into artifact edit revisions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from flare_kernel.runtime.artifact_edit import apply_artifact_edit_request
+
+REGENERATE_ARTIFACT_ACTION_KEY = "regenerate_artifact"
+
+
+def _mapping(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _text(value: Any) -> str:
+    return " ".join(str(value or "").split()).strip()
+
+
+def _content(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _node_result(completion_details: dict[str, Any] | None) -> dict[str, Any]:
+    return _mapping(_mapping(completion_details).get("node_result"))
+
+
+def _node_result_content(*, node_result: dict[str, Any], fallback: str) -> str:
+    return _content(node_result.get("content")) or _content(fallback)
+
+
+def _node_failure_reason(node_result: dict[str, Any]) -> str:
+    quality = _mapping(node_result.get("quality"))
+    failure_state = _mapping(quality.get("failure_state"))
+    metadata = _mapping(node_result.get("metadata"))
+    return _text(failure_state.get("reason") or metadata.get("reason"))
+
+
+def _generation_status(*, completion_status: str, content_text: str, node_result: dict[str, Any]) -> str:
+    node_status = _text(node_result.get("status")).lower()
+    if node_status:
+        if node_status in {"succeeded", "partial"} and _content(content_text):
+            return "completed"
+        return "failed"
+    if _text(completion_status).lower() == "ok" and _content(content_text):
+        return "completed"
+    return "failed"
+
+
+def _generation_result(
+    *,
+    completion_provider: str,
+    completion_model: str,
+    completion_status: str,
+    completion_details: dict[str, Any] | None,
+    content_text: str,
+) -> dict[str, Any]:
+    details = _mapping(completion_details)
+    node_result = _node_result(details)
+    return {
+        "schema_version": "artifact.regeneration_result.v1",
+        "provider": _text(completion_provider),
+        "model": _text(completion_model),
+        "status": _generation_status(
+            completion_status=completion_status,
+            content_text=content_text,
+            node_result=node_result,
+        ),
+        "trace_id": _text(details.get("trace_id")),
+        "reason": _text(_node_failure_reason(node_result) or details.get("reason") or details.get("error")),
+    }
+
+
+def _artifact_edit_request(
+    *,
+    action_payload: dict[str, Any],
+    content_text: str,
+    generation: dict[str, Any],
+) -> dict[str, Any]:
+    canvas_state = _mapping(action_payload.get("canvas_state")) or _mapping(action_payload.get("intake_canvas_state"))
+    artifact_document = _mapping(action_payload.get("artifact_document")) or _mapping(canvas_state.get("artifact_document"))
+    active_tab = _text(action_payload.get("active_tab") or action_payload.get("target_tab")) or "requirement"
+    return {
+        "schema_version": "artifact.edit_request.v1",
+        "active_tab": active_tab,
+        "artifact_id": _text(action_payload.get("artifact_id") or artifact_document.get("artifact_id")),
+        "artifact_document": artifact_document,
+        "canvas_state": canvas_state,
+        "content": _content(content_text),
+        "timestamp": _text(action_payload.get("timestamp")),
+        "change_operation": REGENERATE_ARTIFACT_ACTION_KEY,
+        "change_summary": _text(action_payload.get("change_summary")) or "重新生成 Artifact",
+        "source_kind": "artifact_regenerate",
+        "generation": generation,
+        "source_action": {
+            "action_key": REGENERATE_ARTIFACT_ACTION_KEY,
+            "payload": {
+                "active_tab": active_tab,
+                "target_tab": active_tab,
+                "content": _content(content_text),
+                "artifact_document": artifact_document,
+                "generation": generation,
+            },
+        },
+    }
+
+
+def _merge_context_patch(existing: Any, incoming: Any) -> dict[str, Any] | None:
+    base = dict(_mapping(existing))
+    patch = _mapping(incoming)
+    if not base and not patch:
+        return None
+    return {**base, **patch}
+
+
+def _result_projection(edit_result: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "schema_version": edit_result.get("schema_version"),
+        "status": edit_result.get("status"),
+        "reason": edit_result.get("reason"),
+        "target": edit_result.get("target"),
+        "artifact_id": edit_result.get("artifact_id"),
+        "revision_id": edit_result.get("revision_id"),
+        "active_tab": edit_result.get("active_tab"),
+        "events": edit_result.get("events") if isinstance(edit_result.get("events"), list) else [],
+    }
+
+
+def attach_artifact_regeneration_result(
+    *,
+    result: dict[str, Any],
+    action_key: str | None,
+    action_payload: dict[str, Any],
+    content_text: str,
+    completion_provider: str,
+    completion_model: str,
+    completion_status: str,
+    completion_details: dict[str, Any] | None,
+) -> dict[str, Any]:
+    """Attach backend-owned artifact regenerate result to an action response."""
+
+    if _text(action_key) != REGENERATE_ARTIFACT_ACTION_KEY:
+        return result
+    node_result = _node_result(completion_details)
+    artifact_content = _node_result_content(node_result=node_result, fallback=content_text)
+    generation = _generation_result(
+        completion_provider=completion_provider,
+        completion_model=completion_model,
+        completion_status=completion_status,
+        completion_details=completion_details,
+        content_text=artifact_content,
+    )
+    edit_result = apply_artifact_edit_request(
+        _artifact_edit_request(
+            action_payload=_mapping(action_payload),
+            content_text=artifact_content,
+            generation=generation,
+        )
+    )
+    updated = {
+        **result,
+        "artifact_edit_result": _result_projection(edit_result),
+    }
+    if edit_result.get("status") != "completed":
+        return updated
+    return {
+        **updated,
+        "canvas_state": _mapping(edit_result.get("canvas_state")) or result.get("canvas_state"),
+        "analysis_payload": _mapping(edit_result.get("analysis_payload")) or result.get("analysis_payload"),
+        "context_patch": _merge_context_patch(result.get("context_patch"), edit_result.get("context_patch")),
+    }
+
+
+__all__ = ["REGENERATE_ARTIFACT_ACTION_KEY", "attach_artifact_regeneration_result"]