ltcai 9.0.0 → 9.2.0

package/latticeai/runtime/config_runtime.py

@@ -2,39 +2,71 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Optional
+
+from latticeai.runtime.stages import RuntimeStage
 
 if TYPE_CHECKING:
     from latticeai.core.config import Config
 
 
-def build_config_runtime(config: "Optional[Config]" = None) -> Dict[str, Any]:
+@dataclass(frozen=True)
+class ConfigRuntime(RuntimeStage):
+    CONFIG: Any
+    APP_MODE: str
+    IS_PUBLIC_MODE: bool
+    DEFAULT_HOST: str
+    DEFAULT_PORT: int
+    NETWORK_EXPOSED: bool
+    ENABLE_TELEGRAM: bool
+    ENABLE_GRAPH: bool
+    AUTOLOAD_MODELS: bool
+    MODEL_IDLE_UNLOAD_SECONDS: int
+    ALLOW_LOCAL_MODELS: bool
+    REQUIRE_AUTH: bool
+    ALLOW_PLAINTEXT_API_KEYS: bool
+    CORS_ALLOW_NETWORK: bool
+    CORS_EXTRA_ORIGINS: Any
+    PUBLIC_MODEL: str
+    LOCAL_MODEL: str
+    LOCAL_DRAFT_MODEL: str
+    TIMEZONE: str
+    MAX_LOCAL_MODELS: int
+    ALLOW_MODEL_DOWNLOADS: bool
+    MODEL_DOWNLOAD_TIMEOUT: int
+
+
+def build_config_runtime(config: "Optional[Config]" = None) -> ConfigRuntime:
     """Build app configuration values without importing model/runtime code."""
 
     from latticeai.core.config import Config
 
     cfg = config if config is not None else Config.from_env()
-    return {
-        "CONFIG": cfg,
-        "APP_MODE": cfg.app_mode,
-        "IS_PUBLIC_MODE": cfg.is_public,
-        "DEFAULT_HOST": cfg.host,
-        "DEFAULT_PORT": cfg.port,
-        "NETWORK_EXPOSED": cfg.network_exposed,
-        "ENABLE_TELEGRAM": cfg.enable_telegram,
-        "ENABLE_GRAPH": cfg.enable_graph,
-        "AUTOLOAD_MODELS": cfg.autoload_models,
-        "MODEL_IDLE_UNLOAD_SECONDS": cfg.model_idle_unload_seconds,
-        "ALLOW_LOCAL_MODELS": cfg.allow_local_models,
-        "REQUIRE_AUTH": cfg.require_auth,
-        "ALLOW_PLAINTEXT_API_KEYS": cfg.allow_plaintext_api_keys,
-        "CORS_ALLOW_NETWORK": cfg.cors_allow_network,
-        "CORS_EXTRA_ORIGINS": cfg.cors_extra_origins,
-        "PUBLIC_MODEL": cfg.public_model,
-        "LOCAL_MODEL": cfg.local_model,
-        "LOCAL_DRAFT_MODEL": cfg.local_draft_model,
-        "TIMEZONE": cfg.timezone,
-        "MAX_LOCAL_MODELS": cfg.max_local_models,
-        "ALLOW_MODEL_DOWNLOADS": cfg.allow_model_downloads,
-        "MODEL_DOWNLOAD_TIMEOUT": cfg.model_download_timeout,
-    }
+    return ConfigRuntime(
+        CONFIG=cfg,
+        APP_MODE=cfg.app_mode,
+        IS_PUBLIC_MODE=cfg.is_public,
+        DEFAULT_HOST=cfg.host,
+        DEFAULT_PORT=cfg.port,
+        NETWORK_EXPOSED=cfg.network_exposed,
+        ENABLE_TELEGRAM=cfg.enable_telegram,
+        ENABLE_GRAPH=cfg.enable_graph,
+        AUTOLOAD_MODELS=cfg.autoload_models,
+        MODEL_IDLE_UNLOAD_SECONDS=cfg.model_idle_unload_seconds,
+        ALLOW_LOCAL_MODELS=cfg.allow_local_models,
+        REQUIRE_AUTH=cfg.require_auth,
+        ALLOW_PLAINTEXT_API_KEYS=cfg.allow_plaintext_api_keys,
+        CORS_ALLOW_NETWORK=cfg.cors_allow_network,
+        CORS_EXTRA_ORIGINS=cfg.cors_extra_origins,
+        PUBLIC_MODEL=cfg.public_model,
+        LOCAL_MODEL=cfg.local_model,
+        LOCAL_DRAFT_MODEL=cfg.local_draft_model,
+        TIMEZONE=cfg.timezone,
+        MAX_LOCAL_MODELS=cfg.max_local_models,
+        ALLOW_MODEL_DOWNLOADS=cfg.allow_model_downloads,
+        MODEL_DOWNLOAD_TIMEOUT=cfg.model_download_timeout,
+    )
+
+
+__all__ = ["ConfigRuntime", "build_config_runtime"]

package/latticeai/runtime/context_runtime.py

@@ -23,16 +23,28 @@ def build_context_runtime(
     search_service = SearchService(graph_store=graph_store)
     brain_memory = BrainMemory(ingestion_pipeline)
 
-    def scoped_hybrid_search(q, user_email=None, **kw):
+    def scoped_hybrid_search(q, user_email=None, workspace_id=None, **kw):
         allowed = None
-        if require_auth and user_email:
-            allowed = allowed_scopes_for_user(user_email)
+        if require_auth:
+            if workspace_id is not None:
+                allowed = {workspace_id}
+            elif user_email:
+                allowed = allowed_scopes_for_user(user_email)
         return search_service.hybrid_search(q, allowed_workspaces=allowed, **kw)
 
+    def scoped_notes_context(q, user_email=None, workspace_id=None, **kw):
+        allowed = None
+        if require_auth:
+            if workspace_id is not None:
+                allowed = {workspace_id}
+            elif user_email:
+                allowed = allowed_scopes_for_user(user_email)
+        return gardener.get_relevant_context(q, allowed_workspaces=allowed, **kw)
+
     context_assembler = ContextAssembler(
         memory_recall=memory_service.recall,
         hybrid_search=scoped_hybrid_search,
-        notes_context=gardener.get_relevant_context,
+        notes_context=scoped_notes_context,
     )
 
     return {

package/latticeai/runtime/hooks_runtime.py

@@ -21,7 +21,7 @@ def build_hooks_runtime(
     """Construct the hooks registry and local-knowledge watcher behind one seam."""
 
     from lattice_brain.runtime.hooks import HooksRegistry
-    from local_knowledge_api import LocalKnowledgeWatcher
+    from latticeai.services.local_knowledge import LocalKnowledgeWatcher
 
     hooks_registry = HooksRegistry(data_dir / "hooks.json")
     local_kg_watcher = (

package/latticeai/runtime/model_wiring.py

@@ -2,14 +2,28 @@
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Any
 
 from latticeai.runtime.platform_services_runtime import build_model_service
 
 
-def configure_model_runtime_from_context(**kwargs: Any) -> None:
-    configure_model_runtime = kwargs.pop("configure_model_runtime")
-    configure_model_runtime(**kwargs)
+@dataclass(frozen=True)
+class ModelRuntime:
+    """Typed model-provider stage registered with the HTTP application."""
+
+    router: Any
+    runtime_service: Any
+    service: Any
+    runtime_features: Any
+    is_public: bool
+
+
+def configure_model_runtime_from_context(**kwargs: Any) -> Any:
+    """Build and return an isolated model runtime from app-owned values."""
+
+    build_model_runtime = kwargs.pop("build_model_runtime")
+    return build_model_runtime(**kwargs)
 
 
 def register_model_runtime_routers(
@@ -19,10 +33,11 @@ def register_model_runtime_routers(
     create_models_router: Any,
     register_health_and_model_routers: Any,
     model_router: Any,
+    runtime_service: Any,
     runtime_features: Any,
     is_public_mode: bool,
     **kwargs: Any,
-) -> Any:
+) -> ModelRuntime:
     model_service = build_model_service(
         model_router=model_router,
         runtime_features=runtime_features,
@@ -37,4 +52,17 @@ def register_model_runtime_routers(
         is_public_mode=is_public_mode,
         **kwargs,
     )
-    return model_service
+    return ModelRuntime(
+        router=model_router,
+        runtime_service=runtime_service,
+        service=model_service,
+        runtime_features=runtime_features,
+        is_public=is_public_mode,
+    )
+
+
+__all__ = [
+    "ModelRuntime",
+    "configure_model_runtime_from_context",
+    "register_model_runtime_routers",
+]

package/latticeai/runtime/namespace_runtime.py

@@ -1,21 +1,19 @@
-"""Runtime namespace filtering for legacy server_app compatibility.
+"""Explicit runtime exports for the legacy :mod:`server_app` facade.
 
-The app factory still constructs a broad local namespace for historical
-``server_app`` attribute access. This module keeps that surface deliberate:
-public runtime objects and known legacy helpers stay visible, while internal
-assembly scratch values do not leak into ``server_app.__getattr__``.
+The composition root must never export ``locals()``. Every compatibility name
+is selected here and every typed assembly stage remains available through the
+``RuntimeBundle`` without leaking construction scratch state.
 """
 
 from __future__ import annotations
 
-from dataclasses import dataclass, fields
-from types import ModuleType
+from dataclasses import dataclass
 from typing import Any, Dict, Mapping
 
 
 @dataclass(frozen=True)
 class RuntimeBundle:
-    """Typed migration target for app-factory runtime dependencies."""
+    """Typed application assembly result and its five explicit stages."""
 
     app: Any
     CONFIG: Any
@@ -29,26 +27,45 @@ class RuntimeBundle:
     build_runtime: Any
     get_shared_runtime: Any
     create_app: Any
+    config_runtime: Any
+    security_runtime: Any
+    brain_runtime: Any
+    model_runtime: Any
+    router_bundle: Any
 
     def as_legacy_dict(self) -> Dict[str, Any]:
-        return {field.name: getattr(self, field.name) for field in fields(self)}
-
-
-INTERNAL_RUNTIME_NAMES = {
-    "config",
-    "logging",
-    "os",
-    "threading",
-    "Path",
-    "mx",
-    "uvicorn",
-    "HTTPException",
-    "Request",
-    "BaseModel",
-    "keyring",
-    "datetime",
-    "runtime_bundle",
-}
+        return {
+            name: getattr(self, name)
+            for name in RUNTIME_BUNDLE_EXPORTS
+        }
+
+    @property
+    def stages(self) -> Dict[str, Any]:
+        return {
+            "config": self.config_runtime,
+            "security": self.security_runtime,
+            "brain": self.brain_runtime,
+            "models": self.model_runtime,
+            "routers": self.router_bundle,
+        }
+
+
+RUNTIME_BUNDLE_EXPORTS = frozenset(
+    {
+        "app",
+        "CONFIG",
+        "KNOWLEDGE_GRAPH",
+        "INGESTION_PIPELINE",
+        "AGENT_RUNTIME",
+        "HOOKS_REGISTRY",
+        "REVIEW_QUEUE",
+        "AGENT_REGISTRY",
+        "model_router",
+        "build_runtime",
+        "get_shared_runtime",
+        "create_app",
+    }
+)
 
 LEGACY_UNDERSCORE_EXPORTS = {
     "_LOCAL_WRITE_BLOCKED_PREFIXES",
@@ -102,72 +119,45 @@ LEGACY_PUBLIC_EXPORTS = {
 }
 
 
-def _is_internal_runtime_dict(name: str, value: Any) -> bool:
-    if not isinstance(value, dict):
-        return False
-    if name in {"_RUNTIME_BUNDLE"}:
-        return False
-    return (
-        name.endswith("_runtime")
-        or name.endswith("_router_bundle")
-        or name.endswith("_rt")
-        or name
-        in {
-            "_mcp_state",
-            "_garden_import",
-            "_foundation_router_bundle",
-            "_static_routes_bundle",
-            "_vpc_runtime",
-            "_sso_runtime",
-            "_security_runtime",
-            "_session_runtime",
-            "_config_runtime",
-            "_context_runtime",
-            "_brain_runtime",
-            "_hooks_runtime",
-            "_history_query_runtime",
-            "_persistence_runtime",
-            "_platform_automation_runtime",
-            "_user_key_runtime",
-            "_web_runtime",
-        }
-    )
-
-
 def build_runtime_namespace(
-    local_namespace: Mapping[str, Any],
-    *,
-    runtime_bundle: RuntimeBundle | Mapping[str, Any],
+    *, runtime_bundle: RuntimeBundle | Mapping[str, Any], legacy_exports: Mapping[str, Any]
 ) -> Dict[str, Any]:
-    """Return the compatibility namespace without assembly scratch values."""
+    """Return only explicit compatibility exports and typed bundle handles."""
     legacy_bundle = (
         runtime_bundle.as_legacy_dict()
         if isinstance(runtime_bundle, RuntimeBundle)
         else dict(runtime_bundle)
     )
     exported: Dict[str, Any] = dict(legacy_bundle)
-    allowed = set(legacy_bundle) | LEGACY_PUBLIC_EXPORTS | LEGACY_UNDERSCORE_EXPORTS
-    for name in allowed:
+    allowed = LEGACY_PUBLIC_EXPORTS | LEGACY_UNDERSCORE_EXPORTS
+    unexpected = set(legacy_exports) - allowed
+    if unexpected:
+        raise ValueError(f"unapproved runtime exports: {sorted(unexpected)}")
+    for name in sorted(allowed):
         if name in exported:
             continue
-        if name in INTERNAL_RUNTIME_NAMES:
-            continue
-        value = local_namespace.get(name)
+        value = legacy_exports.get(name)
         if value is None:
             continue
-        if isinstance(value, ModuleType):
-            continue
-        if _is_internal_runtime_dict(name, value):
-            continue
         exported[name] = value
     exported["RUNTIME_BUNDLE"] = runtime_bundle
     exported["_RUNTIME_BUNDLE"] = legacy_bundle
     return exported
 
 
+SERVER_APP_EXPORTS = frozenset(
+    RUNTIME_BUNDLE_EXPORTS
+    | LEGACY_PUBLIC_EXPORTS
+    | LEGACY_UNDERSCORE_EXPORTS
+    | {"RUNTIME_BUNDLE", "_RUNTIME_BUNDLE"}
+)
+
+
 __all__ = [
-    "INTERNAL_RUNTIME_NAMES",
     "LEGACY_UNDERSCORE_EXPORTS",
+    "LEGACY_PUBLIC_EXPORTS",
+    "RUNTIME_BUNDLE_EXPORTS",
     "RuntimeBundle",
+    "SERVER_APP_EXPORTS",
     "build_runtime_namespace",
 ]

package/latticeai/runtime/platform_runtime_wiring.py

@@ -24,13 +24,13 @@ def build_platform_automation_runtime(
     agent_registry: Any,
     data_dir: Any,
     append_audit_event: Callable[..., Any],
+    memory_service: Any = None,
     tz_name: Optional[str] = None,
 ) -> Dict[str, Any]:
     """Build platform services, automation services, and hook bindings.
 
-    The returned names intentionally match the historical local variables in
-    ``app_factory._build`` so ``dict(locals())`` continues to expose the legacy
-    ``server_app`` compatibility surface.
+    The returned names intentionally match the explicit composition-root
+    bindings consumed by the typed application stages.
     """
     from latticeai.runtime.automation_runtime import build_automation_runtime
     from latticeai.services.platform_runtime import PlatformRuntime
@@ -65,6 +65,7 @@ def build_platform_automation_runtime(
         llm_generate=_llm_generate_sync,
         llm_available=lambda: bool(getattr(model_router, "current_model_id", None)),
         agent_registry=agent_registry,
+        memory_recall=memory_service.recall if memory_service is not None else None,
     )
 
     automation_runtime = build_automation_runtime(

package/latticeai/runtime/review_wiring.py

@@ -27,7 +27,7 @@ def build_review_run_now_runner(platform: Any, http_exception: type[Exception])
             workflow_id,
             user_email,
             scope,
-            with_agent=False,
+            with_agent=True,
             inputs={"__review_item__": item.get("id")},
         )
 

package/latticeai/runtime/router_registration.py

@@ -8,17 +8,33 @@ exact include order while creating a narrow seam for the later
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Any
 
 from latticeai.services.router_context import InteractionRouterContext
 
 
+@dataclass(frozen=True)
+class RouterBundle:
+    """Final typed router stage after all domain routers are registered."""
+
+    app: Any
+    context: Any
+    route_count: int
+
+
+def build_router_bundle(app: Any, context: Any) -> RouterBundle:
+    return RouterBundle(app=app, context=context, route_count=len(getattr(app, "routes", ())))
+
+
 def build_static_routes_bundle(
     *,
     create_static_routes_router: Any,
     static_dir: Any,
     invite_gate_enabled: bool,
     invite_code: str,
+    invite_cookie_secret: str,
+    secure_cookies: bool,
     app_mode: str,
     model_router: Any,
     require_user: Any,
@@ -29,6 +45,8 @@ def build_static_routes_bundle(
         static_dir=static_dir,
         invite_gate_enabled=invite_gate_enabled,
         invite_code=invite_code,
+        invite_cookie_secret=invite_cookie_secret,
+        secure_cookies=secure_cookies,
         app_mode=app_mode,
         model_router=model_router,
         require_user=require_user,
@@ -37,6 +55,7 @@ def build_static_routes_bundle(
         "STATIC_ROUTES": static_routes,
         "ui_file_response": static_routes.ui_file_response,
         "local_sysinfo": static_routes.local_sysinfo,
+        "invite_authorized": static_routes.invite_authorized,
     }
 
 
@@ -61,6 +80,8 @@ def build_auth_admin_security_router_bundle(
     open_registration: bool,
     session_ttl: int,
     require_auth: bool,
+    secure_cookies: bool,
+    invite_authorized: Any,
     ensure_identity: Any,
     create_admin_router: Any,
     require_admin: Any,
@@ -113,6 +134,9 @@ def build_auth_admin_security_router_bundle(
         open_registration=open_registration,
         session_ttl=session_ttl,
         require_auth=require_auth,
+        secure_cookies=secure_cookies,
+        invite_gate_enabled=invite_gate_enabled,
+        invite_authorized=invite_authorized,
         ensure_identity=ensure_identity,
     )
 
@@ -290,8 +314,9 @@ def register_platform_feature_routers(
             require_user=require_user,
             require_admin=require_admin,
             append_audit_event=append_audit_event,
+            gate_write=platform.gate_write,
             register_skill=platform.register_plugin_skill,
-            plugin_runners_factory=lambda: platform.plugin_capability_runners(None, None),
+            plugin_runners_factory=platform.plugin_capability_runners,
             ui_file_response=ui_file_response,
             static_dir=static_dir,
         ),
@@ -356,6 +381,7 @@ def register_health_and_model_routers(
     create_models_router: Any,
     model_router: Any,
     require_user: Any,
+    require_admin: Any,
     load_users: Any,
     get_user_role: Any,
     install_engine: Any,
@@ -391,6 +417,7 @@ def register_health_and_model_routers(
         create_models_router(
             model_router=model_router,
             require_user=require_user,
+            require_admin=require_admin,
             get_current_user=get_current_user,
             load_users=load_users,
             get_user_role=get_user_role,
@@ -469,6 +496,7 @@ def register_interaction_routers(
         require_user = interaction_context.require_user
         embedding_info = interaction_context.embedding_info
         tool_context = interaction_context.tool_context
+        require_admin = tool_context.require_admin
         get_current_user = tool_context.get_current_user
         append_audit_event = tool_context.append_audit_event
         hooks = interaction_context.hooks
@@ -515,11 +543,13 @@ def register_interaction_routers(
         create_hooks_router(
             registry=hooks,
             require_user=require_user,
+            require_admin=require_admin,
             append_audit_event=append_audit_event,
         ),
         create_agent_registry_router(
             registry=agent_registry,
             require_user=require_user,
+            require_admin=require_admin,
             append_audit_event=append_audit_event,
         ),
         create_memory_router(
@@ -546,6 +576,7 @@ def register_review_and_brain_tail_routers(
     append_audit_event: Any,
     create_browser_router: Any,
     ingestion_pipeline: Any,
+    workspace_service: Any,
     create_portability_router: Any,
     kg_portability: Any,
     require_admin: Any,
@@ -573,6 +604,7 @@ def register_review_and_brain_tail_routers(
         create_browser_router(
             pipeline=ingestion_pipeline,
             require_user=require_user,
+            workspace_service=workspace_service,
         ),
         create_portability_router(
             service=kg_portability,
@@ -591,6 +623,7 @@ def register_review_and_brain_tail_routers(
             network=brain_network,
             identity=device_identity,
             require_user=require_user,
+            require_admin=require_admin,
         ),
         create_garden_router(gardener=gardener, require_user=require_user),
         create_setup_router(model_router=model_router, require_user=require_user),