ltcai 10.8.0 → 10.10.0

package/latticeai/api/portability.py

@@ -12,6 +12,8 @@ from typing import Any, Callable, Optional
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
 
+from latticeai.core.messages import http_error, resolve_language, translate
+
 
 class ImportRequest(BaseModel):
     artifact: dict
@@ -72,52 +74,52 @@ def create_portability_router(
 ) -> APIRouter:
     router = APIRouter()
 
-    def _require_service():
+    def _require_service(request: Request):
         if service is None or not service.available():
-            raise HTTPException(status_code=503, detail="Knowledge Graph is disabled.")
+            raise http_error(503, "common.graph_disabled", resolve_language(request))
 
     @router.get("/api/knowledge-graph/portability")
     async def portability_status(request: Request):
         require_user(request)
-        _require_service()
+        _require_service(request)
         return service.snapshot_metadata()
 
     @router.get("/api/brain/storage")
     async def brain_storage_status(request: Request):
         require_user(request)
-        _require_service()
+        _require_service(request)
         return service.storage_status()
 
     @router.get("/api/knowledge-graph/backup-health")
     async def backup_health(request: Request):
         require_user(request)
-        _require_service()
+        _require_service(request)
         return service.backup_health()
 
     @router.get("/api/knowledge-graph/provenance")
     async def recent_provenance(request: Request, limit: int = 50, source_type: Optional[str] = None):
         """Recent ingestions (provenance trail) for the ingestion-sources UI."""
         require_admin(request)
-        _require_service()
+        _require_service(request)
         return service.recent_ingestions(limit=limit, source_type=source_type)
 
     @router.post("/api/knowledge-graph/export")
     async def export_graph(request: Request):
         """Logical JSON export of the whole graph (read-only)."""
         require_admin(request)
-        _require_service()
+        _require_service(request)
         return service.export()
 
     @router.post("/api/knowledge-graph/export-file")
     async def export_graph_file(request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         return service.export_to_file()
 
     @router.post("/api/knowledge-graph/import")
     async def import_graph(req: ImportRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         try:
             return service.import_data(req.artifact, mode=req.mode, dry_run=req.dry_run)
         except ValueError as exc:
@@ -126,13 +128,13 @@ def create_portability_router(
     @router.post("/api/knowledge-graph/backup")
     async def backup_graph(req: BackupRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         return service.backup(req.path)
 
     @router.post("/api/knowledge-graph/restore")
     async def restore_graph(req: RestoreRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         try:
             return service.restore(req.path, verify=req.verify, dry_run=req.dry_run, confirm=req.confirm)
         except (ValueError, FileNotFoundError) as exc:
@@ -141,7 +143,7 @@ def create_portability_router(
     @router.post("/api/knowledge-graph/archive")
     async def encrypted_archive(req: EncryptedArchiveRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         try:
             return service.encrypted_archive(req.path, passphrase=req.passphrase)
         except (ValueError, FileNotFoundError) as exc:
@@ -150,7 +152,7 @@ def create_portability_router(
     @router.post("/api/knowledge-graph/archive/inspect")
     async def inspect_encrypted_archive(req: EncryptedInspectRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         try:
             return service.inspect_encrypted_archive(req.path, passphrase=req.passphrase)
         except (ValueError, FileNotFoundError) as exc:
@@ -159,16 +161,22 @@ def create_portability_router(
     @router.post("/api/knowledge-graph/archive/verify")
     async def verify_encrypted_archive(req: EncryptedVerifyRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         result = service.verify_encrypted_archive(req.path, passphrase=req.passphrase)
         if not result.get("ok"):
-            raise HTTPException(status_code=400, detail="; ".join(result.get("errors") or ["Archive verification failed."]))
+            raise HTTPException(
+            status_code=400,
+            detail="; ".join(
+                result.get("errors")
+                or [translate("portability.verification_failed", resolve_language(request))]
+            ),
+        )
         return result
 
     @router.post("/api/knowledge-graph/archive/import")
     async def import_encrypted_archive(req: EncryptedRestoreRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         try:
             return service.import_encrypted_archive(
                 req.path,
@@ -182,7 +190,7 @@ def create_portability_router(
     @router.post("/api/knowledge-graph/archive/restore")
     async def restore_encrypted_archive(req: EncryptedRestoreRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         try:
             return service.restore_encrypted_archive(
                 req.path,
@@ -196,7 +204,7 @@ def create_portability_router(
     @router.post("/api/brain/storage/postgres/docker")
     async def setup_postgres_docker(req: DockerPostgresRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         return service.postgres_docker_setup(
             consent=req.consent,
             dry_run=req.dry_run,
@@ -206,7 +214,7 @@ def create_portability_router(
     @router.post("/api/brain/storage/migrate-postgres")
     async def migrate_sqlite_to_postgres(req: SQLiteToPostgresRequest, request: Request):
         require_admin(request)
-        _require_service()
+        _require_service(request)
         try:
             return service.migrate_sqlite_to_postgres(
                 dsn=req.dsn,

package/latticeai/api/project_sessions.py

@@ -11,9 +11,11 @@ from __future__ import annotations
 
 from typing import Any, Callable, List, Optional
 
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, Request
 from pydantic import BaseModel, Field
 
+from latticeai.core.messages import http_error, resolve_language
+
 
 class CreateProjectRequest(BaseModel):
     title: str = Field(..., min_length=1, max_length=200)
@@ -65,7 +67,7 @@ def create_project_sessions_router(
         user = require_user(request)
         record = store.get(session_id, user_email=user, workspace_id=_scope(request))
         if record is None:
-            raise HTTPException(status_code=404, detail="project not found")
+            raise http_error(404, "project.not_found", resolve_language(request))
         return record
 
     @router.patch("/api/projects/{session_id}")
@@ -80,7 +82,7 @@ def create_project_sessions_router(
             workspace_id=_scope(request, write=True),
         )
         if record is None:
-            raise HTTPException(status_code=404, detail="project not found")
+            raise http_error(404, "project.not_found", resolve_language(request))
         return record
 
     @router.put("/api/projects/{session_id}/todos")
@@ -93,7 +95,7 @@ def create_project_sessions_router(
             workspace_id=_scope(request, write=True),
         )
         if record is None:
-            raise HTTPException(status_code=404, detail="project not found")
+            raise http_error(404, "project.not_found", resolve_language(request))
         return record
 
     @router.delete("/api/projects/{session_id}")
@@ -103,7 +105,7 @@ def create_project_sessions_router(
             session_id, user_email=user, workspace_id=_scope(request, write=True)
         )
         if not removed:
-            raise HTTPException(status_code=404, detail="project not found")
+            raise http_error(404, "project.not_found", resolve_language(request))
         return {"status": "deleted", "id": session_id}
 
     return router

package/latticeai/api/review_queue.py

@@ -19,6 +19,7 @@ from typing import Any, Callable, Dict, List, Optional
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel, Field
 
+from latticeai.core.messages import http_error, resolve_language, translate
 from latticeai.services.change_proposals import ProposalConflictError
 from latticeai.services.review_queue import InvalidReviewTransition, ReviewQueueService
 
@@ -129,7 +130,7 @@ def create_review_queue_router(
         try:
             return service.get(item_id, workspace_id=scope)
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
 
     @router.post("/automation/reviews/{item_id}/approve", response_model=ReviewItem)
     async def approve_item(item_id: str, request: Request):
@@ -141,12 +142,16 @@ def create_review_queue_router(
             try:
                 stored = service.get(item_id, workspace_id=scope)
             except FileNotFoundError as exc:
-                raise HTTPException(status_code=404, detail="review item not found") from exc
+                raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
             if stored.get("source") == "change_proposal":
                 if stored.get("effective_status") not in ("pending", "snoozed"):
                     raise HTTPException(
                         status_code=409,
-                        detail=f"cannot 'approve' a review item in status {stored.get('status')!r}",
+                        detail=translate(
+                    "review.cannot_approve_in_status",
+                    resolve_language(request),
+                    status=stored.get("status"),
+                ),
                     )
                 try:
                     applied = change_proposals.approve_and_apply(
@@ -177,7 +182,7 @@ def create_review_queue_router(
                 item_id, workspace_id=scope, reason=(req.reason if req else None)
             )
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
         except InvalidReviewTransition as exc:
             raise HTTPException(status_code=409, detail=str(exc)) from exc
         append_audit_event("review_item_dismiss", user_email=user, item_id=item_id)
@@ -190,7 +195,7 @@ def create_review_queue_router(
         try:
             item = service.snooze(item_id, until=req.until, workspace_id=scope)
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
         except InvalidReviewTransition as exc:
             raise HTTPException(status_code=409, detail=str(exc)) from exc
         append_audit_event("review_item_snooze", user_email=user, item_id=item_id)
@@ -211,7 +216,7 @@ def create_review_queue_router(
                 workspace_id=scope,
             )
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
         except InvalidReviewTransition as exc:
             raise HTTPException(status_code=409, detail=str(exc)) from exc
         append_audit_event("review_item_run_now", user_email=user, item_id=item_id)
@@ -224,7 +229,7 @@ def create_review_queue_router(
         try:
             item = fn(item_id, workspace_id=scope)
         except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail="review item not found") from exc
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
         except InvalidReviewTransition as exc:
             raise HTTPException(status_code=409, detail=str(exc)) from exc
         append_audit_event(f"review_item_{action}", user_email=user, item_id=item_id)

package/latticeai/api/setup.py

@@ -9,6 +9,7 @@ from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
 from lattice_brain.ingestion import IngestionItem
+from latticeai.core.messages import http_error, resolve_language
 from latticeai.models.router import parse_model_ref
 from latticeai.services.process_audit import command_plan
 from latticeai.setup.auto_setup import (
@@ -184,27 +185,25 @@ def create_setup_router(
         }
         url = auth_urls.get(mcp_id)
         if not url:
-            raise HTTPException(status_code=404, detail=f"알 수 없는 MCP: {mcp_id}")
+            raise http_error(404, "mcp.unknown_id", resolve_language(request), mcp_id=mcp_id)
         open_url(url)
         return {"status": "ok", "opened": url, "mcp_id": mcp_id}
     
     
     # ── First Value Loop demo corpus (backlog #3, review §3.3 P0) ────────────
 
-    def _require_demo_pipeline():
+    def _require_demo_pipeline(request: Request):
         if ingestion_pipeline is None or not ingestion_pipeline.available():
-            raise HTTPException(
-                status_code=503, detail="Knowledge Graph ingestion is disabled.",
-            )
+            raise http_error(503, "capture.ingestion_disabled", resolve_language(request))
         if knowledge_graph is None:
-            raise HTTPException(status_code=503, detail="Knowledge Graph is disabled.")
+            raise http_error(503, "common.graph_disabled", resolve_language(request))
 
     def _demo_workspace(request: Request, body_workspace: Optional[str], user: str) -> Optional[str]:
         header = request.headers.get("X-Workspace-Id")
         header = header.strip() if header and header.strip() else None
         supplied = [value for value in (body_workspace, header) if value]
         if len(set(supplied)) > 1:
-            raise HTTPException(status_code=403, detail="Workspace selectors must match.")
+            raise http_error(403, "common.workspace_mismatch", resolve_language(request))
         requested = supplied[0] if supplied else None
         if workspace_service is None:
             return requested
@@ -217,7 +216,7 @@ def create_setup_router(
     async def demo_corpus_status(request: Request):
         """Whether the demo corpus is installed + the suggestion chips."""
         require_user(request)
-        _require_demo_pipeline()
+        _require_demo_pipeline(request)
         installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
         return {
             "installed": bool(installed),
@@ -236,7 +235,7 @@ def create_setup_router(
         instead of duplicating.
         """
         user = require_user(request)
-        _require_demo_pipeline()
+        _require_demo_pipeline(request)
         workspace_id = _demo_workspace(request, req.workspace_id if req else None, user)
         results = []
         ingested = 0
@@ -285,7 +284,7 @@ def create_setup_router(
     async def demo_corpus_remove(request: Request):
         """Remove every demo document (node + chunks + edges + orphan source)."""
         require_user(request)
-        _require_demo_pipeline()
+        _require_demo_pipeline(request)
         installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
         removed = []
         for doc in installed:
@@ -314,7 +313,7 @@ def create_setup_router(
         }
         url = urls.get(permission_id)
         if not url:
-            raise HTTPException(status_code=404, detail="알 수 없는 권한 설정입니다.")
+            raise http_error(404, "setup.unknown_permission", resolve_language(request))
         open_url(url)
         return {"status": "ok", "opened": url, "permission": permission_id}
     return api_router

package/latticeai/api/static_routes.py

@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
 import hashlib
 import hmac
+import re
 import secrets
 import subprocess
 import time
@@ -40,6 +42,59 @@ SYSINFO_READINESS_ROOMY_MAX = 55.0
 SYSINFO_READINESS_TIGHT_MAX = 80.0
 
 
+def _probe_host_capacity() -> Dict[str, Any]:
+    """Sample CPU / RAM / GPU on this machine. Blocking — call off the loop.
+
+    Extracted from the route so the subprocess sampling can be handed to a
+    worker thread, and so the parsing is testable without an HTTP request.
+    """
+    result: Dict[str, Any] = {
+        "cpu_pct": 0.0,
+        "ram_pct": 0.0,
+        "gpu_mem_pct": 0.0,
+        "gpu_mem_gb": 0.0,
+        "readiness": "roomy",
+    }
+    try:
+        # CPU
+        top_out = subprocess.run(["top", "-l", "1", "-n", "0"], capture_output=True, text=True, timeout=4).stdout
+        for line in top_out.splitlines():
+            if "CPU usage" in line:
+                m = re.search(r"([\d.]+)% user.*?([\d.]+)% sys", line)
+                if m:
+                    result["cpu_pct"] = round(float(m.group(1)) + float(m.group(2)), 1)
+        # RAM
+        vm_out = subprocess.run(["vm_stat"], capture_output=True, text=True, timeout=4).stdout
+        pages: dict = {}
+        for line in vm_out.splitlines():
+            for key in ["Pages free", "Pages active", "Pages inactive", "Pages wired down", "Pages occupied by compressor"]:
+                if line.startswith(key):
+                    m = re.search(r"(\d+)", line)
+                    if m:
+                        pages[key] = int(m.group(1))
+        total = sum(pages.values())
+        used = total - pages.get("Pages free", 0)
+        result["ram_pct"] = round(used / total * 100, 1) if total else 0.0
+        # GPU (MLX / Apple Silicon unified memory)
+        try:
+            import mlx.core as _mx
+            hw_out = subprocess.run(["sysctl", "-n", "hw.memsize"], capture_output=True, text=True, timeout=2).stdout
+            total_bytes = int(hw_out.strip())
+            gpu_bytes = _mx.get_active_memory() + _mx.get_cache_memory()
+            result["gpu_mem_gb"] = round(gpu_bytes / (1024 ** 3), 2)
+            result["gpu_mem_pct"] = round(gpu_bytes / total_bytes * 100, 1) if total_bytes else 0.0
+        except Exception:
+            quiet()
+    except Exception as e:
+        result["error"] = str(e)
+    result["readiness"] = host_capacity_readiness(
+        cpu_pct=float(result.get("cpu_pct") or 0.0),
+        ram_pct=float(result.get("ram_pct") or 0.0),
+        gpu_mem_pct=float(result.get("gpu_mem_pct") or 0.0),
+    )
+    return result
+
+
 def host_capacity_readiness(
     *,
     cpu_pct: float = 0.0,
@@ -278,54 +333,15 @@ def create_static_routes_router(
 
         ``readiness`` is ``roomy`` | ``tight`` | ``low`` so basic System copy
         does not re-interpret raw percents on the client.
+
+        The probe itself is three subprocesses — ``top -l 1`` alone samples for
+        about a second — so it runs on a worker thread. Run inline it held the
+        event loop for the whole sample, and this route is hit on the System
+        screen *and* during first-run analysis, i.e. exactly while an answer is
+        streaming: one status poll used to stall every open stream.
         """
         require_user(request)
-        import re as _re
-        result: Dict[str, Any] = {
-            "cpu_pct": 0.0,
-            "ram_pct": 0.0,
-            "gpu_mem_pct": 0.0,
-            "gpu_mem_gb": 0.0,
-            "readiness": "roomy",
-        }
-        try:
-            # CPU
-            top_out = subprocess.run(["top", "-l", "1", "-n", "0"], capture_output=True, text=True, timeout=4).stdout
-            for line in top_out.splitlines():
-                if "CPU usage" in line:
-                    m = _re.search(r"([\d.]+)% user.*?([\d.]+)% sys", line)
-                    if m:
-                        result["cpu_pct"] = round(float(m.group(1)) + float(m.group(2)), 1)
-            # RAM
-            vm_out = subprocess.run(["vm_stat"], capture_output=True, text=True, timeout=4).stdout
-            pages: dict = {}
-            for line in vm_out.splitlines():
-                for key in ["Pages free", "Pages active", "Pages inactive", "Pages wired down", "Pages occupied by compressor"]:
-                    if line.startswith(key):
-                        m = _re.search(r"(\d+)", line)
-                        if m:
-                            pages[key] = int(m.group(1))
-            total = sum(pages.values())
-            used  = total - pages.get("Pages free", 0)
-            result["ram_pct"] = round(used / total * 100, 1) if total else 0.0
-            # GPU (MLX / Apple Silicon unified memory)
-            try:
-                import mlx.core as _mx
-                hw_out = subprocess.run(["sysctl", "-n", "hw.memsize"], capture_output=True, text=True, timeout=2).stdout
-                total_bytes = int(hw_out.strip())
-                gpu_bytes = _mx.get_active_memory() + _mx.get_cache_memory()
-                result["gpu_mem_gb"]  = round(gpu_bytes / (1024 ** 3), 2)
-                result["gpu_mem_pct"] = round(gpu_bytes / total_bytes * 100, 1) if total_bytes else 0.0
-            except Exception:
-                quiet()
-        except Exception as e:
-            result["error"] = str(e)
-        result["readiness"] = host_capacity_readiness(
-            cpu_pct=float(result.get("cpu_pct") or 0.0),
-            ram_pct=float(result.get("ram_pct") or 0.0),
-            gpu_mem_pct=float(result.get("gpu_mem_pct") or 0.0),
-        )
-        return result
+        return await asyncio.to_thread(_probe_host_capacity)
 
     return StaticRoutesBundle(
         api_router,

package/latticeai/api/tools.py

@@ -19,6 +19,7 @@ from latticeai.api.computer_use import create_computer_use_router
 from latticeai.api.local_files import create_local_files_router
 from latticeai.api.mcp import create_mcp_router
 from latticeai.api.permissions import create_permissions_router
+from latticeai.core.messages import http_error, resolve_language
 from latticeai.services.router_context import ToolRouterContext
 from latticeai.services.tool_dispatch import (
     TOOL_GOVERNANCE,
@@ -510,7 +511,7 @@ def create_tools_router(
         )
         target = Path(path).expanduser().resolve()
         if not target.exists() or not target.is_file():
-            raise HTTPException(status_code=404, detail="File not found")
+            raise http_error(404, "common.file_not_found", resolve_language(request))
         import pypdfium2 as pdfium
         doc = None
         try:
@@ -527,7 +528,7 @@ def create_tools_router(
                 pages.append({"page": i + 1, "b64": b64})
             return {"total": total, "pages": pages}
         except Exception as e:
-            raise HTTPException(status_code=500, detail=f"PDF 렌더링 실패: {e}")
+            raise http_error(500, "tools.pdf_render_failed", resolve_language(request), reason=e)
         finally:
             if doc is not None:
                 try:
@@ -544,9 +545,9 @@ def create_tools_router(
         rel = unquote(path).lstrip("/")
         target = (AGENT_ROOT / rel).resolve()
         if AGENT_ROOT not in target.parents and target != AGENT_ROOT:
-            raise HTTPException(status_code=403, detail="경로가 작업 공간 밖입니다.")
+            raise http_error(403, "tools.path_outside_workspace", resolve_language(request))
         if not target.exists() or not target.is_file():
-            raise HTTPException(status_code=404, detail="파일이 없습니다.")
+            raise http_error(404, "common.file_not_found", resolve_language(request))
         return FileResponse(
             path=target,
             filename=target.name,
@@ -570,9 +571,9 @@ def create_tools_router(
         rel = unquote(path).lstrip("/")
         target = (AGENT_ROOT / rel).resolve()
         if AGENT_ROOT not in target.parents and target != AGENT_ROOT:
-            raise HTTPException(status_code=403, detail="경로가 작업 공간 밖입니다.")
+            raise http_error(403, "tools.path_outside_workspace", resolve_language(request))
         if not target.exists() or not target.is_dir():
-            raise HTTPException(status_code=404, detail="디렉터리가 없습니다.")
+            raise http_error(404, "tools.directory_not_found", resolve_language(request))
         try:
             payload, filename = zip_workspace_dir(rel)
         except ToolError as exc:

package/latticeai/core/legacy_compatibility.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-LEGACY_COMPATIBILITY_VERSION = "10.8.0"
+LEGACY_COMPATIBILITY_VERSION = "10.10.0"
 
 
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
-MARKETPLACE_VERSION = "10.8.0"
+MARKETPLACE_VERSION = "10.10.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 

package/latticeai/core/mcp_registry.py

@@ -4,6 +4,7 @@ Lattice AI — MCP Registry data & pure helper functions.
 Extracted from server.py to reduce module size.
 """
 
+import asyncio
 import json
 import logging
 import os
@@ -354,6 +355,13 @@ async def install_skill(plugin: str, skill: str) -> Dict:
     }
 
 
+def _run_installer(command: List[str], timeout: int) -> "subprocess.CompletedProcess[str]":
+    """Run one package-installer command. Blocking — call off the event loop."""
+    return subprocess.run(
+        command, capture_output=True, text=True, timeout=timeout, check=False
+    )
+
+
 def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
     """Return bound MCP state helpers for given data_dir. No global side effects."""
     MCP_FILE = Path(data_dir) / "mcp_installs.json"
@@ -445,11 +453,15 @@ def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
             status = "needs_auth"
             message = "커넥터 인증이 필요합니다. Codex 앱의 connector 설정에서 계정을 연결하면 바로 사용할 수 있습니다."
         elif item.get("install_mode") == "pip":
+            # Package installers are minutes of network I/O. On the event loop
+            # they froze every other request for the whole install; each one now
+            # runs on a worker thread instead.
             packages = item.get("pip_packages") or []
             for pkg in packages:
-                completed = subprocess.run(
+                completed = await asyncio.to_thread(
+                    _run_installer,
                     [sys.executable, "-m", "pip", "install", "--upgrade", pkg],
-                    capture_output=True, text=True, timeout=900, check=False,
+                    900,
                 )
                 if completed.returncode != 0:
                     raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
@@ -458,7 +470,9 @@ def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
             pkg = item.get("package", "")
             version = item.get("package_version")
             pkg_str = f"{pkg}=={version}" if version else pkg
-            completed = subprocess.run([sys.executable, "-m", "pip", "install", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            completed = await asyncio.to_thread(
+                _run_installer, [sys.executable, "-m", "pip", "install", pkg_str], 300
+            )
             if completed.returncode != 0:
                 raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
             message = f"pip 패키지 설치 완료: {pkg_str}"
@@ -466,7 +480,9 @@ def create_mcp_install_state(data_dir: Path) -> Dict[str, Callable]:
             pkg = item.get("package", "")
             version = item.get("package_version")
             pkg_str = f"{pkg}@{version}" if version else pkg
-            completed = subprocess.run(["npm", "install", "-g", pkg_str], capture_output=True, text=True, timeout=300, check=False)
+            completed = await asyncio.to_thread(
+                _run_installer, ["npm", "install", "-g", pkg_str], 300
+            )
             if completed.returncode != 0:
                 raise HTTPException(status_code=500, detail=(completed.stderr or "")[-2000:] or f"{pkg} 설치 실패")
             message = f"npm 패키지 설치 완료: {pkg_str}"