ltcai 11.5.2 → 11.7.0

package/latticeai/runtime/context_runtime.py

@@ -1,66 +0,0 @@
-"""Retrieval/context runtime assembly for app startup."""
-
-from __future__ import annotations
-
-from typing import Any, Callable, Dict
-
-
-def build_context_runtime(
-    *,
-    graph_store: Any,
-    ingestion_pipeline: Any,
-    memory_service: Any,
-    gardener: Any,
-    require_auth: bool,
-    allowed_scopes_for_user: Callable[[Any], Any],
-    artifact_ledger: Any = None,
-) -> Dict[str, Any]:
-    """Construct search, brain memory, and context assembly services."""
-
-    from lattice_brain.context import ContextAssembler
-    from lattice_brain.memory import BrainMemory
-    from latticeai.services.search_service import SearchService
-
-    search_service = SearchService(graph_store=graph_store)
-    brain_memory = BrainMemory(ingestion_pipeline)
-
-    def scoped_hybrid_search(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 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)
-
-    # Re-search loop (v9.9.6): files this conversation just produced are a
-    # deterministic context section, so "그 파일에 다크모드 넣어줘" works before
-    # asynchronous indexing catches up. Optional — absent ledger, absent section.
-    if artifact_ledger is None:
-        from latticeai.core.artifact_ledger import ArtifactLedger
-
-        artifact_ledger = ArtifactLedger()
-
-    context_assembler = ContextAssembler(
-        memory_recall=memory_service.recall,
-        hybrid_search=scoped_hybrid_search,
-        notes_context=scoped_notes_context,
-        recent_artifacts=artifact_ledger.recent,
-    )
-
-    return {
-        "SEARCH_SERVICE": search_service,
-        "BRAIN_MEMORY": brain_memory,
-        "CONTEXT_ASSEMBLER": context_assembler,
-        "ARTIFACT_LEDGER": artifact_ledger,
-        "_scoped_hybrid_search": scoped_hybrid_search,
-    }

package/latticeai/runtime/feature_toggle_wiring.py

@@ -1,157 +0,0 @@
-"""Wire the feature switchboard into the running app (v11.2.0).
-
-Same shape as ``permission_mode_wiring``: one process-wide service and an
-idempotent router mount guarded on ``app.state``. The rebinding rule that shape
-turns on — explicit arguments *rebind* an already-created service rather than
-being dropped, so a lazy first caller cannot pin the store to a fallback data
-dir with no audit sink — is shared, in
-:mod:`latticeai.runtime.service_singletons`.
-
-The one job unique to this module is :func:`bind_feature_gates`: it points each
-opt-in gate's resolver at the service, which is the step that turns a persisted
-preference into behaviour. Every gate is imported inside the function so
-importing this module costs nothing; ``lattice_brain.synthesis`` in particular
-drags in the graph layer.
-
-Unbinding is a supported operation (:func:`unbind_feature_gates`) because these
-gates are module-level singletons: a test that bound them must be able to give
-them back, and "the environment answers again" has to be reachable.
-"""
-
-from __future__ import annotations
-
-import threading
-from pathlib import Path
-from typing import Any, Callable, List, Optional, Tuple
-
-from latticeai.runtime.service_singletons import (
-    rebind_singleton,
-    singleton_data_dir,
-)
-from latticeai.services.feature_toggles import FeatureToggleService
-
-_LOCK = threading.Lock()
-_SHARED: Optional[FeatureToggleService] = None
-
-#: ``feature id -> (module, attribute)`` for every boolean gate. Resolved lazily
-#: by :func:`_boolean_gates` so the table stays readable next to the catalog it
-#: mirrors, and a rename that breaks the pairing fails loudly at wiring time.
-GATE_BINDINGS: Tuple[Tuple[str, str, str], ...] = (
-    ("allow_multimodal", "lattice_brain.ingestion", "MULTIMODAL_GATE"),
-    ("video_ingest", "lattice_brain.ingestion", "VIDEO_GATE"),
-    ("auto_vector_index", "lattice_brain.ingestion", "AUTO_VECTOR_INDEX_GATE"),
-    ("brain_network", "lattice_brain.portability", "BRAIN_NETWORK_GATE"),
-    ("synthesis", "lattice_brain.synthesis", "SYNTHESIS_GATE"),
-    ("fusion_rrf", "lattice_brain.graph.fusion", "FUSION_RRF_GATE"),
-    ("graph_expansion", "lattice_brain.graph.fusion", "GRAPH_EXPANSION_GATE"),
-    ("vault_watch", "latticeai.services.folder_watch", "VAULT_WATCH_GATE"),
-    ("auto_late_fusion", "latticeai.services.search_service", "IMAGE_QUERY_FUSION_GATE"),
-)
-
-#: The one non-boolean seam: the vector backend is a pick-one-of-three.
-CHOICE_FEATURE = "vector_backend"
-
-
-def _boolean_gates() -> List[Tuple[str, Any]]:
-    """``[(feature id, gate)]`` — imports are here, not at module import."""
-    from importlib import import_module
-
-    return [
-        (feature_id, getattr(import_module(module), attribute))
-        for feature_id, module, attribute in GATE_BINDINGS
-    ]
-
-
-def _bind_vector_index(resolver: Any) -> None:
-    from lattice_brain.graph.vector_index.selector import bind_vector_index_resolver
-
-    bind_vector_index_resolver(resolver)
-
-
-def get_feature_toggle_service(
-    *,
-    data_dir: Optional[Path] = None,
-    audit: Optional[Callable[..., None]] = None,
-) -> FeatureToggleService:
-    """Process-wide singleton; explicit arguments rebind an existing one."""
-    global _SHARED
-    with _LOCK:
-        if _SHARED is None:
-            _SHARED = FeatureToggleService(
-                data_dir=singleton_data_dir(data_dir),
-                audit=audit,
-            )
-            return _SHARED
-        return rebind_singleton(_SHARED, data_dir=data_dir, audit=audit)
-
-
-def bind_feature_gates(service: Optional[FeatureToggleService] = None) -> None:
-    """Point every opt-in gate at the switchboard.
-
-    After this, a persisted preference beats the environment variable for every
-    feature in the catalog — which is the whole point, since the panel is the
-    only control surface most people will ever use.
-    """
-    resolved = service or get_feature_toggle_service()
-    for feature_id, gate in _boolean_gates():
-        # ``gate.local`` is the fallback on purpose: the switchboard speaks only
-        # for switches this person actually moved. Everything else still answers
-        # from the gate's own override → env → default, so binding changes
-        # nothing at all for an install that never opened the panel.
-        gate.bind(resolved.resolver(feature_id, gate.local))
-    _bind_vector_index(resolved.choice_resolver(CHOICE_FEATURE))
-
-
-def unbind_feature_gates() -> None:
-    """Hand every gate back to its environment variable."""
-    for _feature_id, gate in _boolean_gates():
-        gate.bind(None)
-    _bind_vector_index(None)
-
-
-def reset_feature_toggle_service() -> None:
-    """Drop the singleton *and* the bindings that pointed at it (tests)."""
-    global _SHARED
-    unbind_feature_gates()
-    with _LOCK:
-        _SHARED = None
-
-
-def register_features_router(
-    app: Any,
-    *,
-    require_user: Callable[..., str],
-    data_dir: Optional[Path] = None,
-    append_audit_event: Optional[Callable[..., None]] = None,
-) -> FeatureToggleService:
-    """Install GET/POST /api/features on ``app`` and bind the gates. Idempotent.
-
-    The guard is a flag on ``app.state`` rather than a scan of route paths: a
-    router included through fastapi >= 0.140 has no flat ``path`` to introspect,
-    so path scanning silently stopped seeing the mount (see
-    ``permission_mode_wiring`` for the same note).
-    """
-    from latticeai.api.features import create_features_router
-
-    service = get_feature_toggle_service(data_dir=data_dir, audit=append_audit_event)
-    bind_feature_gates(service)
-    state = getattr(app, "state", None)
-    if state is not None and getattr(state, "_ltcai_features_mounted", False):
-        return service
-    app.include_router(
-        create_features_router(service=service, require_user=require_user)
-    )
-    if state is not None:
-        state._ltcai_features_mounted = True
-    return service
-
-
-__all__ = [
-    "CHOICE_FEATURE",
-    "GATE_BINDINGS",
-    "bind_feature_gates",
-    "get_feature_toggle_service",
-    "register_features_router",
-    "reset_feature_toggle_service",
-    "unbind_feature_gates",
-]

package/latticeai/runtime/history_runtime.py

@@ -1,163 +0,0 @@
-"""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):  # noqa: B007 — index documents the enumerate contract for readers
-            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/history_writer.py

@@ -1,138 +0,0 @@
-"""Persisting one chat turn: redact, audit, store, then grow the Brain.
-
-Extracted from the `app_factory._build` closure in 10.3.0. It was 66 lines
-deep inside a 1,343-line composition root, which meant the one function that
-decides what a chat message looks like *after* redaction — and what the audit
-log records about it — could not be exercised without standing up the whole
-application.
-
-The order here is the contract, and it is deliberate:
-
-1. **Redact first.** Everything downstream (the audit preview, the durable
-   store, the knowledge graph) sees the redacted text, never the original.
-2. **Audit before storing.** The audit row carries a masked preview and the
-   sensitivity verdict, so a message that should not have been sent is
-   visible in the log even if the store write later fails.
-3. **Ingest through the pipeline, not the store.** Chat messages enter the
-   Brain the same way files and web pages do, so they get provenance and the
-   hook lifecycle rather than a direct write that bypasses both.
-4. **A failed ingest does not lose the message.** Graph growth is best-effort;
-   the conversation store is not.
-"""
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any, Callable, Dict, Optional
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class HistoryWriterDeps:
-    """Everything one chat turn needs, injected so this is testable in isolation."""
-
-    conversations: Any
-    append_audit_event: Callable[..., None]
-    classify_sensitive_message: Callable[[Dict[str, Any], int], Dict[str, Any]]
-    redact_secret_text: Callable[[str], str]
-    normalize_branding: Callable[[str], str]
-    ingestion_pipeline: Any = None
-    ingestion_item_factory: Any = None
-    enable_graph: bool = False
-    knowledge_graph: Any = None
-
-
-def write_chat_turn(
-    role: str,
-    message: str,
-    *,
-    user_email: Optional[str] = None,
-    user_nickname: Optional[str] = None,
-    source: Optional[str] = None,
-    conversation_id: Optional[str] = None,
-    workspace_id: Optional[str] = None,
-    deps: HistoryWriterDeps,
-) -> None:
-    """Persist one chat turn. Never raises: a failure here must not lose a reply."""
-    redact_secret_text = deps.redact_secret_text
-    normalize_branding = deps.normalize_branding
-    classify_sensitive_message = deps.classify_sensitive_message
-    append_audit_event = deps.append_audit_event
-    conversations = deps.conversations
-    ingestion_pipeline = deps.ingestion_pipeline
-    ingestion_item_factory = deps.ingestion_item_factory
-    enable_graph = deps.enable_graph
-    knowledge_graph = deps.knowledge_graph
-
-    try:
-        # 1. Redact before anything else sees the text.
-        message = redact_secret_text(message)
-        if role == "assistant":
-            message = normalize_branding(message)
-
-        item: Dict[str, Any] = {
-            "role": role,
-            "content": message,
-            "timestamp": datetime.now().isoformat(),
-        }
-        for key, value in (
-            ("user_email", user_email),
-            ("user_nickname", user_nickname),
-            ("source", source),
-            ("conversation_id", conversation_id),
-            ("workspace_id", workspace_id),
-        ):
-            if value:
-                item[key] = value
-
-        # 2. Audit carries a masked preview and the verdict, never the body.
-        sensitive = classify_sensitive_message(item, -1)
-        append_audit_event(
-            "chat_message",
-            role=role,
-            user_email=user_email,
-            user_nickname=user_nickname,
-            source=source,
-            conversation_id=conversation_id,
-            workspace_id=workspace_id,
-            content_preview=sensitive.get("preview"),
-            content_chars=len(message or ""),
-            sensitivity=sensitive.get("sensitivity"),
-            sensitive_labels=sensitive.get("labels") or [],
-        )
-
-        # 3. Durable episodic memory. Unbounded SQLite; the old 50-message
-        #    chat_history.json cap is gone.
-        conversations.append(item)
-
-        # 4. Best-effort Brain growth through the unified pipeline.
-        if enable_graph and knowledge_graph and ingestion_pipeline and ingestion_item_factory:
-            try:
-                ingestion_pipeline.ingest(
-                    ingestion_item_factory(
-                        source_type="chat_message",
-                        text=message,
-                        owner=user_email,
-                        workspace_id=workspace_id,
-                        conversation_id=conversation_id,
-                        metadata={
-                            "role": role,
-                            "user_nickname": user_nickname,
-                            "source": source,
-                            "raw": item,
-                        },
-                    ),
-                    user_email=user_email,
-                )
-            except Exception as graph_error:  # noqa: BLE001
-                # The message is already stored; a graph failure must not
-                # look like a lost turn.
-                logger.warning("knowledge graph message ingest failed: %s", graph_error)
-    except Exception as exc:  # noqa: BLE001
-        logger.warning("save_to_history failed: %s", exc)
-
-
-__all__ = ["HistoryWriterDeps", "write_chat_turn"]

package/latticeai/runtime/hooks_runtime.py

@@ -1,77 +0,0 @@
-"""Hooks + local-knowledge watcher runtime assembly for app startup.
-
-Extracted from ``app_factory._build`` as a composition seam: the hooks
-registry must be constructed *ahead* of the local-knowledge watcher so
-folder-watch reindexes can fire the ``pre_index``/``post_index`` lifecycle
-hooks. Heavy imports stay inside the function so importing the module has no
-side effects.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Callable, Dict
-
-
-def build_hooks_runtime(
-    *,
-    data_dir: Any,
-    enable_graph: bool,
-    knowledge_graph_getter: Callable[[], Any],
-) -> Dict[str, Any]:
-    """Construct the hooks registry and local-knowledge watcher behind one seam."""
-
-    from lattice_brain.runtime.hooks import HooksRegistry
-    from latticeai.services.local_knowledge import LocalKnowledgeWatcher
-
-    hooks_registry = HooksRegistry(data_dir / "hooks.json")
-    local_kg_watcher = (
-        LocalKnowledgeWatcher(knowledge_graph_getter, hooks=hooks_registry)
-        if enable_graph
-        else None
-    )
-    return {
-        "HOOKS_REGISTRY": hooks_registry,
-        "LOCAL_KG_WATCHER": local_kg_watcher,
-    }
-
-
-def bind_trigger_hook_runner(*, registry: Any, trigger_service: Any) -> str:
-    """Ensure the brain-event trigger hook exists and bind its runtime runner."""
-
-    from latticeai.services.triggers import TRIGGER_HOOK_NAME
-
-    trigger_hook_id = next(
-        (
-            h.get("id")
-            for h in registry._state.get("custom", [])
-            if h.get("name") == TRIGGER_HOOK_NAME
-        ),
-        None,
-    )
-    if trigger_hook_id is None:
-        trigger_hook_id = registry.register(
-            name=TRIGGER_HOOK_NAME,
-            kind="post_tool",
-            description="Fires brain_event workflow triggers when knowledge enters the brain.",
-        )["id"]
-    registry.register_hook(trigger_hook_id, trigger_service.hook_runner())
-    return trigger_hook_id
-
-
-def bind_builtin_hook_runners(
-    *,
-    registry: Any,
-    append_audit_event: Callable[..., Any],
-    get_tool_permission: Callable[..., Any],
-    classify_sensitive_message: Callable[..., Any],
-) -> None:
-    """Bind concrete platform runners for built-in hook definitions."""
-
-    from latticeai.core.builtin_hooks import register_builtin_hook_runners
-
-    register_builtin_hook_runners(
-        registry,
-        append_audit_event=append_audit_event,
-        get_tool_permission=get_tool_permission,
-        classify_sensitive_message=classify_sensitive_message,
-    )

package/latticeai/runtime/model_wiring.py

@@ -1,68 +0,0 @@
-"""Model/runtime wiring seam for ``latticeai.app_factory``."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any
-
-from latticeai.runtime.platform_services_runtime import build_model_service
-
-
-@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(
-    *,
-    app: Any,
-    create_health_router: Any,
-    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,
-) -> ModelRuntime:
-    model_service = build_model_service(
-        model_router=model_router,
-        runtime_features=runtime_features,
-        is_public=is_public_mode,
-    )
-    register_health_and_model_routers(
-        app,
-        create_health_router=create_health_router,
-        model_service=model_service,
-        create_models_router=create_models_router,
-        model_router=model_router,
-        is_public_mode=is_public_mode,
-        **kwargs,
-    )
-    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",
-]