ltcai 11.5.2 → 11.7.0

package/latticeai/runtime/access_runtime.py

@@ -148,24 +148,10 @@ def build_access_runtime(
                     quiet()
         raise http_exception(status_code=403, detail="관리자 권한이 필요합니다.")
 
-    def public_user(email: str, user: Dict, users: Dict) -> Dict:
-        role = get_user_role(email, users)
-        user_id = user.get("id") or user_id_for_email(users, email)
-        return {
-            "id": user_id,
-            "email": email,
-            "identity": user_id,
-            "name": user.get("name", ""),
-            "nickname": user.get("nickname", ""),
-            "role": role,
-            "disabled": bool(user.get("disabled", False)),
-        }
-
     return {
         "get_user_role": get_user_role,
         "_extract_bearer_token": extract_bearer_token,
         "get_current_user": get_current_user,
         "require_user": require_user,
         "require_admin": require_admin,
-        "public_user": public_user,
     }

package/latticeai/runtime/bootstrap.py

@@ -1,11 +1,13 @@
-"""Session bootstrap runtime: session store and token helpers.
-
-Extracted from ``app_factory._build`` as a composition seam. The session
-token helpers stay closures over a single ``SessionStore`` so the factory
-keeps one source of truth for token lifecycle. ``user_id_resolver`` is the
-factory's ``user_id_for_email`` — injected so the store stays decoupled from
-user persistence. Heavy imports stay inside the function so importing the
-module has no side effects.
+"""Session bootstrap runtime: the token read the seam gate performs.
+
+``lattice-auth`` owns the durable session: it issues the token, it persists it,
+it invalidates it. The worker only ever *reads* one — ``require_user`` resolves
+a bearer token or cookie to an email so a seam call can be attributed and rate
+limited — so this seam is the store plus that single lookup.
+
+``user_id_resolver`` is the factory's ``user_id_for_email``, injected so the
+store stays decoupled from user persistence. Heavy imports stay inside the
+function so importing the module has no side effects.
 """
 
 from __future__ import annotations
@@ -26,23 +28,10 @@ def build_session_runtime(
 
     session_store = SessionStore(ttl_seconds=ttl_seconds)
 
-    def create_session(email: str) -> str:
-        return session_store.create(user_id_resolver(email) or email, email=email)
-
     def get_session_email(token: str) -> Optional[str]:
         return session_store.get_email(token)
 
-    def get_session_user_id(token: str) -> Optional[str]:
-        return session_store.get_subject(token)
-
-    def invalidate_session(token: str) -> None:
-        session_store.invalidate(token)
-
     return {
-        "_SESSION_TTL": ttl_seconds,
         "_session_store": session_store,
-        "create_session": create_session,
         "get_session_email": get_session_email,
-        "get_session_user_id": get_session_user_id,
-        "invalidate_session": invalidate_session,
     }

package/latticeai/runtime/brain_runtime.py

@@ -1,53 +1,45 @@
-"""Brain Core runtime assembly for app startup."""
+"""Embedder resolution for the AI-Worker build.
 
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
+``build_brain_runtime`` used to open the knowledge-graph store and the
+conversation store. Rust owns every durable write after v11.6.0 §Wave 2.5, so
+what is left of "the Brain" inside the worker is the one port the compute seams
+need: something that turns text into a vector.
 
-from latticeai.runtime.stages import RuntimeStage
+The resolution rules are the product's, unchanged — a named profile supplies
+model/dimensions, explicit configuration overrides it, and a provider that
+cannot be reached degrades to the offline hash embedder while recording what
+was requested.
+"""
 
+from __future__ import annotations
 
-@dataclass(frozen=True)
-class BrainRuntime(RuntimeStage):
-    BRAIN_CORE: Any
-    KNOWLEDGE_GRAPH: Any
-    CONVERSATIONS: Any
+from typing import Any, Callable, Mapping
 
 
-def build_brain_runtime(
+def build_embedder_runtime(
     *,
-    data_dir: Any,
-    history_file: Any,
-    enable_graph: bool,
-    embedder: Any,
-    storage_engine: Any,
-) -> BrainRuntime:
-    """Construct Brain Core storage/conversation primitives behind one seam."""
-
-    from lattice_brain import BrainCore, ConversationStore
-
-    brain_core = (
-        BrainCore.from_paths(
-            data_dir,
-            embedder=embedder.provider,
-            storage_engine=storage_engine,
-        )
-        if enable_graph
-        else None
-    )
-    knowledge_graph = brain_core.knowledge if brain_core is not None else None
-    conversations = (
-        brain_core.conversations
-        if brain_core is not None
-        else ConversationStore(data_dir / "knowledge_graph.sqlite")
-    )
-    conversations.import_legacy_json(history_file)
-    return BrainRuntime(
-        BRAIN_CORE=brain_core,
-        KNOWLEDGE_GRAPH=knowledge_graph,
-        CONVERSATIONS=conversations,
+    config: Any,
+    profile: Mapping[str, Any],
+    resolve_embedder: Callable[..., Any],
+) -> Any:
+    """Resolve the configured embedding provider once."""
+
+    provider = config.embedding_provider
+    model = config.embedding_model or str(profile.get("model") or "")
+    dim = config.embedding_dim or int(profile.get("dimensions") or 0)
+    if config.embedding_profile and provider in {"", "hash", "local", "fallback"}:
+        provider = str(profile.get("provider") or provider)
+
+    return resolve_embedder(
+        provider,
+        model=model,
+        base_url=config.embedding_base_url,
+        api_key=config.embedding_api_key,
+        dim=dim,
+        timeout=config.embedding_timeout,
+        extra={"target": config.embedding_custom_target},
+        probe=provider not in {"", "hash", "local", "fallback"},
     )
 
 
-__all__ = ["BrainRuntime", "build_brain_runtime"]
+__all__ = ["build_embedder_runtime"]

package/latticeai/runtime/build_phases/__init__.py

@@ -1,19 +1,25 @@
-"""The ordered phases that build the Lattice AI application.
+"""The ordered phases that build the Lattice AI AI-Worker application.
 
 Each phase reads what earlier phases published on the :class:`RuntimeContext`
 and publishes its own results. The order below *is* the dependency order and is
 fixed by ``tests/unit/test_runtime_context.py``:
 
-1.  ``platform``   — MLX/GPU device selection (the only step that touches hardware)
-2.  ``config``     — configuration, security settings, paths, filesystem layout
-3.  ``identity``   — users, sessions, audit, access control, API keys, SSO/VPC config
-4.  ``brain``      — embedder, knowledge graph, conversations, hooks, persistence, history
-5.  ``domain``     — model router, garden, chat service (needed by the web phase)
-6.  ``web``        — lifespan, the FastAPI app, model runtime, static + foundation routers
-7.  ``services``   — retrieval/context, chat agent runtime, the typed AppContext
-8.  ``foundation_routes`` — mount the foundation routers now that AppContext exists
-9.  ``platform_features`` — workspace platform, automation, review, command centre
-10. ``interaction`` — model/chat/search/tools routers and the brain tail routers
+1. ``platform`` — MLX/GPU device selection (the only step that touches hardware)
+2. ``config``   — configuration, paths, the data directory
+3. ``identity`` — the seam gate: users read, sessions, access control, rate limit
+4. ``brain``    — the embedder and the multi-modal ports
+5. ``domain``   — the LLM router and the tool-dispatch policy
+6. ``web``      — lifespan, the FastAPI object, the model runtime service
+7. ``features`` — the worker's compute routers
+
+``worker_profile.phase_worker_routes`` runs *after* this list (from
+:func:`latticeai.worker_app.create_worker_app`): it mounts the ``/worker/*``
+seams and then asserts the served surface is exactly the worker contract.
+
+v11.6.0 (WP-P1) cut the product's ten phases to these seven. The three that
+disappeared — ``services`` (the typed ``AppContext``), ``foundation_routes``
+(auth/admin/security/static/workspace) and ``platform_features`` (~34 product
+routers) — built the surface ``lattice-host`` now serves natively.
 
 Every heavy import lives *inside* a phase, never at module scope: importing
 this module must stay free of GPU init, singleton construction, and filesystem
@@ -23,33 +29,17 @@ Why closures still appear here: several handlers must resolve a dependency at
 call time rather than at construction time, because the dependency is built by
 a later phase. Those read through ``ctx``, which is exactly the late binding
 the original single function got from Python's closure rules.
-
-v11.3.0 split the 1,450-line module into three stage submodules — ``foundation``
-(1-4), ``web`` (5-8) and ``features`` (9-10). Nothing else moved: this package
-re-exports every phase under its historical name and :data:`BUILD_PHASES` stays
-defined here, in one place, so the order test and the factory read the same
-tuple rather than a copy that can drift.
 """
 
 from __future__ import annotations
 
-from latticeai.runtime.build_phases.features import (
-    phase_interaction as phase_interaction,
-)
-from latticeai.runtime.build_phases.features import (
-    phase_platform_features as phase_platform_features,
-)
+from latticeai.runtime.build_phases.features import phase_features as phase_features
 from latticeai.runtime.build_phases.foundation import phase_brain as phase_brain
 from latticeai.runtime.build_phases.foundation import phase_config as phase_config
 from latticeai.runtime.build_phases.foundation import phase_identity as phase_identity
 from latticeai.runtime.build_phases.foundation import phase_platform as phase_platform
 from latticeai.runtime.build_phases.web import phase_domain as phase_domain
-from latticeai.runtime.build_phases.web import (
-    phase_foundation_routes as phase_foundation_routes,
-)
-from latticeai.runtime.build_phases.web import phase_services as phase_services
 from latticeai.runtime.build_phases.web import phase_web as phase_web
-from latticeai.runtime.build_phases.web import self_model_port as self_model_port
 
 #: The build order. Exported so the ordering test reads the same list the
 #: factory runs, rather than a copy that can drift.
@@ -60,23 +50,17 @@ BUILD_PHASES = (
     phase_brain,
     phase_domain,
     phase_web,
-    phase_services,
-    phase_foundation_routes,
-    phase_platform_features,
-    phase_interaction,
+    phase_features,
 )
 
 
 __all__ = [
     "BUILD_PHASES",
     "phase_brain",
-    "phase_domain",
     "phase_config",
-    "phase_foundation_routes",
+    "phase_domain",
+    "phase_features",
     "phase_identity",
-    "phase_interaction",
     "phase_platform",
-    "phase_platform_features",
-    "phase_services",
     "phase_web",
 ]