flare-kernel 0.1.0__py3-none-any.whl

flare_kernel/runtime/domain_pack_loader.py

@@ -0,0 +1,240 @@
+"""Helpers for loading instance-scoped domain-pack assets."""
+
+from __future__ import annotations
+
+import json
+import os
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from flare_kernel.runtime.logging import get_logger
+
+logger = get_logger("flare_kernel.runtime.domain_pack_loader")
+
+_DOMAIN_PACK_ROOT_ENV = "FLARE_DOMAIN_PACK_ROOT"
+_INSTANCE_PROFILE_FILE = "branding/instance-branding.json"
+_REQUIREMENT_SCHEMA_GLOBS = ("schema/*.yaml", "schema/*.yml")
+
+
+def _resolve_from_env() -> Path | None:
+    env_path = os.getenv(_DOMAIN_PACK_ROOT_ENV)
+    if not env_path:
+        return None
+
+    root = Path(env_path).expanduser().resolve()
+    if not root.exists():
+        logger.warning("domain_pack.root_not_found env=%s path=%s", _DOMAIN_PACK_ROOT_ENV, str(root))
+        return None
+    return root
+
+
+def _resolve_from_repo(instance_id: str) -> Path | None:
+    current_file = Path(__file__).resolve()
+    for parent in current_file.parents:
+        candidate = parent / "apps" / instance_id / "domain-pack"
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def resolve_domain_pack_root(instance_id: str) -> Path | None:
+    env_root = _resolve_from_env()
+    if env_root is not None:
+        return env_root
+    return _resolve_from_repo(instance_id)
+
+
+def _parse_scalar(raw_value: str) -> Any:
+    value = raw_value.strip()
+    if not value:
+        return ""
+
+    if value.startswith(("'", '"')) and value.endswith(("'", '"')) and len(value) >= 2:
+        return value[1:-1]
+
+    lowered = value.lower()
+    if lowered == "true":
+        return True
+    if lowered == "false":
+        return False
+
+    try:
+        return int(value)
+    except ValueError:
+        pass
+
+    try:
+        return float(value)
+    except ValueError:
+        return value
+
+
+def _load_requirement_schema_text(text: str, *, source_path: Path) -> dict[str, Any]:
+    lines = text.splitlines()
+    parsed: dict[str, Any] = {}
+    index = 0
+
+    while index < len(lines):
+        raw_line = lines[index].rstrip()
+        stripped = raw_line.strip()
+        if not stripped or stripped.startswith("#"):
+            index += 1
+            continue
+
+        indent = len(raw_line) - len(raw_line.lstrip(" "))
+        if indent != 0 or ":" not in stripped:
+            index += 1
+            continue
+
+        key, raw_value = stripped.split(":", 1)
+        key = key.strip()
+        value = raw_value.strip()
+
+        if key == "required_fields" and not value:
+            index += 1
+            required_fields: list[dict[str, Any]] = []
+            while index < len(lines):
+                item_line = lines[index].rstrip()
+                item_stripped = item_line.strip()
+                if not item_stripped or item_stripped.startswith("#"):
+                    index += 1
+                    continue
+
+                item_indent = len(item_line) - len(item_line.lstrip(" "))
+                if item_indent < 2:
+                    break
+
+                if item_indent != 2 or not item_stripped.startswith("- "):
+                    index += 1
+                    continue
+
+                field_item: dict[str, Any] = {}
+                first_field = item_stripped[2:].strip()
+                if first_field and ":" in first_field:
+                    item_key, item_value = first_field.split(":", 1)
+                    field_item[item_key.strip()] = _parse_scalar(item_value)
+
+                index += 1
+                while index < len(lines):
+                    field_line = lines[index].rstrip()
+                    field_stripped = field_line.strip()
+                    if not field_stripped or field_stripped.startswith("#"):
+                        index += 1
+                        continue
+
+                    field_indent = len(field_line) - len(field_line.lstrip(" "))
+                    if field_indent <= 2:
+                        break
+
+                    if ":" in field_stripped:
+                        item_key, item_value = field_stripped.split(":", 1)
+                        field_item[item_key.strip()] = _parse_scalar(item_value)
+                    index += 1
+
+                required_fields.append(field_item)
+
+            parsed[key] = required_fields
+            continue
+
+        if key == "ask_strategy" and not value:
+            index += 1
+            ask_strategy: dict[str, Any] = {}
+            while index < len(lines):
+                strategy_line = lines[index].rstrip()
+                strategy_stripped = strategy_line.strip()
+                if not strategy_stripped or strategy_stripped.startswith("#"):
+                    index += 1
+                    continue
+
+                strategy_indent = len(strategy_line) - len(strategy_line.lstrip(" "))
+                if strategy_indent < 2:
+                    break
+
+                if ":" in strategy_stripped and not strategy_stripped.startswith("- "):
+                    strategy_key, strategy_value = strategy_stripped.split(":", 1)
+                    ask_strategy[strategy_key.strip()] = _parse_scalar(strategy_value)
+                index += 1
+
+            parsed[key] = ask_strategy
+            continue
+
+        if value:
+            parsed[key] = _parse_scalar(value)
+            index += 1
+            continue
+
+        index += 1
+        while index < len(lines):
+            nested_line = lines[index].rstrip()
+            nested_stripped = nested_line.strip()
+            if not nested_stripped or nested_stripped.startswith("#"):
+                index += 1
+                continue
+
+            nested_indent = len(nested_line) - len(nested_line.lstrip(" "))
+            if nested_indent < 2:
+                break
+            index += 1
+
+    parsed["schema_path"] = str(source_path)
+    return parsed
+
+
+def _find_requirement_schema_path(root: Path) -> Path | None:
+    for pattern in _REQUIREMENT_SCHEMA_GLOBS:
+        for candidate in root.glob(pattern):
+            if candidate.is_file():
+                return candidate
+    return None
+
+
+@lru_cache(maxsize=8)
+def load_requirement_schema(instance_id: str) -> dict[str, Any] | None:
+    root = resolve_domain_pack_root(instance_id)
+    if root is None:
+        return None
+
+    schema_path = _find_requirement_schema_path(root)
+    if schema_path is None:
+        return None
+
+    try:
+        schema_text = schema_path.read_text(encoding="utf-8")
+    except OSError:
+        logger.warning("domain_pack.read_failed file=%s", str(schema_path))
+        return None
+
+    try:
+        schema = _load_requirement_schema_text(schema_text, source_path=schema_path)
+    except Exception as exc:
+        logger.warning("domain_pack.schema_parse_failed file=%s error=%s", str(schema_path), str(exc))
+        return None
+
+    schema["root"] = str(root)
+    return schema
+
+
+@lru_cache(maxsize=8)
+def load_instance_profile(instance_id: str) -> dict[str, Any] | None:
+    root = resolve_domain_pack_root(instance_id)
+    if root is None:
+        return None
+
+    profile_path = root / _INSTANCE_PROFILE_FILE
+    if not profile_path.exists():
+        return None
+
+    try:
+        data = json.loads(profile_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        logger.warning("domain_pack.invalid_json file=%s", str(profile_path))
+        return None
+    except OSError:
+        logger.warning("domain_pack.read_failed file=%s", str(profile_path))
+        return None
+
+    if not isinstance(data, dict):
+        logger.warning("domain_pack.invalid_profile file=%s", str(profile_path))
+        return None
+    return data

flare_kernel/runtime/llm_provider.py

@@ -0,0 +1,204 @@
+"""LLM provider adapter layer for the kernel."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Any
+
+from flare_kernel.runtime.logging import get_logger
+
+logger = get_logger("flare_kernel.runtime.llm_provider")
+
+_DEFAULT_PROVIDER_BACKEND = "dashscope"
+_DASHSCOPE_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+_DASHSCOPE_MODEL = "qwen-plus"
+
+
+@dataclass(frozen=True)
+class LLMProviderConfig:
+    backend: str
+    dashscope_api_key: str | None
+    dashscope_base_url: str
+    dashscope_model: str
+    timeout_seconds: float
+
+
+@dataclass(frozen=True)
+class LLMCompletion:
+    provider: str
+    model: str
+    content: str
+    status: str
+    details: dict[str, Any]
+
+
+def _env(name: str, default: str | None = None) -> str | None:
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    value = raw.strip()
+    return value if value else default
+
+
+def _placeholder_content(provider: str, model: str, reason: str | None = None) -> str:
+    suffix = f" ({reason})" if reason else ""
+    return f"[{provider}:{model}] LLM placeholder{suffix}"
+
+
+def _float_env(name: str, default: float) -> float:
+    raw = _env(name)
+    if raw is None:
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        logger.warning("llm.provider.invalid_timeout env=%s raw=%s", name, raw)
+        return default
+
+
+@lru_cache(maxsize=1)
+def get_llm_provider_config() -> LLMProviderConfig:
+    backend = (_env("LLM_PROVIDER_BACKEND", _DEFAULT_PROVIDER_BACKEND) or _DEFAULT_PROVIDER_BACKEND).lower()
+    return LLMProviderConfig(
+        backend=backend,
+        dashscope_api_key=_env("DASHSCOPE_API_KEY"),
+        dashscope_base_url=_env("DASHSCOPE_BASE_URL", _DASHSCOPE_BASE_URL) or _DASHSCOPE_BASE_URL,
+        dashscope_model=_env("DASHSCOPE_MODEL", _DASHSCOPE_MODEL) or _DASHSCOPE_MODEL,
+        timeout_seconds=_float_env("LLM_PROVIDER_TIMEOUT_SECONDS", 60.0),
+    )
+
+
+async def generate_llm_completion(prompt: str, *, trace_id: str, session_id: str, intent: str) -> LLMCompletion:
+    config = get_llm_provider_config()
+
+    if config.backend != "dashscope":
+        provider = config.backend
+        model = config.dashscope_model
+        logger.info("llm.provider.placeholder backend=%s trace_id=%s session_id=%s intent=%s", provider, trace_id, session_id, intent)
+        return LLMCompletion(
+            provider=provider,
+            model=model,
+            content=_placeholder_content(provider, model, "provider backend is not dashscope"),
+            status="placeholder",
+            details={"backend": provider, "reason": "provider backend is not dashscope"},
+        )
+
+    if not config.dashscope_api_key:
+        logger.info("llm.provider.missing_key backend=dashscope trace_id=%s session_id=%s intent=%s", trace_id, session_id, intent)
+        return LLMCompletion(
+            provider="dashscope",
+            model=config.dashscope_model,
+            content=_placeholder_content("dashscope", config.dashscope_model, "DASHSCOPE_API_KEY is missing"),
+            status="placeholder",
+            details={"backend": "dashscope", "reason": "DASHSCOPE_API_KEY is missing"},
+        )
+
+    payload = {
+        "model": config.dashscope_model,
+        "messages": [
+            {
+                "role": "system",
+                "content": "You are FLARE kernel. Respond concisely and helpfully.",
+            },
+            {
+                "role": "user",
+                "content": prompt,
+            },
+        ],
+        "temperature": 0.2,
+    }
+
+    headers = {
+        "Authorization": f"Bearer {config.dashscope_api_key}",
+        "Content-Type": "application/json",
+    }
+    url = f"{config.dashscope_base_url.rstrip('/')}/chat/completions"
+
+    try:
+        import httpx
+    except ImportError:
+        logger.warning("llm.provider.httpx_missing backend=dashscope trace_id=%s session_id=%s intent=%s", trace_id, session_id, intent)
+        return LLMCompletion(
+            provider="dashscope",
+            model=config.dashscope_model,
+            content=_placeholder_content("dashscope", config.dashscope_model, "httpx is not installed"),
+            status="placeholder",
+            details={"backend": "dashscope", "reason": "httpx_missing"},
+        )
+
+    try:
+        async with httpx.AsyncClient(timeout=config.timeout_seconds) as client:
+            response = await client.post(url, json=payload, headers=headers)
+    except httpx.HTTPError as exc:
+        logger.warning("llm.provider.request_failed backend=dashscope trace_id=%s session_id=%s intent=%s error=%s", trace_id, session_id, intent, str(exc))
+        return LLMCompletion(
+            provider="dashscope",
+            model=config.dashscope_model,
+            content=_placeholder_content("dashscope", config.dashscope_model, "request failed"),
+            status="placeholder",
+            details={"backend": "dashscope", "reason": "request failed", "error": str(exc)},
+        )
+
+    if response.status_code != 200:
+        logger.warning(
+            "llm.provider.http_error backend=dashscope trace_id=%s session_id=%s intent=%s status=%s",
+            trace_id,
+            session_id,
+            intent,
+            response.status_code,
+        )
+        return LLMCompletion(
+            provider="dashscope",
+            model=config.dashscope_model,
+            content=_placeholder_content("dashscope", config.dashscope_model, f"HTTP {response.status_code}"),
+            status="placeholder",
+            details={
+                "backend": "dashscope",
+                "reason": "http_error",
+                "status_code": response.status_code,
+                "response_text": response.text[:512],
+            },
+        )
+
+    try:
+        data = response.json()
+    except json.JSONDecodeError:
+        logger.warning("llm.provider.invalid_json backend=dashscope trace_id=%s session_id=%s intent=%s", trace_id, session_id, intent)
+        return LLMCompletion(
+            provider="dashscope",
+            model=config.dashscope_model,
+            content=_placeholder_content("dashscope", config.dashscope_model, "invalid JSON response"),
+            status="placeholder",
+            details={"backend": "dashscope", "reason": "invalid_json", "response_text": response.text[:512]},
+        )
+    choices = data.get("choices") if isinstance(data, dict) else None
+    message = ""
+    if isinstance(choices, list) and choices:
+        first_choice = choices[0]
+        if isinstance(first_choice, dict):
+            choice_message = first_choice.get("message")
+            if isinstance(choice_message, dict):
+                content = choice_message.get("content")
+                if isinstance(content, str):
+                    message = content.strip()
+
+    if not message:
+        logger.warning("llm.provider.empty_response backend=dashscope trace_id=%s session_id=%s intent=%s", trace_id, session_id, intent)
+        return LLMCompletion(
+            provider="dashscope",
+            model=config.dashscope_model,
+            content=_placeholder_content("dashscope", config.dashscope_model, "empty response"),
+            status="placeholder",
+            details={"backend": "dashscope", "reason": "empty response", "response": data},
+        )
+
+    return LLMCompletion(
+        provider="dashscope",
+        model=config.dashscope_model,
+        content=message,
+        status="ok",
+        details={"backend": "dashscope"},
+    )

flare_kernel/runtime/logging.py

@@ -0,0 +1,21 @@
+"""Kernel logging setup."""
+
+from __future__ import annotations
+
+import logging
+
+_LOG_FORMAT = "%(asctime)s %(levelname)s %(name)s %(message)s"
+_configured = False
+
+
+def _ensure_basic_logging() -> None:
+    global _configured
+    if _configured:
+        return
+    logging.basicConfig(level=logging.INFO, format=_LOG_FORMAT)
+    _configured = True
+
+
+def get_logger(name: str) -> logging.Logger:
+    _ensure_basic_logging()
+    return logging.getLogger(name)