ltcai 8.9.0 → 9.1.0

package/latticeai/runtime/automation_runtime.py

@@ -27,25 +27,40 @@ def build_automation_runtime(
     from latticeai.services.triggers import TriggerService
 
     review_queue = ReviewQueueService(store=store)
+
+    def _run_triggered_workflow(workflow_id: str, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        trigger = (inputs or {}).get("__trigger__") or {}
+        return platform.run_workflow_by_id(
+            workflow_id,
+            trigger.get("user_email"),
+            trigger.get("workspace_id"),
+            with_agent=True,
+            inputs=inputs,
+        )
+
     trigger_service = TriggerService(
         store=store,
-        run_workflow=lambda wf_id, inputs: platform.run_workflow_by_id(
-            wf_id,
-            None,
-            None,
-            with_agent=False,
-            inputs=inputs,
-        ),
+        run_workflow=_run_triggered_workflow,
         data_dir=data_dir,
         review_sink=review_queue,
         tz_name=tz_name,
     )
+
+    def _memory_ingest(**kwargs):
+        try:
+            # Delegate to store's upsert (enriches memories + KG automatically via internal graph.ingest_event)
+            return store.upsert_memory(**kwargs)
+        except Exception:
+            return None
+
     agent_runtime = AgentRuntime(
         store=store,
         orchestrator_factory=platform.build_orchestrator,
         workspace_graph=workspace_graph,
         append_audit_event=append_audit_event,
         hooks=hooks,
+        memory_ingest=_memory_ingest,
+        review_sink=review_queue,
     )
     run_executor = RunExecutor(
         store=store,

package/latticeai/runtime/brain_runtime.py

@@ -2,7 +2,17 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict
+from dataclasses import dataclass
+from typing import Any
+
+from latticeai.runtime.stages import RuntimeStage
+
+
+@dataclass(frozen=True)
+class BrainRuntime(RuntimeStage):
+    BRAIN_CORE: Any
+    KNOWLEDGE_GRAPH: Any
+    CONVERSATIONS: Any
 
 
 def build_brain_runtime(
@@ -12,7 +22,7 @@ def build_brain_runtime(
     enable_graph: bool,
     embedder: Any,
     storage_engine: Any,
-) -> Dict[str, Any]:
+) -> BrainRuntime:
     """Construct Brain Core storage/conversation primitives behind one seam."""
 
     from lattice_brain import BrainCore, ConversationStore
@@ -33,9 +43,11 @@ def build_brain_runtime(
         else ConversationStore(data_dir / "knowledge_graph.sqlite")
     )
     conversations.import_legacy_json(history_file)
-    return {
-        "BRAIN_CORE": brain_core,
-        "KNOWLEDGE_GRAPH": knowledge_graph,
-        "CONVERSATIONS": conversations,
-    }
+    return BrainRuntime(
+        BRAIN_CORE=brain_core,
+        KNOWLEDGE_GRAPH=knowledge_graph,
+        CONVERSATIONS=conversations,
+    )
+
 
+__all__ = ["BrainRuntime", "build_brain_runtime"]

package/latticeai/runtime/chat_wiring.py

@@ -56,6 +56,7 @@ def build_interaction_contexts(
     install_mcp: Any,
     mcp_public_item: Any,
     hooks: Any,
+    workspace_service: Any,
     chat_context: Any,
     search_service: Any,
     allowed_workspaces_for: Any,
@@ -89,6 +90,7 @@ def build_interaction_contexts(
         install_mcp=install_mcp,
         mcp_public_item=mcp_public_item,
         hooks=hooks,
+        workspace_service=workspace_service,
         allowed_workspaces_for=allowed_workspaces_for,
     )
     interaction_router_context = InteractionRouterContext(

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/history_runtime.py

@@ -0,0 +1,163 @@
+"""Conversation-history query/clear seam extracted from the app factory.
+
+The read and clear helpers (scope resolution, ``get_history``, conversation
+grouping, and the clear operations) used to be defined inline in
+``app_factory._build``. They are behaviour-preserving closures over the durable
+conversation store and the workspace service; moving them here keeps the factory
+a wiring path. Names are returned unchanged for the legacy ``server_app``
+compatibility namespace.
+
+Note: ``save_to_history`` (the *write* path) stays in the factory — it is bound
+up with redaction, audit, and the ingestion pipeline that are assembled around
+it — so only the query/clear side moves here.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional
+
+
+def build_history_query_runtime(
+    *,
+    conversations: Any,
+    workspace_service: Any,
+    require_auth: bool,
+    logging: Any,
+) -> Dict[str, Any]:
+    """Return the history scope/query/clear helpers as a name → callable dict."""
+
+    def _history_allowed_workspaces_for(user_email: Optional[str]):
+        if not require_auth or not user_email:
+            return None
+        try:
+            return set(workspace_service.readable_workspaces(user_email))
+        except Exception as exc:
+            logging.warning("history workspace scope resolution failed for %s: %s", user_email, exc)
+            return set()
+
+    def _history_include_legacy_global(user_email: Optional[str]) -> bool:
+        return not require_auth or not user_email
+
+    def get_history(
+        user_email: Optional[str] = None,
+        allowed_workspaces=None,
+        include_legacy_global: Optional[bool] = None,
+    ):
+        try:
+            if allowed_workspaces is None and user_email:
+                allowed_workspaces = _history_allowed_workspaces_for(user_email)
+            if include_legacy_global is None:
+                include_legacy_global = _history_include_legacy_global(user_email)
+            return conversations.history(
+                user_email=user_email,
+                allowed_workspaces=allowed_workspaces,
+                include_legacy_global=include_legacy_global,
+            )
+        except Exception as e:
+            logging.warning("get_history failed: %s", e)
+            return []
+
+    def conversation_title(item: Dict) -> str:
+        content = str(item.get("content") or "").strip()
+        content = re.sub(r"\s+", " ", content)
+        return content[:48] or "새 대화"
+
+    def group_history_conversations(history: Optional[List[Dict]] = None) -> List[Dict]:
+        history = history if history is not None else get_history()
+        grouped: Dict[str, Dict] = {}
+        order: List[str] = []
+
+        for index, item in enumerate(history):
+            conv_id = item.get("conversation_id")
+            if not conv_id:
+                conv_id = "legacy-previous-history"
+
+            if conv_id not in grouped:
+                grouped[conv_id] = {
+                    "id": conv_id,
+                    "title": "이전 대화 기록" if conv_id == "legacy-previous-history" else conversation_title(item),
+                    "created_at": item.get("timestamp"),
+                    "updated_at": item.get("timestamp"),
+                    "message_count": 0,
+                    "last_message": "",
+                    "source": item.get("source"),
+                }
+                order.append(conv_id)
+
+            conv = grouped[conv_id]
+            conv["message_count"] += 1
+            conv["updated_at"] = item.get("timestamp") or conv.get("updated_at")
+            conv["last_message"] = conversation_title(item)
+            if conv_id != "legacy-previous-history" and item.get("role") == "user" and (not conv.get("title") or conv["title"] == "새 대화"):
+                conv["title"] = conversation_title(item)
+
+        return sorted((grouped[key] for key in order), key=lambda item: item.get("updated_at") or "", reverse=True)
+
+    def get_conversation_messages(
+        conversation_id: str,
+        *,
+        user_email: Optional[str] = None,
+        allowed_workspaces=None,
+        include_legacy_global: Optional[bool] = None,
+    ) -> List[Dict]:
+        history = get_history(
+            user_email=user_email,
+            allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        )
+        if conversation_id == "legacy-previous-history":
+            return [item for item in history if not item.get("conversation_id")]
+        return [item for item in history if item.get("conversation_id") == conversation_id]
+
+    def clear_history(
+        keep_last: int = 0,
+        *,
+        user_email: Optional[str] = None,
+        allowed_workspaces=None,
+        include_legacy_global: Optional[bool] = None,
+    ) -> Dict:
+        if allowed_workspaces is None and user_email:
+            allowed_workspaces = _history_allowed_workspaces_for(user_email)
+        if include_legacy_global is None:
+            include_legacy_global = _history_include_legacy_global(user_email)
+        return conversations.clear_all(
+            keep_last=keep_last,
+            user_email=user_email,
+            allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        )
+
+    def clear_conversation(
+        conversation_id: str,
+        started_at: Optional[str] = None,
+        *,
+        user_email: Optional[str] = None,
+        allowed_workspaces=None,
+        include_legacy_global: Optional[bool] = None,
+    ) -> Dict:
+        if allowed_workspaces is None and user_email:
+            allowed_workspaces = _history_allowed_workspaces_for(user_email)
+        if include_legacy_global is None:
+            include_legacy_global = _history_include_legacy_global(user_email)
+        return conversations.clear_conversation(
+            conversation_id,
+            started_at=started_at,
+            user_email=user_email,
+            allowed_workspaces=allowed_workspaces,
+            include_legacy_global=include_legacy_global,
+        )
+
+    return {
+        "_history_allowed_workspaces_for": _history_allowed_workspaces_for,
+        "_history_include_legacy_global": _history_include_legacy_global,
+        "get_history": get_history,
+        "conversation_title": conversation_title,
+        "group_history_conversations": group_history_conversations,
+        "get_conversation_messages": get_conversation_messages,
+        "clear_history": clear_history,
+        "clear_conversation": clear_conversation,
+    }
+
+
+__all__ = ["build_history_query_runtime"]

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

@@ -0,0 +1,163 @@
+"""Explicit runtime exports for the legacy :mod:`server_app` facade.
+
+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
+from typing import Any, Dict, Mapping
+
+
+@dataclass(frozen=True)
+class RuntimeBundle:
+    """Typed application assembly result and its five explicit stages."""
+
+    app: Any
+    CONFIG: Any
+    KNOWLEDGE_GRAPH: Any
+    INGESTION_PIPELINE: Any
+    AGENT_RUNTIME: Any
+    HOOKS_REGISTRY: Any
+    REVIEW_QUEUE: Any
+    AGENT_REGISTRY: Any
+    model_router: Any
+    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 {
+            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",
+    "_RATE_LIMIT_ENABLED",
+    "_SESSION_TTL",
+    "_TOOL_CATALOG_BRIEF",
+    "_TOOL_GOVERNANCE_DEFAULT",
+    "_agent_risk",
+    "_allowed_workspaces_for",
+    "_build_admin_audit_report",
+    "_build_sensitivity_report",
+    "_bytes_match_extension",
+    "_check_ip_rate_limit",
+    "_check_rate_limit",
+    "_check_tool_role",
+    "_classify_sensitive_message",
+    "_client_ip",
+    "_create_security_router",
+    "_embedding_info",
+    "_fetch_skills_marketplace",
+    "_get_audit_log",
+    "_get_sso_discovery",
+    "_graph_stats_safe",
+    "_host_is_loopback",
+    "_list_compat_profiles",
+    "_llm_generate_sync",
+    "_product_hardening_status",
+    "_recent_chat_context",
+    "_redact_secret_text",
+    "_require_graph",
+    "_scoped_hybrid_search",
+    "_security_audit_events_safe",
+    "_security_list_uploaded_files",
+    "_spawn",
+    "_tool_response",
+    "_user_id_for_email",
+    "_workspace_graph",
+    "_workspace_models_payload",
+    "_workspace_scope_from_request",
+    "_workspace_settings_payload",
+}
+
+LEGACY_PUBLIC_EXPORTS = {
+    "ENGINE_MODEL_CATALOG",
+    "TOOL_GOVERNANCE",
+    "enforce_rate_limit",
+    "filter_lower_family_versions",
+    "hash_password",
+    "normalize_local_model_request",
+    "verify_password",
+}
+
+
+def build_runtime_namespace(
+    *, runtime_bundle: RuntimeBundle | Mapping[str, Any], legacy_exports: Mapping[str, Any]
+) -> Dict[str, Any]:
+    """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 = 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
+        value = legacy_exports.get(name)
+        if value is None:
+            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__ = [
+    "LEGACY_UNDERSCORE_EXPORTS",
+    "LEGACY_PUBLIC_EXPORTS",
+    "RUNTIME_BUNDLE_EXPORTS",
+    "RuntimeBundle",
+    "SERVER_APP_EXPORTS",
+    "build_runtime_namespace",
+]