ltcai 9.0.0 → 9.1.0

package/latticeai/runtime/security_runtime.py

@@ -2,26 +2,123 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict
+import json
+import logging
+import secrets
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict
+
+from latticeai.runtime.stages import RuntimeStage
 
 if TYPE_CHECKING:
     from latticeai.core.config import Config
 
 
-def build_security_runtime(config: "Config") -> Dict[str, Any]:
+_SECURITY_SECRETS_FILE = "security_secrets.json"
+
+
+@dataclass(frozen=True)
+class SecurityRuntime(RuntimeStage):
+    SSO_DISCOVERY_URL: str
+    SSO_CLIENT_ID: str
+    SSO_CLIENT_SECRET: str
+    SSO_REDIRECT_URI: str
+    SSO_PROVIDER_NAME: str
+    RATE_LIMIT_ENABLED: bool
+    OPEN_REGISTRATION: bool
+    INVITE_CODE: str
+    INVITE_COOKIE_SECRET: str
+    INVITE_GATE_ENABLED: bool
+    SECURE_COOKIES: bool
+
+
+def _stored_security_secrets(data_dir: Path) -> Dict[str, str]:
+    path = data_dir / _SECURITY_SECRETS_FILE
+    if not path.exists():
+        return {}
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        # A corrupt secret store invalidates old invite cookies, but must never
+        # make startup fall back to a shared or predictable signing key.
+        logging.warning("invite-gate secret store is unreadable; rotating secrets: %s", exc)
+        return {}
+    if not isinstance(payload, dict):
+        return {}
+    return {
+        key: str(value)
+        for key, value in payload.items()
+        if key in {"invite_code", "invite_cookie_secret"} and value
+    }
+
+
+def _resolve_invite_gate_secrets(config: "Config") -> tuple[str, str]:
+    """Resolve stable, per-install invitation secrets.
+
+    No file is created while the invitation gate is disabled.  Once enabled,
+    missing values are generated with the OS CSPRNG and persisted atomically
+    with mode 0600 so restarts do not invalidate links or signed cookies.
+    Explicit environment values remain authoritative and are not copied to the
+    local secret file unnecessarily.
+    """
+
+    if not config.invite_gate_enabled:
+        return config.invite_code, config.invite_cookie_secret
+
+    from latticeai.core.io_utils import atomic_write_json
+
+    data_dir = Path(config.data_dir)
+    stored = _stored_security_secrets(data_dir)
+    invite_code = config.invite_code or stored.get("invite_code") or secrets.token_urlsafe(24)
+    cookie_secret = (
+        config.invite_cookie_secret
+        or stored.get("invite_cookie_secret")
+        or secrets.token_urlsafe(48)
+    )
+
+    persisted = dict(stored)
+    if not config.invite_code:
+        persisted["invite_code"] = invite_code
+    if not config.invite_cookie_secret:
+        persisted["invite_cookie_secret"] = cookie_secret
+    if persisted != stored:
+        atomic_write_json(data_dir / _SECURITY_SECRETS_FILE, persisted)
+    return invite_code, cookie_secret
+
+
+def build_security_runtime(config: "Config") -> SecurityRuntime:
     """Build auth/security-derived runtime settings from the central config."""
 
     from latticeai.core.security import configure_trusted_proxies
 
     configure_trusted_proxies(config.trusted_proxies)
-    return {
-        "SSO_DISCOVERY_URL": config.sso_discovery_url,
-        "SSO_CLIENT_ID": config.sso_client_id,
-        "SSO_CLIENT_SECRET": config.sso_client_secret,
-        "SSO_REDIRECT_URI": config.sso_redirect_uri,
-        "SSO_PROVIDER_NAME": config.sso_provider_name,
-        "RATE_LIMIT_ENABLED": config.rate_limit_enabled,
-        "OPEN_REGISTRATION": config.open_registration,
-        "INVITE_CODE": config.invite_code,
-        "INVITE_GATE_ENABLED": config.invite_gate_enabled,
-    }
+    invite_code, invite_cookie_secret = _resolve_invite_gate_secrets(config)
+    secure_cookies = bool(config.is_public or config.network_exposed)
+    if secure_cookies:
+        logging.warning(
+            "Public/non-loopback mode: authentication and Secure cookies are forced; "
+            "serve Lattice AI through HTTPS/TLS or browser sessions will be rejected."
+        )
+    if config.invite_gate_enabled and not config.invite_code:
+        logging.warning(
+            "No LATTICEAI_INVITE_CODE was configured; generated a private per-install "
+            "invite code in %s.",
+            Path(config.data_dir) / _SECURITY_SECRETS_FILE,
+        )
+    return SecurityRuntime(
+        SSO_DISCOVERY_URL=config.sso_discovery_url,
+        SSO_CLIENT_ID=config.sso_client_id,
+        SSO_CLIENT_SECRET=config.sso_client_secret,
+        SSO_REDIRECT_URI=config.sso_redirect_uri,
+        SSO_PROVIDER_NAME=config.sso_provider_name,
+        RATE_LIMIT_ENABLED=config.rate_limit_enabled,
+        OPEN_REGISTRATION=config.open_registration,
+        INVITE_CODE=invite_code,
+        INVITE_COOKIE_SECRET=invite_cookie_secret,
+        INVITE_GATE_ENABLED=config.invite_gate_enabled,
+        SECURE_COOKIES=secure_cookies,
+    )
+
+
+__all__ = ["SecurityRuntime", "build_security_runtime"]

package/latticeai/runtime/stages.py

@@ -0,0 +1,27 @@
+"""Typed mapping base for application assembly stages."""
+
+from __future__ import annotations
+
+from dataclasses import fields
+from typing import Any, Iterator, Mapping
+
+
+class RuntimeStage(Mapping[str, Any]):
+    """Dataclass mixin that preserves the legacy mapping access during DI migration."""
+
+    def __getitem__(self, key: str) -> Any:
+        if key not in self:
+            raise KeyError(key)
+        return getattr(self, key)
+
+    def __iter__(self) -> Iterator[str]:
+        return (field.name for field in fields(self))
+
+    def __len__(self) -> int:
+        return len(fields(self))
+
+    def __contains__(self, key: object) -> bool:
+        return isinstance(key, str) and any(field.name == key for field in fields(self))
+
+
+__all__ = ["RuntimeStage"]

package/latticeai/server_app.py

@@ -13,6 +13,8 @@ from __future__ import annotations
 
 from typing import Any, List
 
+from latticeai.runtime.namespace_runtime import SERVER_APP_EXPORTS
+
 
 def _runtime():
     from latticeai.app_factory import get_shared_runtime
@@ -25,6 +27,8 @@ def __getattr__(name: str) -> Any:
         # Never let dunder probes (importlib, inspect, pickling) trigger the
         # full application construction.
         raise AttributeError(name)
+    if name not in SERVER_APP_EXPORTS:
+        raise AttributeError(f"module 'latticeai.server_app' has no attribute '{name}'")
     try:
         return getattr(_runtime(), name)
     except AttributeError as exc:
@@ -34,7 +38,7 @@ def __getattr__(name: str) -> Any:
 
 
 def __dir__() -> List[str]:
-    return sorted(set(globals()) | set(vars(_runtime())))
+    return sorted(set(globals()) | set(SERVER_APP_EXPORTS))
 
 
 def main() -> None:

package/latticeai/services/architecture_readiness.py

@@ -1,6 +1,6 @@
 """Machine-checkable architecture readiness gates for release work.
 
-9.0.0 keeps the major architecture priorities under an explicit release
+The current release keeps the major architecture priorities under an explicit release
 contract while product maturity work reduces visible beta seams. AgentRuntime, ToolRegistry,
 central Config, decomposed server runtime, and Knowledge Graph stabilization
 must remain discoverable, ordered, and backed by tests before the release can be
@@ -17,7 +17,7 @@ from typing import Any, Dict, List
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
 
-ARCHITECTURE_VERSION_TARGET = "9.0.0"
+ARCHITECTURE_VERSION_TARGET = "9.1.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",
@@ -54,16 +54,64 @@ def _symbol_exists(dotted: str) -> bool:
         return False
 
 
+def _forbidden_patterns(root: Path, relative_path: str, patterns: List[str]) -> List[str]:
+    path = root / relative_path
+    try:
+        source = path.read_text(encoding="utf-8")
+    except OSError:
+        return [f"missing:{relative_path}"]
+    return [pattern for pattern in patterns if pattern in source]
+
+
 def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
     if root is None:
         root = Path(__file__).resolve().parents[2]
     shim_report = legacy_shim_report(root)
+    factory_forbidden = _forbidden_patterns(
+        root,
+        "latticeai/app_factory.py",
+        ["build_runtime_namespace(locals", "dict(locals())"],
+    )
+    model_runtime_forbidden = _forbidden_patterns(
+        root,
+        "latticeai/services/model_runtime.py",
+        [
+            "def _sync_globals",
+            "global router",
+            "STATE = ModelRuntimeState",
+            "_STATE_EXPORTS",
+            "def __getattr__(name:",
+            "from fastapi import HTTPException",
+        ],
+    )
+    model_runtime_forbidden.extend(
+        _forbidden_patterns(
+            root,
+            "latticeai/services/model_loading.py",
+            ["from .model_runtime import STATE", "from fastapi import HTTPException"],
+        )
+    )
+    model_runtime_forbidden.extend(
+        _forbidden_patterns(
+            root,
+            "latticeai/services/model_engines.py",
+            ["from fastapi import HTTPException", "raise HTTPException"],
+        )
+    )
+    agent_alias_forbidden = _forbidden_patterns(
+        root,
+        "latticeai/core/agent.py",
+        ["AgentRuntime = SingleAgentRuntime"],
+    )
 
     gates = [
         ArchitectureGate(
             id="agent-runtime",
             title="AgentRuntime boundary",
-            status="complete" if _symbol_exists("lattice_brain.runtime.agent_runtime.AgentRuntime") else "incomplete",
+            status="complete" if (
+                _symbol_exists("lattice_brain.runtime.agent_runtime.AgentRuntime")
+                and not agent_alias_forbidden
+            ) else "incomplete",
             evidence=[
                 "lattice_brain.runtime.agent_runtime.AgentRuntime",
                 "latticeai.api.agents.create_agents_router(agent_runtime=...)",
@@ -83,7 +131,11 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
         ArchitectureGate(
             id="config-centralization",
             title="Central app Config",
-            status="complete" if _symbol_exists("latticeai.core.config.Config") else "incomplete",
+            status="complete" if (
+                _symbol_exists("latticeai.core.config.Config")
+                and _symbol_exists("latticeai.runtime.config_runtime.ConfigRuntime")
+                and not model_runtime_forbidden
+            ) else "incomplete",
             evidence=[
                 "latticeai.core.config.Config.from_env",
                 "latticeai.runtime.config_runtime.ConfigRuntime",
@@ -93,7 +145,19 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
         ArchitectureGate(
             id="server-decomposition",
             title="Server decomposition",
-            status="complete",
+            status="complete" if (
+                all(
+                    _symbol_exists(symbol)
+                    for symbol in [
+                        "latticeai.runtime.config_runtime.ConfigRuntime",
+                        "latticeai.runtime.security_runtime.SecurityRuntime",
+                        "latticeai.runtime.brain_runtime.BrainRuntime",
+                        "latticeai.runtime.model_wiring.ModelRuntime",
+                        "latticeai.runtime.router_registration.RouterBundle",
+                    ]
+                )
+                and not factory_forbidden
+            ) else "incomplete",
             evidence=[
                 "latticeai.app_factory.create_app composition root",
                 "latticeai.api.* domain routers",
@@ -192,6 +256,11 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
             "runtime_modules": runtime_module_count,
             "architecture_gates": len(gates),
             "legacy_shims_remaining": shim_report["remaining_count"],
+            "forbidden_patterns": {
+                "app_factory": factory_forbidden,
+                "model_runtime": model_runtime_forbidden,
+                "agent_alias": agent_alias_forbidden,
+            },
         },
         "legacy_compatibility": shim_report,
     }

package/latticeai/services/brain_automation.py

@@ -136,6 +136,7 @@ def build_brain_automation_workflow(recipe_id: str, *, enabled: bool = False) ->
     trigger_config = {
         **deepcopy(recipe.trigger),
         "enabled": bool(enabled),
+        "review_queue": True,
         "consent_required": True,
         "local_only": True,
         "external_actions": False,
@@ -156,7 +157,9 @@ def build_brain_automation_workflow(recipe_id: str, *, enabled: bool = False) ->
                 "name": "Draft Brain review",
                 "config": {
                     "agent": "agent:planner",
+                    "goal": recipe.prompt,
                     "prompt": recipe.prompt,
+                    "roles": ["researcher", "planner", "executor", "reviewer"],
                     "mode": "draft",
                     "local_only": True,
                     "external_actions": False,
@@ -186,29 +189,3 @@ def build_brain_automation_workflow(recipe_id: str, *, enabled: bool = False) ->
             "creates": list(recipe.creates),
         },
     }
-
-
-# === A방향 (Act/automation + BrainAutomationPanel) E2E 시나리오 초안 ===
-# (backend 인터페이스 list_brain_automation_recipes / find_installed... / build_... 완료 후 즉시 작성)
-# 1. Recipe 목록 노출: frontend BrainAutomationPanel이 list_brain_automation_recipes() 호출 → recipes + consent metadata 표시.
-# 2. "Create reviewable draft" 클릭:
-#    - build_brain_automation_workflow(recipe_id, enabled=False) 로 draft 생성 (metadata.recipe_id + created_from=brain_automation_recipe)
-#    - find_installed_recipe_workflow 로 사전 dedup 체크 → 이미 있으면 기존 반환, UI disabled + "✓ Reviewable draft ready" 피드백.
-#    - 생성된 workflow는 automation_state="draft_disabled", trigger.enabled=False → TriggerService 무시.
-# 3. Dedup guard (UI + backend): metadata.recipe_id + created_from 기준. 중복 클릭 가드 (no-dup) 로 double submit 방지.
-# 4. User가 draft를 review/수정 후 enabled=True 로 전환 → TriggerService._triggered_workflows 에서 enabled True인 것만 arm.
-# 5. Interval trigger E2E:
-#    - reconcile_missed() : 다운타임 중 missed → "skipped" 이벤트 기록 (catch-up storm 없음).
-#    - tick_intervals() : last_fired_at + interval + last_attempt_at dedup 가드 (10s cooldown) 로 중복 실행 방지.
-#    - LATTICE_TZ 환경변수: describe()에 "tz" 노출, 이벤트 at 값은 epoch이지만 클라이언트가 LATTICE_TZ로 현지화.
-# 6. Brain event trigger E2E: kg_ingest.* post_tool hook → on_brain_event → matching source_type 필터 → _fire (dedup 5s).
-# 7. Failure degraded:
-#    - _fire 에서 run_workflow 예외 → _record_fire_outcome → consecutive_failures++ , describe() "status":"degraded" ( >=3 ).
-#    - 성공 시 reset. (실행 내부 실패는 workflow run record에 남음, scheduler는 launch health만).
-# 8. Run provenance: fired run의 inputs["__trigger__"] = {"type": "interval"|"brain_event", ...} 로 감사/디버그 가능.
-# 9. Consent-first: draft_disabled 기본, user enable 전까지 절대 실행 안 됨. "review_before_run": True.
-# 10. End-to-end Act: draft → enable → trigger fire → agent:planner "Draft Brain review" 노드 → output (requires_review) → user review → save or discard.
-#
-# 다음: 실제 API (e.g. POST /brain/automation/install-draft) 가 UI에서 호출되면 위 시나리오에 대한 통합 테스트 + RunExecutor 경로 검증 즉시 추가.
-# 현재 상태: backend recipe 인터페이스 + TriggerService edge 하드닝 + AgentRuntime wiring 완료. UI (App.tsx + styles) + test_brain_automation.py 는 별도 완료 보고됨.
-

package/latticeai/services/chat_service.py

@@ -1,37 +1,191 @@
-"""Chat / session service seam.
+"""Non-HTTP chat orchestration: history persistence and answer traces.
 
-The streaming chat path in ``server_app`` is intentionally left in place — its
-generator and SSE behaviour are sensitive. This service provides a stable seam
-for the *bookkeeping* around answers (conversation history access and
-Workspace-OS answer-trace recording) so those concerns are named and wrapped
-rather than reaching into the store directly from the streaming handler.
+The API layer owns FastAPI requests/responses and SSE framing.  This service
+owns the reusable bookkeeping that must be identical across normal answers,
+streamed answers, document generation, and fast-path intents:
 
-It is a behaviour-preserving façade: methods forward to the injected history
-accessor and :class:`WorkspaceOSStore`, so wiring the chat path through it
-cannot change streaming output.
+* workspace/user-scoped history reads;
+* asynchronous persistence of user/assistant exchanges;
+* Graph-RAG answer trace construction and recording;
+* history search/grouping independent of HTTP.
+
+``coerce`` preserves lightweight test/embedding contexts that provide the old
+``build_graph_trace``/``record_trace`` façade without requiring them to grow a
+full service implementation.
 """
 
 from __future__ import annotations
 
+import asyncio
 from typing import Any, Callable, Dict, List, Optional
 
 from latticeai.core.workspace_os import WorkspaceOSStore
 
 
 class ChatService:
-    def __init__(self, *, store: WorkspaceOSStore, get_history: Callable[[], List[Dict[str, Any]]]):
+    def __init__(
+        self,
+        *,
+        store: WorkspaceOSStore,
+        get_history: Callable[..., List[Dict[str, Any]]],
+        save_to_history: Optional[Callable[..., None]] = None,
+        get_history_user: Optional[Callable[..., Dict[str, Any]]] = None,
+        trace_delegate: Any = None,
+    ):
         self._store = store
         self._get_history = get_history
+        self._save_to_history = save_to_history
+        self._get_history_user = get_history_user
+        self._trace_delegate = trace_delegate
+
+    @classmethod
+    def coerce(
+        cls,
+        candidate: Any,
+        *,
+        store: Any,
+        get_history: Callable[..., List[Dict[str, Any]]],
+        save_to_history: Callable[..., None],
+        get_history_user: Callable[..., Dict[str, Any]],
+    ) -> "ChatService":
+        """Return a fully wired service while preserving legacy trace fakes."""
+
+        if isinstance(candidate, cls):
+            candidate._get_history = get_history
+            candidate._save_to_history = save_to_history
+            candidate._get_history_user = get_history_user
+            return candidate
+        return cls(
+            store=store,
+            get_history=get_history,
+            save_to_history=save_to_history,
+            get_history_user=get_history_user,
+            trace_delegate=candidate,
+        )
 
     # ── conversation history ─────────────────────────────────────────────
 
-    def history(self) -> List[Dict[str, Any]]:
-        return self._get_history()
+    def history(self, **scope: Any) -> List[Dict[str, Any]]:
+        return self._get_history(**scope)
+
+    def history_scope(
+        self,
+        user_email: Optional[str],
+        *,
+        require_auth: bool,
+        allowed_workspaces_for: Optional[Callable[[str], Any]] = None,
+    ) -> Dict[str, Any]:
+        scoped_user = user_email if require_auth else None
+        allowed = None
+        if require_auth and scoped_user and allowed_workspaces_for is not None:
+            allowed = allowed_workspaces_for(scoped_user)
+        return {
+            "user_email": scoped_user,
+            "allowed_workspaces": allowed,
+            "include_legacy_global": not require_auth,
+        }
+
+    def history_user(
+        self,
+        user_email: Optional[str],
+        user_nickname: Optional[str],
+    ) -> Dict[str, Any]:
+        if self._get_history_user is None:
+            return {}
+        return self._get_history_user(user_email, user_nickname)
+
+    async def persist_entry(
+        self,
+        role: str,
+        content: str,
+        *,
+        history_meta: Optional[Dict[str, Any]] = None,
+        history_user: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        if self._save_to_history is None:
+            raise RuntimeError("chat history writer is not configured")
+        await asyncio.to_thread(
+            self._save_to_history,
+            role,
+            content,
+            **(history_meta or {}),
+            **(history_user or {}),
+        )
+
+    async def persist_exchange(
+        self,
+        *,
+        request_message: str,
+        stored_user_message: str,
+        answer: str,
+        source: Optional[str],
+        history_meta: Dict[str, Any],
+        history_user: Dict[str, Any],
+        notify: Optional[Callable[[str, str, Optional[str]], None]] = None,
+    ) -> None:
+        await self.persist_entry(
+            "user",
+            stored_user_message,
+            history_meta=history_meta,
+            history_user=history_user,
+        )
+        await self.persist_entry(
+            "assistant",
+            answer,
+            history_meta=history_meta,
+            history_user=history_user,
+        )
+        if notify is not None:
+            notify("user", request_message, source)
+            notify("assistant", answer, source)
+
+    def search_history(
+        self,
+        query: str,
+        *,
+        scope: Dict[str, Any],
+        conversation_title: Callable[[Dict[str, Any]], str],
+        limit: int = 30,
+    ) -> List[Dict[str, Any]]:
+        q_lower = str(query or "").strip().lower()
+        if not q_lower:
+            return []
+        matches = [
+            item
+            for item in self.history(**scope)
+            if q_lower in str(item.get("content") or "").lower()
+        ]
+        grouped: Dict[str, Dict[str, Any]] = {}
+        for item in matches:
+            conversation_id = item.get("conversation_id") or "legacy"
+            if conversation_id not in grouped:
+                grouped[conversation_id] = {
+                    "conversation_id": conversation_id,
+                    "title": conversation_title(item),
+                    "messages": [],
+                }
+            grouped[conversation_id]["messages"].append(item)
+        return list(grouped.values())[-max(1, int(limit or 30)) :]
 
     # ── answer-trace recording (Graph RAG) ───────────────────────────────
 
-    def build_graph_trace(self, question: str, graph: Any, context: str = "", *, limit: int = 8) -> Dict[str, Any]:
-        return self._store.build_graph_trace(question, graph, context, limit=limit)
+    def build_graph_trace(
+        self,
+        question: str,
+        graph: Any,
+        context: str = "",
+        *,
+        limit: int = 8,
+        allowed_workspaces=None,
+    ) -> Dict[str, Any]:
+        target = self._trace_delegate or self._store
+        return target.build_graph_trace(
+            question,
+            graph,
+            context,
+            limit=limit,
+            allowed_workspaces=allowed_workspaces,
+        )
 
     def record_trace(
         self,
@@ -43,7 +197,37 @@ class ChatService:
         trace: Dict[str, Any],
         workspace_id: Optional[str] = None,
     ) -> Dict[str, Any]:
-        return self._store.record_trace(
+        target = self._trace_delegate or self._store
+        return target.record_trace(
+            question=question,
+            response=response,
+            conversation_id=conversation_id,
+            user_email=user_email,
+            trace=trace,
+            workspace_id=workspace_id,
+        )
+
+    async def persist_answer(
+        self,
+        *,
+        question: str,
+        response: str,
+        conversation_id: Optional[str],
+        user_email: Optional[str],
+        user_nickname: Optional[str],
+        source: Optional[str],
+        trace: Dict[str, Any],
+        workspace_id: Optional[str],
+        history_meta: Dict[str, Any],
+        notify: Optional[Callable[[str, str, Optional[str]], None]] = None,
+    ) -> Dict[str, Any]:
+        await self.persist_entry(
+            "assistant",
+            response,
+            history_meta=history_meta,
+            history_user=self.history_user(user_email, user_nickname),
+        )
+        trace_record = self.record_trace(
             question=question,
             response=response,
             conversation_id=conversation_id,
@@ -51,3 +235,9 @@ class ChatService:
             trace=trace,
             workspace_id=workspace_id,
         )
+        if notify is not None:
+            notify("assistant", response, source)
+        return trace_record
+
+
+__all__ = ["ChatService"]