ltcai 9.0.0 → 9.2.0

package/latticeai/integrations/telegram_bot.py

@@ -5,11 +5,11 @@ import base64
 import os
 import socket
 import tempfile
-import time
 import zipfile
 import json
 from pathlib import Path
 
+from latticeai.core.io_utils import atomic_write_json
 from latticeai.core.logging_safety import install_sensitive_log_filter, safe_log_text
 from latticeai.cli.runtime import _load_env_file
 
@@ -43,7 +43,7 @@ AGENT_WORKSPACE       = Path(env_value("LATTICEAI_AGENT_ROOT", "agent_workspace"
 # Pending plan approvals: context_id → (chat_id, executing_model, reviewing_model)
 _bot_pending_plans: dict[str, dict] = {}
 MAX_TELEGRAM_FILE_BYTES = 45 * 1024 * 1024
-INVITE_CODE           = env_value("LATTICEAI_INVITE_CODE", "gemma-lattice-ai")
+INVITE_CODE           = env_value("LATTICEAI_INVITE_CODE")
 PUBLIC_WEB_URL        = env_value("LATTICEAI_PUBLIC_URL")
 DATA_DIR              = Path(env_value("LATTICEAI_DATA_DIR", str(Path.home() / ".ltcai")))
 DATA_DIR.mkdir(parents=True, exist_ok=True)
@@ -55,45 +55,56 @@ logger = logging.getLogger(__name__)
 # ── Server session auth ───────────────────────────────────────────────────────
 
 def _get_server_session() -> str:
-    """Read the most recent valid admin session from sessions.json (web login)."""
-    explicit_token = env_value("LATTICEAI_SERVER_SESSION_TOKEN")
-    if explicit_token:
-        return explicit_token
-    sessions_file = DATA_DIR / "sessions.json"
-    users_file = DATA_DIR / "users.json"
-    try:
-        if not sessions_file.exists():
-            return ""
-        sessions = json.loads(sessions_file.read_text())
-        admin_emails: set[str] = set()
-        if users_file.exists():
-            users = json.loads(users_file.read_text())
-            admin_emails = {e for e, u in users.items() if u.get("role") == "admin" and not u.get("disabled")}
-        now = time.time()
-        # Pick the newest non-expired admin session
-        best_token, best_ts = "", 0.0
-        for token, entry in sessions.items():
-            if len(token) == 64 and all(ch in "0123456789abcdef" for ch in token.lower()):
-                continue
-            email, created_at = entry[0], float(entry[1])
-            if admin_emails and email not in admin_emails:
-                continue
-            if now - created_at > 7 * 86400:
-                continue
-            if created_at > best_ts:
-                best_token, best_ts = token, created_at
-        return best_token
-    except Exception:
-        return ""
+    """Return only the explicitly provisioned bot-to-server token.
+
+    Web sessions are hashed at rest and belong to interactive users. Scanning
+    ``sessions.json`` cannot recover a usable token and would couple the bot to
+    whichever administrator happened to be logged in most recently.
+    """
+    return env_value("LATTICEAI_SERVER_SESSION_TOKEN").strip()
 
 def _server_client(**kwargs) -> httpx.AsyncClient:
-    """httpx client pre-loaded with the web session cookie."""
+    """Return a server client authenticated by an explicit bearer capability."""
     token = _get_server_session()
-    cookies = {"session_token": token} if token else {}
-    return httpx.AsyncClient(cookies=cookies, **kwargs)
+    if not token:
+        raise RuntimeError(
+            "LATTICEAI_SERVER_SESSION_TOKEN is required for Telegram server API calls."
+        )
+    headers = dict(kwargs.pop("headers", {}) or {})
+    headers["Authorization"] = f"Bearer {token}"
+    return httpx.AsyncClient(headers=headers, **kwargs)
 
 # ── Chat ID registry ─────────────────────────────────────────────────────────
 
+def parse_allowed_chat_ids(raw: str) -> frozenset[int]:
+    """Parse a comma-separated Telegram chat-id allowlist."""
+    allowed: set[int] = set()
+    for value in str(raw or "").split(","):
+        value = value.strip()
+        if not value:
+            continue
+        try:
+            allowed.add(int(value))
+        except ValueError:
+            logger.warning(
+                "Invalid Telegram chat id ignored in allowlist: %r",
+                safe_log_text(value),
+            )
+    return frozenset(allowed)
+
+
+def allowed_chat_ids() -> frozenset[int]:
+    """Return the configured allowlist; missing configuration denies all."""
+    return parse_allowed_chat_ids(env_value("LATTICEAI_TELEGRAM_ALLOWED_CHAT_IDS"))
+
+
+def is_chat_allowed(chat_id) -> bool:
+    try:
+        return int(chat_id) in allowed_chat_ids()
+    except (TypeError, ValueError):
+        return False
+
+
 def load_chat_ids():
     try:
         if CHAT_IDS_FILE.exists():
@@ -105,19 +116,24 @@ def load_chat_ids():
 
 def save_chat_ids(chat_ids):
     try:
-        CHAT_IDS_FILE.write_text(
-            json.dumps({"chat_ids": sorted(chat_ids)}, ensure_ascii=False, indent=2),
-            encoding="utf-8",
-        )
+        atomic_write_json(CHAT_IDS_FILE, {"chat_ids": sorted(chat_ids)})
     except Exception as e:
         logger.error("텔레그램 채팅 목록 저장 실패: %s", safe_log_text(e))
 
 def register_chat_id(chat_id):
+    if not is_chat_allowed(chat_id):
+        logger.warning(
+            "허용되지 않은 텔레그램 채팅 등록 차단: %s",
+            safe_log_text(chat_id),
+        )
+        return False
+    chat_id = int(chat_id)
     chat_ids = load_chat_ids()
     if chat_id not in chat_ids:
         chat_ids.add(chat_id)
         save_chat_ids(chat_ids)
         logger.info("텔레그램 웹 미러링 대상 등록: %s", chat_id)
+    return True
 
 # ── Telegram API helpers ──────────────────────────────────────────────────────
 
@@ -205,7 +221,8 @@ def get_lan_ip():
 def get_web_url():
     if PUBLIC_WEB_URL:
         return PUBLIC_WEB_URL.rstrip("/")
-    return f"http://{get_lan_ip()}:{SERVER_PORT}/?code={INVITE_CODE}"
+    base = f"http://{get_lan_ip()}:{SERVER_PORT}/"
+    return f"{base}?code={INVITE_CODE}" if INVITE_CODE else base
 
 def get_graph_url():
     if PUBLIC_WEB_URL:
@@ -217,7 +234,10 @@ def get_graph_url():
 async def broadcast_web_chat(role, text):
     if not TOKEN:
         return
-    chat_ids = load_chat_ids()
+    # Old releases registered every sender. Intersect persisted recipients
+    # with the current allowlist so stale files cannot keep receiving mirrors.
+    allowed = allowed_chat_ids()
+    chat_ids = load_chat_ids() & set(allowed)
     if not chat_ids:
         return
     label = "사용자" if role == "user" else "Lattice AI"
@@ -730,6 +750,14 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
     if len(parts) != 3:
         return
     _, action, context_id = parts
+    pending = _bot_pending_plans.get(context_id)
+
+    # A callback is bound to the chat that received the plan. Even two allowed
+    # chats cannot approve or cancel each other's plan by replaying callback
+    # data.
+    if pending and int(pending.get("chat_id")) != int(chat_id):
+        await send_message(client, chat_id, "❌ 다른 채팅의 작업은 처리할 수 없습니다.")
+        return
     pending = _bot_pending_plans.pop(context_id, None)
 
     if action == "cancel" or not pending:
@@ -870,10 +898,17 @@ async def handle_command(client, chat_id, command: str, args: str):
 # ── Callback query handler ────────────────────────────────────────────────────
 
 async def handle_callback_query(client, callback_query):
-    cq_id   = callback_query["id"]
-    chat_id = callback_query["message"]["chat"]["id"]
+    cq_id = callback_query.get("id", "")
+    chat_id = (
+        (callback_query.get("message") or {}).get("chat") or {}
+    ).get("id")
     data    = callback_query.get("data", "")
 
+    if not is_chat_allowed(chat_id):
+        logger.warning("허용되지 않은 텔레그램 callback 차단: %s", safe_log_text(chat_id))
+        await answer_callback(client, cq_id, "허용되지 않은 채팅입니다.")
+        return
+
     await answer_callback(client, cq_id)
 
     if data == "cmd:status":
@@ -907,6 +942,16 @@ async def run_bot():
     if not TOKEN:
         logger.warning("LATTICEAI_TELEGRAM_BOT_TOKEN이 설정되지 않아 텔레그램 봇을 시작하지 않습니다.")
         return
+    if not allowed_chat_ids():
+        logger.error(
+            "LATTICEAI_TELEGRAM_ALLOWED_CHAT_IDS가 없어 텔레그램 봇을 시작하지 않습니다."
+        )
+        return
+    if not _get_server_session():
+        logger.error(
+            "LATTICEAI_SERVER_SESSION_TOKEN이 없어 텔레그램 봇을 시작하지 않습니다."
+        )
+        return
 
     logger.info("🚀 비동기 텔레그램 봇 모드 시작!")
     last_update_id = None
@@ -942,6 +987,12 @@ async def run_bot():
 
                     msg     = update["message"]
                     chat_id = msg["chat"]["id"]
+                    if not is_chat_allowed(chat_id):
+                        logger.warning(
+                            "허용되지 않은 텔레그램 메시지 차단: %s",
+                            safe_log_text(chat_id),
+                        )
+                        continue
                     register_chat_id(chat_id)
                     text    = msg.get("text", "")
                     caption = msg.get("caption", "")

package/latticeai/models/router.py

@@ -261,11 +261,13 @@ class LLMRouter:
 
     @property
     def current_model_id(self) -> Optional[str]:
-        return self._current
+        with self._lock:
+            return self._current
 
     @property
     def loaded_model_ids(self) -> List[str]:
-        return list(self._cache.keys())
+        with self._lock:
+            return list(self._cache.keys())
 
     def switch_model(self, model_id: str) -> None:
         with self._lock:
@@ -302,11 +304,12 @@ class LLMRouter:
         return unloaded
 
     def model_memory_policy(self) -> Dict[str, object]:
-        return {
-            "max_local_models": self._max_local_models,
-            "loaded_count": len(self._cache),
-            "last_used": dict(self._last_used),
-        }
+        with self._lock:
+            return {
+                "max_local_models": self._max_local_models,
+                "loaded_count": len(self._cache),
+                "last_used": dict(self._last_used),
+            }
 
     def _touch(self, model_id: Optional[str] = None) -> None:
         model_id = model_id or self._current
@@ -478,7 +481,8 @@ class LLMRouter:
         return items
 
     def _is_cloud_current(self) -> bool:
-        return bool(self._current and isinstance(self._cache.get(self._current), CloudModel))
+        with self._lock:
+            return bool(self._current and isinstance(self._cache.get(self._current), CloudModel))
 
     def _local_server_error_hint(self, cloud: CloudModel, error: Exception) -> str:
         raw = str(error)
@@ -532,28 +536,62 @@ class LLMRouter:
         loader_kind = str(cached[3]) if len(cached) > 3 else "mlx_vlm"
         return model, tokenizer, draft_model, loader_kind
 
-    async def generate_as(self, model_id: str | None, message: str, context: Optional[str] = None, max_tokens: int = 4096, temperature: float = 0.2) -> str:
-        """Generate using a specific model, temporarily switching if needed. Falls back to current model if model_id is None or not loaded."""
-        if not model_id or model_id == self._current:
-            return await self.generate(message, context, max_tokens, temperature)
-        if model_id not in self._cache:
-            raise ValueError(f"Model '{model_id}' is not loaded. Load it first via /models/load.")
-        prev = self._current
-        self._current = model_id
-        try:
-            return await self.generate(message, context, max_tokens, temperature)
-        finally:
-            self._current = prev
+    def _model_snapshot(self, model_id: Optional[str] = None) -> tuple[Optional[str], object | None]:
+        """Return an immutable request-scoped view of a loaded model.
 
-    async def generate(self, message: str, context: Optional[str] = None, max_tokens: int = 4096, temperature: float = 0.2, image_data: Optional[str] = None) -> str:
-        if not self._current:
+        Generation must never change ``_current``: that value is a UI/default
+        preference shared by every request.  Capturing the cache entry while
+        holding the registry lock prevents concurrent requests from selecting
+        or restoring each other's models.
+        """
+        with self._lock:
+            selected = model_id or self._current
+            if not selected:
+                return None, None
+            cached = self._cache.get(selected)
+            if cached is None:
+                raise ValueError(f"Model '{selected}' is not loaded. Load it first via /models/load.")
+            self._touch(selected)
+            return selected, cached
+
+    async def generate_as(
+        self,
+        model_id: str | None,
+        message: str,
+        context: Optional[str] = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.2,
+        image_data: Optional[str] = None,
+    ) -> str:
+        """Generate with a request-scoped model without changing the default."""
+        _selected, cached = self._model_snapshot(model_id)
+        if cached is None:
             return "No model."
-        self._touch()
-        cached = self._cache[self._current]
+        return await self._generate_cached(cached, message, context, max_tokens, temperature, image_data)
+
+    async def generate(
+        self,
+        message: str,
+        context: Optional[str] = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.2,
+        image_data: Optional[str] = None,
+    ) -> str:
+        return await self.generate_as(None, message, context, max_tokens, temperature, image_data)
+
+    async def _generate_cached(
+        self,
+        cached: object,
+        message: str,
+        context: Optional[str],
+        max_tokens: int,
+        temperature: float,
+        image_data: Optional[str],
+    ) -> str:
         if isinstance(cached, CloudModel):
             return await self._cloud_generate(cached, message, context, max_tokens, temperature)
 
-        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(self._cache[self._current])
+        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(cached)
         use_vlm = loader_kind == "mlx_vlm"
         prompt = (
             self._build_vlm_prompt(model, tokenizer, message, context, 1 if image_data else 0)
@@ -596,18 +634,26 @@ class LLMRouter:
             raise RuntimeError(self._local_server_error_hint(cloud, e)) from e
         return normalize_branding(response.choices[0].message.content or "")
 
-    async def stream_generate(self, message: str, context: Optional[str] = None, max_tokens: int = 4096, temperature: float = 0.2, image_data: Optional[str] = None) -> AsyncIterator[str]:
-        if not self._current:
+    async def stream_generate_as(
+        self,
+        model_id: str | None,
+        message: str,
+        context: Optional[str] = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.2,
+        image_data: Optional[str] = None,
+    ) -> AsyncIterator[str]:
+        """Stream with a request-scoped model without changing the default."""
+        _selected, cached = self._model_snapshot(model_id)
+        if cached is None:
             yield "No model."
             return
-        self._touch()
-        cached = self._cache[self._current]
         if isinstance(cached, CloudModel):
             async for chunk in self._cloud_stream_generate(cached, message, context, max_tokens, temperature):
                 yield chunk
             return
 
-        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(self._cache[self._current])
+        model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(cached)
         use_vlm = loader_kind == "mlx_vlm"
         prompt = (
             self._build_vlm_prompt(model, tokenizer, message, context, 1 if image_data else 0)
@@ -643,6 +689,19 @@ class LLMRouter:
                 break
             yield normalize_branding(chunk)
 
+    async def stream_generate(
+        self,
+        message: str,
+        context: Optional[str] = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.2,
+        image_data: Optional[str] = None,
+    ) -> AsyncIterator[str]:
+        async for chunk in self.stream_generate_as(
+            None, message, context, max_tokens, temperature, image_data
+        ):
+            yield chunk
+
     async def _cloud_stream_generate(self, cloud: CloudModel, message: str, context: Optional[str], max_tokens: int, temperature: float) -> AsyncIterator[str]:
         system = SYSTEM_PROMPT
         context = normalize_branding(context)
@@ -691,10 +750,27 @@ class LLMRouter:
         temperature: float = 0.3,
     ) -> str:
         """Generate a document using a specialized system prompt with graph context."""
-        if not self._current:
+        return await self.generate_document_as(
+            None,
+            message,
+            system_prompt,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+
+    async def generate_document_as(
+        self,
+        model_id: str | None,
+        message: str,
+        system_prompt: str,
+        *,
+        max_tokens: int = 8192,
+        temperature: float = 0.3,
+    ) -> str:
+        """Generate a document with a request-scoped model."""
+        _selected, cached = self._model_snapshot(model_id)
+        if cached is None:
             return "No model loaded."
-        self._touch()
-        cached = self._cache[self._current]
 
         if isinstance(cached, CloudModel):
             return await self._cloud_generate_document(cached, message, system_prompt, max_tokens, temperature)
@@ -750,11 +826,29 @@ class LLMRouter:
         temperature: float = 0.3,
     ) -> AsyncIterator[str]:
         """Stream document generation with specialized system prompt."""
-        if not self._current:
+        async for chunk in self.stream_generate_document_as(
+            None,
+            message,
+            system_prompt,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        ):
+            yield chunk
+
+    async def stream_generate_document_as(
+        self,
+        model_id: str | None,
+        message: str,
+        system_prompt: str,
+        *,
+        max_tokens: int = 8192,
+        temperature: float = 0.3,
+    ) -> AsyncIterator[str]:
+        """Stream a document with a request-scoped model."""
+        _selected, cached = self._model_snapshot(model_id)
+        if cached is None:
             yield "No model loaded."
             return
-        self._touch()
-        cached = self._cache[self._current]
 
         if isinstance(cached, CloudModel):
             async for chunk in self._cloud_stream_document(cached, message, system_prompt, max_tokens, temperature):

package/latticeai/runtime/access_runtime.py

@@ -20,9 +20,23 @@ def build_access_runtime(
     from latticeai.core.policy import normalize_role, require_capability
     from latticeai.core.users import normalize_email
 
+    # The historical loopback/no-auth profile represents its single human as
+    # an empty identity.  Keep that storage/workspace compatibility contract,
+    # but project the identity as an owner at authorization boundaries.  Never
+    # extend this trust to public or non-loopback bindings, even if an invalid
+    # caller constructs this runtime with ``require_auth=False`` directly.
+    externally_reachable = bool(
+        getattr(config, "is_public", False)
+        or getattr(config, "network_exposed", False)
+    )
+    trusted_local_owner = not require_auth and not externally_reachable
+    effective_require_auth = bool(require_auth or externally_reachable)
+
     def get_user_role(email: str, users: Optional[Dict] = None) -> str:
         users = users or load_users()
         identity = str(email or "")
+        if trusted_local_owner and not identity:
+            return "owner"
         normalized_email = normalize_email(identity)
         user = users.get(normalized_email) or users.get(identity) or next(
             (
@@ -46,25 +60,69 @@ def build_access_runtime(
             return auth[7:].strip()
         return request.cookies.get("session_token")
 
+    def active_session_email(identity: Optional[str], users: Dict) -> Optional[str]:
+        """Resolve a session identity only while its account remains active."""
+        if not identity:
+            return None
+        raw_identity = str(identity)
+        normalized_email = normalize_email(raw_identity)
+        matched_key: Optional[str] = None
+        user = users.get(normalized_email)
+        if isinstance(user, dict):
+            matched_key = normalized_email
+        else:
+            user = users.get(raw_identity)
+            if isinstance(user, dict):
+                matched_key = raw_identity
+            else:
+                for key, item in users.items():
+                    if isinstance(item, dict) and item.get("id") == raw_identity:
+                        matched_key = str(key)
+                        user = item
+                        break
+        # A session for a deleted account, malformed account record, or an
+        # explicitly disabled account is invalid immediately. This check is
+        # intentionally performed on every request so stale bearer/cookie
+        # tokens cannot retain user or administrator access.
+        if not matched_key or not isinstance(user, dict) or bool(user.get("disabled", False)):
+            return None
+        return normalize_email(matched_key)
+
     def get_current_user(request: request_type) -> Optional[str]:
         token = extract_bearer_token(request)
         if token:
-            return get_session_email(token)
+            try:
+                return active_session_email(get_session_email(token), load_users())
+            except Exception:
+                # Account-store failures must fail closed rather than turning a
+                # stale session into an authenticated identity.
+                return None
         return None
 
     def require_user(request: request_type) -> str:
         email = get_current_user(request)
-        if require_auth and not email:
+        if email:
+            # Optional authentication remains meaningful in local mode: a
+            # valid session keeps its real account identity instead of being
+            # collapsed into the anonymous Local User fallback.
+            return email
+        if trusted_local_owner:
+            # A no-auth loopback caller is the trusted, anonymous local owner.
+            # Returning the legacy empty identity keeps ownerless workspaces,
+            # shared local vaults, and Local User profile behavior compatible;
+            # get_user_role() supplies the explicit owner authorization role.
+            return ""
+        if effective_require_auth and not email:
             raise http_exception(status_code=401, detail="인증이 필요합니다.")
         return email or ""
 
     def require_admin(request: request_type) -> tuple[str, Dict]:
         users = load_users()
-        if not require_auth:
+        if trusted_local_owner:
             return "", users
         token = extract_bearer_token(request)
         if token:
-            email = get_session_email(token)
+            email = active_session_email(get_session_email(token), users)
             if email:
                 role = get_user_role(email, users)
                 try:

package/latticeai/runtime/automation_runtime.py

@@ -27,19 +27,25 @@ 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)

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(