flare-kernel 0.1.0__tar.gz

flare_kernel-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: flare-kernel
+Version: 0.1.0
+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<0.2.0,>=0.1.0
+Requires-Dist: fastapi<1.0,>=0.115
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: uvicorn<1.0,>=0.30
+
+# flare-kernel
+
+通用编排与执行内核。
+
+职责：
+
+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`
+
+kernel 现已输出 mode/context 运行时占位事件与字段。
+
+## Instance 注入（品牌信息）
+
+1. kernel 支持从 instance 的 domain-pack 读取品牌配置：
+   `branding/instance-branding.json`
+2. 读取优先级：
+   - 环境变量 `FLARE_DOMAIN_PACK_ROOT`
+   - 自动探测 `apps/<instance_id>/domain-pack`
+3. 注入位置：
+   - `POST /kernel/run` 响应 `result.instance_profile`
+   - `POST /kernel/stream` SSE 事件 `instance_profile`
+
+说明：品牌注入仅在 instance 层配置，core 不写死产品名、logo、标签。
+
+本地启动（示例）：
+
+```bash
+uvicorn flare_kernel.main:app --app-dir packages/flare-kernel/src --host 0.0.0.0 --port 8002
+```
+
+## 最小发布说明
+
+1. 当前包版本：`0.1.0`
+2. 发布元数据：`packages/flare-kernel/pyproject.toml`
+3. 本地构建：`python -m build`
+4. 本地安装：`pip install packages/flare-kernel`

flare_kernel-0.1.0/README.md

@@ -0,0 +1,52 @@
+# flare-kernel
+
+通用编排与执行内核。
+
+职责：
+
+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`
+
+kernel 现已输出 mode/context 运行时占位事件与字段。
+
+## Instance 注入（品牌信息）
+
+1. kernel 支持从 instance 的 domain-pack 读取品牌配置：
+   `branding/instance-branding.json`
+2. 读取优先级：
+   - 环境变量 `FLARE_DOMAIN_PACK_ROOT`
+   - 自动探测 `apps/<instance_id>/domain-pack`
+3. 注入位置：
+   - `POST /kernel/run` 响应 `result.instance_profile`
+   - `POST /kernel/stream` SSE 事件 `instance_profile`
+
+说明：品牌注入仅在 instance 层配置，core 不写死产品名、logo、标签。
+
+本地启动（示例）：
+
+```bash
+uvicorn flare_kernel.main:app --app-dir packages/flare-kernel/src --host 0.0.0.0 --port 8002
+```
+
+## 最小发布说明
+
+1. 当前包版本：`0.1.0`
+2. 发布元数据：`packages/flare-kernel/pyproject.toml`
+3. 本地构建：`python -m build`
+4. 本地安装：`pip install packages/flare-kernel`

flare_kernel-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flare-kernel"
+version = "0.1.0"
+description = "FLARE kernel runtime package"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "flare-engines>=0.1.0,<0.2.0",
+    "fastapi>=0.115,<1.0",
+    "pydantic>=2,<3",
+    "uvicorn>=0.30,<1.0",
+]
+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-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flare_kernel-0.1.0/src/flare_kernel/__init__.py

@@ -0,0 +1,9 @@
+"""flare-kernel package."""
+
+__all__ = ["create_app"]
+
+
+def create_app():
+    from flare_kernel.app import create_app as _create_app
+
+    return _create_app()

flare_kernel-0.1.0/src/flare_kernel/app.py

@@ -0,0 +1,27 @@
+"""FastAPI app factory for flare-kernel."""
+
+from __future__ import annotations
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from flare_kernel.router import kernel_router
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title="FLARE Kernel",
+        version="0.1.0",
+        description="FLARE kernel minimal runtime",
+    )
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.include_router(kernel_router)
+    return app

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

@@ -0,0 +1,5 @@
+"""Kernel contracts."""
+
+from flare_kernel.contracts.kernel_contract import HealthResponse, KernelRequest, KernelResponse
+
+__all__ = ["KernelRequest", "KernelResponse", "HealthResponse"]

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

@@ -0,0 +1,36 @@
+"""Kernel API contracts."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class KernelRequest(BaseModel):
+    tenant_id: str = "default"
+    instance_id: str = "xiaocai-instance"
+    domain_pack_version: str = "v1"
+    session_id: str = "default"
+    intent: str = "default"
+    payload: dict[str, Any] = Field(default_factory=dict)
+    context_refs: list[Any] = Field(default_factory=list)
+    action_key: str | None = None
+    target_mode: str | None = None
+    action_status: str | None = None
+    action_reason: str | None = None
+    trace_id: str | None = None
+
+
+class KernelResponse(BaseModel):
+    trace_id: str
+    state: Literal["RUNNING", "SUCCEEDED", "FAILED"]
+    events: list[dict[str, Any]] = Field(default_factory=list)
+    result: dict[str, Any] = Field(default_factory=dict)
+    next_actions: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class HealthResponse(BaseModel):
+    status: Literal["healthy"]
+    service: str
+    trace_id: str

flare_kernel-0.1.0/src/flare_kernel/main.py

@@ -0,0 +1,5 @@
+"""ASGI entrypoint."""
+
+from flare_kernel.app import create_app
+
+app = create_app()

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

@@ -0,0 +1,5 @@
+"""Kernel routers."""
+
+from flare_kernel.router.kernel import router as kernel_router
+
+__all__ = ["kernel_router"]

flare_kernel-0.1.0/src/flare_kernel/router/kernel.py

@@ -0,0 +1,342 @@
+"""Kernel API router."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from fastapi import APIRouter
+from fastapi.responses import StreamingResponse
+
+from flare_kernel.contracts import HealthResponse, KernelRequest, KernelResponse
+from flare_kernel.runtime import build_kernel_runtime, generate_llm_completion, get_logger, load_instance_profile, resolve_trace_id
+
+router = APIRouter(prefix="/kernel", tags=["kernel"])
+logger = get_logger("flare_kernel.router.kernel")
+
+
+def _build_prompt(
+    req: KernelRequest,
+    instance_profile: dict[str, object] | None,
+    *,
+    intent: str | None = None,
+) -> str:
+    message = ""
+    if isinstance(req.payload, dict):
+        raw_message = req.payload.get("message")
+        if isinstance(raw_message, str):
+            message = raw_message.strip()
+
+    product_name = ""
+    if instance_profile and isinstance(instance_profile.get("product_name"), str):
+        product_name = instance_profile.get("product_name", "").strip()
+
+    prompt_parts = [
+        f"intent: {intent or req.intent}",
+        f"session_id: {req.session_id}",
+    ]
+    if product_name:
+        prompt_parts.append(f"product_name: {product_name}")
+    if message:
+        prompt_parts.append(f"user_message: {message}")
+    return "\n".join(prompt_parts)
+
+
+def _normalize_key(value: Any) -> str:
+    if value is None:
+        return ""
+    return str(value).strip().lower().replace("-", "_").replace(" ", "_")
+
+
+def _extract_value(raw_value: Any) -> Any:
+    if isinstance(raw_value, dict):
+        for candidate in ("value", "content", "text"):
+            candidate_value = raw_value.get(candidate)
+            if candidate_value not in (None, "", [], {}):
+                return candidate_value
+    return raw_value
+
+
+def _collect_sourcing_base_fields(payload: dict[str, Any]) -> dict[str, Any]:
+    raw_base_fields = payload.get("base_fields")
+    if isinstance(raw_base_fields, dict):
+        return dict(raw_base_fields)
+
+    base_fields: dict[str, Any] = {}
+    raw_fields = payload.get("fields")
+
+    if isinstance(raw_fields, dict):
+        for key in ("category", "region"):
+            if key not in raw_fields:
+                continue
+            value = _extract_value(raw_fields.get(key))
+            if value not in (None, "", [], {}):
+                base_fields[key] = value
+    elif isinstance(raw_fields, list):
+        for raw_item in raw_fields:
+            if not isinstance(raw_item, dict):
+                continue
+            field_key = ""
+            for candidate in ("field_key", "name", "id", "key", "label"):
+                candidate_value = raw_item.get(candidate)
+                if isinstance(candidate_value, str) and candidate_value.strip():
+                    field_key = candidate_value.strip()
+                    break
+            normalized_key = _normalize_key(field_key)
+            if normalized_key not in {"category", "region"}:
+                continue
+            value = _extract_value(raw_item.get("value", raw_item.get("content", raw_item.get("text"))))
+            if value not in (None, "", [], {}):
+                base_fields[normalized_key] = value
+
+    for key in ("category", "region"):
+        if key in base_fields:
+            continue
+        value = payload.get(key)
+        if value not in (None, "", [], {}):
+            base_fields[key] = value
+
+    return base_fields
+
+
+def _resolve_action_target_mode(req: KernelRequest) -> str:
+    target_mode = req.target_mode
+    if isinstance(target_mode, str):
+        normalized = target_mode.strip()
+        if normalized in {"requirement_canvas", "intelligent_sourcing"}:
+            return normalized
+
+    action_key = req.action_key if isinstance(req.action_key, str) else ""
+    if action_key == "handoff_to_sourcing":
+        return "intelligent_sourcing"
+    if action_key == "continue_collection":
+        return "requirement_canvas"
+
+    return req.intent if isinstance(req.intent, str) and req.intent.strip() else "default"
+
+
+def _build_action_payload(req: KernelRequest, target_mode: str) -> dict[str, Any]:
+    payload = dict(req.payload) if isinstance(req.payload, dict) else {}
+    payload["function_type"] = target_mode
+    payload["target_mode"] = target_mode
+    if isinstance(req.action_key, str) and req.action_key.strip():
+        payload["action_key"] = req.action_key.strip()
+    if isinstance(req.action_status, str) and req.action_status.strip():
+        payload["action_status"] = req.action_status.strip()
+    if isinstance(req.action_reason, str) and req.action_reason.strip():
+        payload["action_reason"] = req.action_reason.strip()
+
+    if target_mode == "intelligent_sourcing":
+        base_fields = _collect_sourcing_base_fields(payload)
+        if base_fields:
+            payload["base_fields"] = base_fields
+
+    return payload
+
+
+@router.get("/health", response_model=HealthResponse)
+async def kernel_health() -> HealthResponse:
+    trace_id = resolve_trace_id(None)
+    logger.info("kernel.health trace_id=%s", trace_id)
+    return HealthResponse(status="healthy", service="flare-kernel", trace_id=trace_id)
+
+
+@router.post("/run", response_model=KernelResponse)
+async def kernel_run(req: KernelRequest) -> KernelResponse:
+    trace_id = resolve_trace_id(req.trace_id)
+    instance_profile = load_instance_profile(req.instance_id)
+    runtime_snapshot = build_kernel_runtime(
+        trace_id=trace_id,
+        tenant_id=req.tenant_id,
+        instance_id=req.instance_id,
+        domain_pack_version=req.domain_pack_version,
+        session_id=req.session_id,
+        intent=req.intent,
+        payload=req.payload,
+        instance_profile=instance_profile,
+    )
+    logger.info(
+        "kernel.run trace_id=%s session_id=%s intent=%s instance_id=%s has_instance_profile=%s",
+        trace_id,
+        req.session_id,
+        req.intent,
+        req.instance_id,
+        bool(instance_profile),
+    )
+    completion = await generate_llm_completion(
+        _build_prompt(req, instance_profile),
+        trace_id=trace_id,
+        session_id=req.session_id,
+        intent=req.intent,
+    )
+    result = {
+        "message": completion.content,
+        "provider": completion.provider,
+        "model": completion.model,
+        "provider_status": completion.status,
+        "mode_key": runtime_snapshot["mode_key"],
+        "mode_state": runtime_snapshot["mode_state"],
+        "mode_runtime": runtime_snapshot["mode_runtime"],
+        "context_usage": runtime_snapshot["context_usage"],
+        "agent_runtime": runtime_snapshot["agent_runtime"],
+        "skill_runtime": runtime_snapshot["skill_runtime"],
+        "mode_events": runtime_snapshot["mode_events"],
+        "next_actions": runtime_snapshot["next_actions"],
+    }
+    if instance_profile:
+        result["instance_profile"] = instance_profile
+    return KernelResponse(
+        trace_id=trace_id,
+        state="SUCCEEDED",
+        events=[],
+        result=result,
+        next_actions=runtime_snapshot["next_actions"],
+    )
+
+
+@router.post("/action", response_model=KernelResponse)
+async def kernel_action(req: KernelRequest) -> KernelResponse:
+    trace_id = resolve_trace_id(req.trace_id)
+    instance_profile = load_instance_profile(req.instance_id)
+    action_target_mode = _resolve_action_target_mode(req)
+    action_payload = _build_action_payload(req, action_target_mode)
+    runtime_snapshot = build_kernel_runtime(
+        trace_id=trace_id,
+        tenant_id=req.tenant_id,
+        instance_id=req.instance_id,
+        domain_pack_version=req.domain_pack_version,
+        session_id=req.session_id,
+        intent=action_target_mode,
+        payload=action_payload,
+        instance_profile=instance_profile,
+    )
+    logger.info(
+        "kernel.action trace_id=%s session_id=%s intent=%s action_key=%s target_mode=%s instance_id=%s has_instance_profile=%s",
+        trace_id,
+        req.session_id,
+        req.intent,
+        req.action_key,
+        action_target_mode,
+        req.instance_id,
+        bool(instance_profile),
+    )
+    completion = await generate_llm_completion(
+        _build_prompt(req, instance_profile, intent=action_target_mode),
+        trace_id=trace_id,
+        session_id=req.session_id,
+        intent=action_target_mode,
+    )
+    result = {
+        "message": completion.content,
+        "provider": completion.provider,
+        "model": completion.model,
+        "provider_status": completion.status,
+        "mode_key": runtime_snapshot["mode_key"],
+        "mode_state": runtime_snapshot["mode_state"],
+        "mode_runtime": runtime_snapshot["mode_runtime"],
+        "context_usage": runtime_snapshot["context_usage"],
+        "agent_runtime": runtime_snapshot["agent_runtime"],
+        "skill_runtime": runtime_snapshot["skill_runtime"],
+        "mode_events": runtime_snapshot["mode_events"],
+        "next_actions": runtime_snapshot["next_actions"],
+        "selected_action": {
+            "action_key": req.action_key,
+            "target_mode": action_target_mode,
+            "status": req.action_status,
+            "reason": req.action_reason,
+        },
+    }
+    if instance_profile:
+        result["instance_profile"] = instance_profile
+    return KernelResponse(
+        trace_id=trace_id,
+        state="SUCCEEDED",
+        events=[],
+        result=result,
+        next_actions=runtime_snapshot["next_actions"],
+    )
+
+
+@router.post("/stream")
+async def kernel_stream(req: KernelRequest) -> StreamingResponse:
+    trace_id = resolve_trace_id(req.trace_id)
+    instance_profile = load_instance_profile(req.instance_id)
+    runtime_snapshot = build_kernel_runtime(
+        trace_id=trace_id,
+        tenant_id=req.tenant_id,
+        instance_id=req.instance_id,
+        domain_pack_version=req.domain_pack_version,
+        session_id=req.session_id,
+        intent=req.intent,
+        payload=req.payload,
+        instance_profile=instance_profile,
+    )
+    logger.info(
+        "kernel.stream trace_id=%s session_id=%s intent=%s instance_id=%s has_instance_profile=%s",
+        trace_id,
+        req.session_id,
+        req.intent,
+        req.instance_id,
+        bool(instance_profile),
+    )
+
+    async def event_stream():
+        running = {"trace_id": trace_id, "state": "RUNNING", "events": [], "result": {}, "next_actions": []}
+        yield f"event: status\ndata: {json.dumps(running, ensure_ascii=False)}\n\n"
+
+        if instance_profile:
+            profile_event = {"trace_id": trace_id, "instance_profile": instance_profile}
+            yield f"event: instance_profile\ndata: {json.dumps(profile_event, ensure_ascii=False)}\n\n"
+
+        mode_runtime_event = {"trace_id": trace_id, **runtime_snapshot["mode_runtime"]}
+        yield f"event: mode_runtime\ndata: {json.dumps(mode_runtime_event, ensure_ascii=False)}\n\n"
+
+        context_usage_event = {"trace_id": trace_id, **runtime_snapshot["context_usage"]}
+        yield f"event: context_usage\ndata: {json.dumps(context_usage_event, ensure_ascii=False)}\n\n"
+
+        agent_runtime_event = {"trace_id": trace_id, **runtime_snapshot["agent_runtime"]}
+        yield f"event: agent_runtime\ndata: {json.dumps(agent_runtime_event, ensure_ascii=False)}\n\n"
+
+        skill_runtime_event = {"trace_id": trace_id, **runtime_snapshot["skill_runtime"]}
+        yield f"event: skill_runtime\ndata: {json.dumps(skill_runtime_event, ensure_ascii=False)}\n\n"
+
+        for mode_event in runtime_snapshot["mode_events"]:
+            event_type = mode_event.get("event_type")
+            if not isinstance(event_type, str) or not event_type.strip():
+                continue
+            event_payload = mode_event.get("payload")
+            if isinstance(event_payload, dict):
+                event_data = {"trace_id": trace_id, **event_payload}
+            else:
+                event_data = {"trace_id": trace_id, "payload": event_payload}
+            yield f"event: {event_type}\ndata: {json.dumps(event_data, ensure_ascii=False)}\n\n"
+
+        product_name = ""
+        if instance_profile and isinstance(instance_profile.get("product_name"), str):
+            product_name = instance_profile.get("product_name", "").strip()
+        completion = await generate_llm_completion(
+            _build_prompt(req, instance_profile),
+            trace_id=trace_id,
+            session_id=req.session_id,
+            intent=req.intent,
+        )
+        content_text = completion.content
+        if product_name and completion.status == "placeholder" and "kernel.stream placeholder" not in content_text:
+            content_text = f"{product_name} {content_text}".strip()
+        content = {
+            "trace_id": trace_id,
+            "content": content_text,
+            "provider": completion.provider,
+            "model": completion.model,
+            "provider_status": completion.status,
+        }
+        yield f"event: content\ndata: {json.dumps(content, ensure_ascii=False)}\n\n"
+
+        complete = {"trace_id": trace_id, "status": "done"}
+        yield f"event: complete\ndata: {json.dumps(complete, ensure_ascii=False)}\n\n"
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+    )

flare_kernel-0.1.0/src/flare_kernel/runtime/__init__.py

@@ -0,0 +1,26 @@
+"""Kernel runtime helpers."""
+
+from flare_kernel.runtime.domain_pack_loader import load_instance_profile, resolve_domain_pack_root
+from flare_kernel.runtime.logging import get_logger
+from flare_kernel.runtime.llm_provider import generate_llm_completion, get_llm_provider_config
+from flare_kernel.runtime.mode_runtime import build_kernel_runtime, build_mode_runtime, build_context_usage, get_context_budget_config
+from flare_kernel.runtime.mode_orchestration import build_mode_orchestration
+from flare_kernel.runtime.agent_runtime import build_agent_runtime
+from flare_kernel.runtime.skill_runtime import build_skill_runtime
+from flare_kernel.runtime.trace import resolve_trace_id
+
+__all__ = [
+    "resolve_trace_id",
+    "get_logger",
+    "resolve_domain_pack_root",
+    "load_instance_profile",
+    "get_llm_provider_config",
+    "generate_llm_completion",
+    "get_context_budget_config",
+    "build_mode_runtime",
+    "build_context_usage",
+    "build_mode_orchestration",
+    "build_agent_runtime",
+    "build_skill_runtime",
+    "build_kernel_runtime",
+]