ltcai 10.2.0 → 10.4.0

package/latticeai/services/memory_service.py

@@ -236,7 +236,7 @@ class MemoryService:
         elif kg_index:
             vector_total = kg_index.get("indexed") or kg_index.get("ready")
 
-        sources = [
+        sources: List[Dict[str, Any]] = [
             {
                 "id": "workspace", "type": "workspace", "label": "Workspace Memory",
                 "count": len(ws_mem), "size_bytes": ws_bytes if ws_mem else 0,
@@ -272,7 +272,7 @@ class MemoryService:
                 "detail": "Local embedding vector index." if kg_index else "Vector index unavailable.",
             },
         ]
-        total_items = sum((s["count"] or 0) for s in sources)
+        total_items = sum(int(s["count"] or 0) for s in sources)
         total_bytes = ws_bytes + kg_bytes + conv_bytes
         healthy = sum(1 for s in sources if s["health"] == "ok")
         overall = "ok" if healthy >= 4 else "degraded" if healthy >= 1 else "unavailable"
@@ -747,7 +747,11 @@ class MemoryService:
         graph_count = int(sources.get("graph", {}).get("count") or 0)
         vector_count = int(sources.get("vector", {}).get("count") or 0)
         query = recall_query.strip() or self._latest_recall_query(user_email=user_email, workspace_id=workspace_id)
-        recall = self.recall(query, user_email=user_email, workspace_id=workspace_id, limit=limit) if query else {"query": "", "results": [], "count": 0, "source": "live"}
+        recall: Dict[str, Any] = (
+            self.recall(query, user_email=user_email, workspace_id=workspace_id, limit=limit)
+            if query
+            else {"query": "", "results": [], "count": 0, "source": "live"}
+        )
         recall_items = [
             {
                 "id": item.get("id"),
@@ -760,7 +764,7 @@ class MemoryService:
                 "matched_terms": item.get("matched_terms") or [],
                 "confidence": item.get("confidence") or "low",
             }
-            for item in recall.get("results", [])[: max(1, min(limit, 8))]
+            for item in list(recall.get("results", []))[: max(1, min(limit, 8))]
         ]
         durable_items = workspace_count + conversation_count + graph_count
         # Capability and proof are deliberately separated. The brain is

package/latticeai/services/model_catalog.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 import re
 import sys
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from latticeai.services.model_capability_registry import (
     LOCAL_MLX_MODELS as _LOCAL_MLX_MODELS,
@@ -34,7 +34,7 @@ from latticeai.services.model_capability_registry import (
     get_verified_models as _get_verified_models,
 )
 
-ENGINE_INSTALLERS = {
+ENGINE_INSTALLERS: Dict[str, Dict[str, Any]] = {
     "local_mlx": {
         "command": [sys.executable, "-m", "pip", "install", "--upgrade", "mlx-vlm>=0.6.3", "mlx-lm", "huggingface_hub[cli]"],
         "label": "Install MLX runtime",
@@ -89,10 +89,10 @@ ENGINE_INSTALLERS = {
 # user-facing ENGINE_MODEL_CATALOG below is then narrowed to the aggressive 5.2.0
 # policy (latest family generations only, no text-only/legacy weights) and the
 # engine-specific ids/sizes are normalised. See `_finalize_engine_catalog`.
-_RAW_ENGINE_MODEL_CATALOG: Dict[str, List[Dict[str, object]]] = _build_engine_model_catalog()
+_RAW_ENGINE_MODEL_CATALOG: Dict[str, List[Dict[str, Any]]] = _build_engine_model_catalog()
 # Filled in at module end once the blocklist, alias map and family-version filter
 # are all defined; declared here so the public name exists for static readers.
-ENGINE_MODEL_CATALOG: Dict[str, List[Dict[str, object]]] = {}
+ENGINE_MODEL_CATALOG: Dict[str, List[Dict[str, Any]]] = {}
 
 # Historical aliases preserved (used by _recommended_with_engine_options and resolution).
 # These can be enriched later from registry if needed; kept verbatim for safety.
@@ -173,7 +173,7 @@ def _version_tuple(raw: str) -> tuple[int, ...]:
     return tuple(int(part) for part in raw.split(".") if part.isdigit())
 
 
-def _model_family_version(model: Dict[str, object]) -> Optional[tuple[str, tuple[int, ...]]]:
+def _model_family_version(model: Dict[str, Any]) -> Optional[tuple[str, tuple[int, ...]]]:
     text = " ".join(str(model.get(key) or "") for key in ("family", "name", "id"))
     for family, pattern in _VERSIONED_MODEL_PATTERNS:
         match = pattern.search(text)
@@ -184,9 +184,9 @@ def _model_family_version(model: Dict[str, object]) -> Optional[tuple[str, tuple
     return None
 
 
-def filter_lower_family_versions(models: List[Dict[str, object]]) -> List[Dict[str, object]]:
+def filter_lower_family_versions(models: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     max_versions: Dict[str, tuple[int, ...]] = {}
-    detected: List[tuple[Dict[str, object], Optional[tuple[str, tuple[int, ...]]]]] = []
+    detected: List[tuple[Dict[str, Any], Optional[tuple[str, tuple[int, ...]]]]] = []
     for model in models:
         version_info = _model_family_version(model)
         detected.append((model, version_info))
@@ -214,12 +214,12 @@ _BLOCKED_CATALOG_FRAGMENTS = (
 )
 
 
-def _is_blocked_catalog_id(model: Dict[str, object]) -> bool:
+def _is_blocked_catalog_id(model: Dict[str, Any]) -> bool:
     ident = str(model.get("id") or "").lower()
     return any(fragment in ident for fragment in _BLOCKED_CATALOG_FRAGMENTS)
 
 
-def _normalize_engine_entry(engine: str, model: Dict[str, object]) -> Dict[str, object]:
+def _normalize_engine_entry(engine: str, model: Dict[str, Any]) -> Dict[str, Any]:
     """Apply historical engine-specific id + size conventions to a raw entry.
 
     * Non-MLX engines resolve to their canonical packaged id via
@@ -243,9 +243,9 @@ def _normalize_engine_entry(engine: str, model: Dict[str, object]) -> Dict[str,
 
 
 def _finalize_engine_catalog(
-    raw: Dict[str, List[Dict[str, object]]],
-) -> Dict[str, List[Dict[str, object]]]:
-    final: Dict[str, List[Dict[str, object]]] = {}
+    raw: Dict[str, List[Dict[str, Any]]],
+) -> Dict[str, List[Dict[str, Any]]]:
+    final: Dict[str, List[Dict[str, Any]]] = {}
     for engine, models in raw.items():
         kept = [
             _normalize_engine_entry(engine, m)

package/latticeai/services/model_engines.py

@@ -33,7 +33,7 @@ from latticeai.services.process_audit import (
 )
 
 
-def _progress_payload(*args, **kwargs) -> Dict[str, object]:
+def _progress_payload(*args, **kwargs) -> Dict[str, Any]:
     try:
         from latticeai.services.model_runtime import model_download_progress_payload
     except Exception:
@@ -63,7 +63,7 @@ def windows_binary_candidates(binary: str) -> List[Path]:
     local_appdata = os.environ.get("LOCALAPPDATA", "")
     program_files = os.environ.get("ProgramFiles", r"C:\Program Files")
     program_files_x86 = os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)")
-    candidates = {
+    candidates: Dict[str, List[Optional[Path]]] = {
         "ollama": [
             Path(local_appdata) / "Programs" / "Ollama" / "ollama.exe" if local_appdata else None,
             Path(program_files) / "Ollama" / "ollama.exe",
@@ -111,7 +111,7 @@ def _json_request(
     headers: Optional[Dict[str, str]] = None,
     payload: Optional[Dict[str, Any]] = None,
     timeout: float = 10.0,
-) -> Dict[str, object]:
+) -> Dict[str, Any]:
     data = None
     req_headers = dict(headers or {})
     if payload is not None:
@@ -211,8 +211,6 @@ def get_openai_compatible_server_models(provider: str) -> List[str]:
     if provider == "lmstudio":
         models = []
         for item in get_lmstudio_models():
-            if not isinstance(item, dict):
-                continue
             key = str(item.get("key") or "").strip()
             loaded_instances = item.get("loaded_instances") or []
             if loaded_instances:
@@ -360,7 +358,7 @@ def ensure_llamacpp_server(model_name: str) -> None:
         raise ModelRuntimeError(status_code=500, detail="llama.cpp 서버가 모델을 자동 로드하지 못했습니다.")
 
 
-def pull_ollama_model_with_progress(model_name: str, progress_emit=None) -> Dict[str, object]:
+def pull_ollama_model_with_progress(model_name: str, progress_emit=None) -> Dict[str, Any]:
     ollama = local_binary("ollama")
     if not ollama:
         raise ModelRuntimeError(status_code=400, detail="Ollama가 설치되지 않았습니다.")
@@ -447,7 +445,7 @@ def get_ollama_pulled_models() -> set:
         return set()
 
 
-def engine_support_status(engine: str) -> Dict[str, object]:
+def engine_support_status(engine: str) -> Dict[str, Any]:
     if engine != "vllm":
         return {"supported": True, "reason": None}
     is_apple_silicon = sys.platform == "darwin" and platform.machine() == "arm64"
@@ -470,7 +468,7 @@ def _engine_install_command(
     if engine not in ENGINE_INSTALLERS:
         raise ModelRuntimeError(status_code=400, detail="지원하지 않는 엔진입니다.")
     installer = ENGINE_INSTALLERS[engine]
-    required_binary = installer.get("requires_binary")
+    required_binary = str(installer.get("requires_binary") or "")
     if required_binary and shutil.which(required_binary) is None:
         raise ModelRuntimeError(status_code=400, detail=f"{required_binary}가 설치되어 있지 않아 자동 설치할 수 없습니다.")
     command = list(installer["command"])
@@ -528,16 +526,16 @@ def install_engine(
             },
         ) from exc
 
-    run_kwargs = {
-        "cwd": cwd,
-        "capture_output": True,
-        "text": True,
-        "timeout": 900,
-        "check": False,
-    }
     try:
         append_process_audit_event("engine_install", plan=plan, status="started")
-        completed = subprocess.run(command, **run_kwargs)
+        completed = subprocess.run(
+            command,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=900,
+            check=False,
+        )
     except subprocess.TimeoutExpired:
         append_process_audit_event("engine_install", plan=plan, status="timeout")
         raise ModelRuntimeError(status_code=408, detail="엔진 설치 시간이 초과되었습니다.")
@@ -603,7 +601,7 @@ async def _smoke_test_loaded_model(
     *,
     api_key_override: Optional[str] = None,
     model_router: Any = None,
-) -> Dict[str, object]:
+) -> Dict[str, Any]:
     """로드 직후 짧은 채팅 테스트를 돌려 ready_to_chat 여부를 판정한다.
 
     Cloud models are skipped to avoid cost.

package/latticeai/services/model_loading.py

@@ -231,7 +231,7 @@ async def prepare_and_load_model_stream(
     if compatibility.get("supported") is False:
         raise ModelRuntimeError(status_code=400, detail=compatibility)
 
-    work_queue: "queue.Queue[Dict[str, object]]" = queue.Queue()
+    work_queue: "queue.Queue[Dict[str, Any]]" = queue.Queue()
     work_result: Dict[str, object] = {}
 
     def emit_progress(payload: Dict[str, object]) -> None:

package/latticeai/services/model_runtime.py

@@ -269,10 +269,10 @@ def _json_request(
     url: str,
     *,
     method: str = "GET",
-    payload: Optional[Dict[str, object]] = None,
+    payload: Optional[Dict[str, Any]] = None,
     headers: Optional[Dict[str, str]] = None,
     timeout: float = 10.0,
-) -> Dict[str, object]:
+) -> Dict[str, Any]:
     data = None
     req_headers = dict(headers or {})
     if payload is not None:
@@ -299,12 +299,12 @@ def ensure_lmstudio_server() -> None:
     return _ensure_lmstudio_server()
 
 
-_LMSTUDIO_MODELS_CACHE: List[Dict[str, object]] = []
+_LMSTUDIO_MODELS_CACHE: List[Dict[str, Any]] = []
 _LMSTUDIO_MODELS_CACHE_TS: float = 0.0
 _LMSTUDIO_MODELS_CACHE_TTL: float = 10.0
 
 
-def get_lmstudio_models(*, force: bool = False) -> List[Dict[str, object]]:
+def get_lmstudio_models(*, force: bool = False) -> List[Dict[str, Any]]:
     global _LMSTUDIO_MODELS_CACHE, _LMSTUDIO_MODELS_CACHE_TS
     if not force and time.monotonic() - _LMSTUDIO_MODELS_CACHE_TS < _LMSTUDIO_MODELS_CACHE_TTL:
         return _LMSTUDIO_MODELS_CACHE
@@ -335,15 +335,13 @@ def _lmstudio_candidate_keys(model_name: str) -> List[str]:
     return list(dict.fromkeys(candidates))
 
 
-def _find_lmstudio_model_key(model_name: str, models: List[Dict[str, object]]) -> Optional[str]:
+def _find_lmstudio_model_key(model_name: str, models: List[Dict[str, Any]]) -> Optional[str]:
     if not models:
         return None
     candidate_keys = _lmstudio_candidate_keys(model_name)
     exact = []
     fuzzy = []
     for item in models:
-        if not isinstance(item, dict):
-            continue
         key = str(item.get("key") or "").strip()
         display_name = str(item.get("display_name") or "").strip()
         haystacks = [key.lower(), display_name.lower()]
@@ -352,10 +350,10 @@ def _find_lmstudio_model_key(model_name: str, models: List[Dict[str, object]]) -
             continue
         if any(token and token in hay for token in candidate_keys for hay in haystacks):
             fuzzy.append(key)
-    return (exact or fuzzy or [None])[0]
+    return next(iter(exact or fuzzy), None)
 
 
-def ensure_lmstudio_model(model_name: str) -> Dict[str, object]:
+def ensure_lmstudio_model(model_name: str) -> Dict[str, Any]:
     ensure_lmstudio_server()
     auth_header = {"Authorization": f"Bearer {os.getenv('LMSTUDIO_API_KEY') or 'lmstudio'}"}
     models = get_lmstudio_models()
@@ -430,7 +428,7 @@ def ensure_lmstudio_model(model_name: str) -> Dict[str, object]:
         "cached": False,
     }
 
-def engine_support_status(engine: str) -> Dict[str, object]:
+def engine_support_status(engine: str) -> Dict[str, Any]:
     return _engine_support_status(engine)
 
 def hf_model_ready(repo_id: str, provider: str = "local_mlx") -> bool:
@@ -467,8 +465,8 @@ def model_download_progress_payload(
     eta_seconds: Optional[float] = None,
     file: Optional[str] = None,
     indeterminate: bool = False,
-) -> Dict[str, object]:
-    payload: Dict[str, object] = {
+) -> Dict[str, Any]:
+    payload: Dict[str, Any] = {
         "stage": stage,
         "message": message,
         "indeterminate": indeterminate,
@@ -496,7 +494,7 @@ def estimate_eta_seconds(started_at: float, percent: Optional[float]) -> Optiona
     return elapsed * (100.0 - percent) / percent
 
 
-def hf_repo_files_with_sizes(repo_id: str) -> List[Dict[str, object]]:
+def hf_repo_files_with_sizes(repo_id: str) -> List[Dict[str, Any]]:
     from huggingface_hub import HfApi
 
     api = HfApi()
@@ -522,7 +520,7 @@ def download_hf_model(
     repo_id: str,
     provider: str = "local_mlx",
     progress_emit=None,
-) -> Dict[str, object]:
+) -> Dict[str, Any]:
     if importlib.util.find_spec("huggingface_hub") is None:
         raise ModelRuntimeError(status_code=400, detail="huggingface_hub가 없습니다. 먼저 MLX runtime 설치를 진행해 주세요.")
 
@@ -695,7 +693,7 @@ def download_hf_model(
     return {"model": repo_id, "path": str(target_dir), "cached": False}
 
 
-def pull_ollama_model_with_progress(model_name: str, progress_emit=None) -> Dict[str, object]:
+def pull_ollama_model_with_progress(model_name: str, progress_emit=None) -> Dict[str, Any]:
     return _pull_ollama_model_with_progress(model_name, progress_emit)
 
 
@@ -727,7 +725,7 @@ def _safe_engine_install_plan(
     engine: str,
     *,
     base_dir: Path,
-) -> Optional[Dict[str, object]]:
+) -> Optional[Dict[str, Any]]:
     try:
         return _engine_install_plan(engine, base_dir=base_dir)
     except Exception:
@@ -760,7 +758,7 @@ def engine_status(
     r = state.router
     verify_cache = cloud_verify_cache or {}
     cloud_models = r.detected_cloud_models() if r else []
-    cloud_by_provider = {}
+    cloud_by_provider: Dict[str, List[Dict[str, Any]]] = {}
     for model in cloud_models:
         cloud_by_provider.setdefault(model["provider"], []).append(model)
 
@@ -787,10 +785,8 @@ def engine_status(
 
     lmstudio_models = []
     downloaded_lmstudio = get_lmstudio_models()
-    downloaded_by_key = {}
+    downloaded_by_key: Dict[str, Dict[str, Any]] = {}
     for item in downloaded_lmstudio:
-        if not isinstance(item, dict):
-            continue
         key = str(item.get("key") or "").strip()
         if not key:
             continue
@@ -823,7 +819,7 @@ def engine_status(
         llamacpp_models.append({**m, "pulled": hf_model_ready(repo_id, "llamacpp")})
     llamacpp_models = filter_lower_family_versions(llamacpp_models)
 
-    local_server_specs = [
+    local_server_specs: List[Dict[str, Any]] = [
         {
             "id": "vllm",
             "name": "vLLM",
@@ -906,7 +902,7 @@ def engine_status(
         env_key = next((item.get("requires") for item in cloud_by_provider.get(provider, []) if item.get("requires")), None)
         provider_models = []
         for model in cloud_by_provider.get(provider, []):
-            cache = verify_cache.get(model.get("id"))
+            cache = verify_cache.get(str(model.get("id") or ""))
             provider_models.append({
                 **model,
                 "verified": cache.get("ok") if cache else None,
@@ -1009,7 +1005,7 @@ def normalize_local_model_request(model_id: str, engine: Optional[str] = None) -
     return model_id
 
 
-def ensure_engine_ready(engine: str, *, state: ModelRuntimeState) -> Dict[str, object]:
+def ensure_engine_ready(engine: str, *, state: ModelRuntimeState) -> Dict[str, Any]:
     engine = "local_mlx" if engine == "mlx" else engine
     if engine not in ENGINE_INSTALLERS and engine not in OPENAI_COMPATIBLE_PROVIDERS:
         raise ModelRuntimeError(status_code=400, detail=f"지원하지 않는 엔진입니다: {engine}")
@@ -1065,7 +1061,7 @@ async def _smoke_test_loaded_model(
     *,
     api_key_override: Optional[str] = None,
     state: ModelRuntimeState,
-) -> Dict[str, object]:
+) -> Dict[str, Any]:
     # Delegated to model_engines for server decomp
     from .model_engines import _smoke_test_loaded_model as _impl_smoke
     return await _impl_smoke(
@@ -1085,7 +1081,7 @@ async def prepare_and_load_model(
     allow_download: bool = False,
     *,
     state: ModelRuntimeState,
-) -> Dict[str, object]:
+) -> Dict[str, Any]:
     from .model_loading import prepare_and_load_model as _impl
 
     return await _impl(
@@ -1100,7 +1096,7 @@ async def prepare_and_load_model(
     )
 
 
-def sse_event(event: str, data: Dict[str, object]) -> str:
+def sse_event(event: str, data: Dict[str, Any]) -> str:
     return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
 
 
@@ -1128,7 +1124,7 @@ async def prepare_and_load_model_stream(
 
 CLOUD_VERIFY_TTL_SECONDS = 600
 
-async def _probe_cloud_model(model_ref: str) -> Dict[str, object]:
+async def _probe_cloud_model(model_ref: str) -> Dict[str, Any]:
     provider, model_name = parse_model_ref(model_ref)
     config = OPENAI_COMPATIBLE_PROVIDERS.get(provider)
     if not config:
@@ -1140,12 +1136,14 @@ async def _probe_cloud_model(model_ref: str) -> Dict[str, object]:
 
     base_url = os.getenv(config.get("base_url_env", "")) if config.get("base_url_env") else None
     base_url = base_url or config.get("base_url")
-    client_kwargs = {"api_key": api_key}
-    if base_url:
-        client_kwargs["base_url"] = base_url
-
     try:
-        client = AsyncOpenAI(**client_kwargs)
+        # base_url is passed only when configured: an explicit None is not
+        # the same as omitting the argument.
+        client = (
+            AsyncOpenAI(api_key=api_key, base_url=base_url)
+            if base_url
+            else AsyncOpenAI(api_key=api_key)
+        )
         await asyncio.wait_for(
             client.chat.completions.create(
                 model=model_name,
@@ -1246,7 +1244,7 @@ class ModelRuntimeService:
         adapter_path: Optional[str] = None,
         draft_model_id: Optional[str] = None,
         allow_download: bool = False,
-    ) -> Dict[str, object]:
+    ) -> Dict[str, Any]:
         return await prepare_and_load_model(
             model_id,
             request,

package/latticeai/services/multimodal_streaming.py

@@ -45,14 +45,20 @@ class MultimodalTurnResult:
 
 
 class MultimodalAdapter(Protocol):
-    async def stream_media(
+    # See CloudLLMAdapter.stream: an async generator is declared with `def`.
+    def stream_media(
         self,
         *,
         prompt: str,
         context: str,
         model: Optional[str] = None,
-    ) -> AsyncIterator[Dict[str, Any]]:
-        """Yield progress events, then a final event with media_urls."""
+    ) -> AsyncIterator[Any]:
+        """Yield progress events, then a final event with media_urls.
+
+        Typed as ``Any`` rather than ``Dict[str, Any]`` because adapters are
+        supplied by callers: the bridge validates each event's shape rather
+        than trusting the annotation.
+        """
         ...
 
 
@@ -112,7 +118,7 @@ class MultimodalStreamingBridge:
             answer_text="\n".join(notes),
             sent_node_ids=list(minimal.node_ids),
             provider=getattr(self._adapter, "provider_name", "multimodal"),
-            model=model or getattr(self._adapter, "default_model", ""),
+            model=str(model or getattr(self._adapter, "default_model", "")),
         )
 
 

package/latticeai/services/openai_compatible_adapter.py

@@ -51,10 +51,11 @@ class OpenAICompatibleAdapter:
             raise RuntimeError(
                 "openai package is required for the cloud streaming adapter"
             ) from exc
-        kwargs = {"api_key": self.api_key}
+        # base_url is only passed when configured: AsyncOpenAI treats an
+        # explicit None differently from an omitted argument.
         if self.base_url:
-            kwargs["base_url"] = self.base_url
-        return AsyncOpenAI(**kwargs)
+            return AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
+        return AsyncOpenAI(api_key=self.api_key)
 
     async def stream(
         self,

package/latticeai/services/product_readiness.py

@@ -18,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "10.2.0"
+PRODUCT_VERSION_TARGET = "10.4.0"
 
 
 @dataclass(frozen=True)

package/latticeai/services/run_executor.py

@@ -29,6 +29,15 @@ class _RunHandle:
     cancel_requested: bool = False
     started: bool = False
 
+    def is_cancelled(self) -> bool:
+        """Read the flag through a call.
+
+        `cancel_requested` is set by a *different* task (``cancel``), so a
+        reader must not be narrowed by an earlier check in its own frame:
+        the value can change between the guard and the poll.
+        """
+        return self.cancel_requested
+
 
 class RunExecutor:
     """Async task manager for persisted agent/workflow executions."""
@@ -119,9 +128,9 @@ class RunExecutor:
                 roles=roles,
                 inputs=inputs,
                 max_retries=max_retries,
-                cancel_requested=lambda: handle.cancel_requested,
+                cancel_requested=handle.is_cancelled,
             )
-            if handle.cancel_requested and (payload.get("run") or {}).get("status") != "cancelled":
+            if handle.is_cancelled() and (payload.get("run") or {}).get("status") != "cancelled":
                 self._cancel_agent_record(run_id, handle.scope, "cancelled after the final result was persisted")
             else:
                 self._results[run_id] = payload
@@ -232,7 +241,7 @@ class RunExecutor:
                 started_at=run.get("started_at") or _now(),
             )
             result = await asyncio.to_thread(self._execute_workflow_sync, workflow, user_email, handle.scope, inputs)
-            if handle.cancel_requested:
+            if handle.is_cancelled():
                 self._cancel_workflow_record(run_id, handle.scope, "cancelled after the current synchronous step completed")
                 return
             pause = (

package/latticeai/services/search_service.py

@@ -330,7 +330,7 @@ class SearchService:
                 by_id[node_id] = current
             current["score"] = max(float(current["score"]), score)
             current["source_scores"]["graph"] = max(float(current["source_scores"]["graph"]), score)
-            context = {"reason": reason}
+            context: Dict[str, Any] = {"reason": reason}
             if edge:
                 context["relationship"] = {
                     "id": edge.get("id"),

package/latticeai/services/triggers.py

@@ -71,7 +71,7 @@ class TriggerService:
             try:
                 self._tz = ZoneInfo(self._tz_name)
             except Exception:
-                self._tz = ZoneInfo("UTC") if ZoneInfo else None
+                self._tz = ZoneInfo("UTC")
 
     # ── durable state ──────────────────────────────────────────────────────
     def _load_state(self) -> Dict[str, Any]:

package/latticeai/setup/auto_setup.py

@@ -298,7 +298,7 @@ def _detect_cpu_details(prof_os: str) -> Tuple[str, int, int, List[str]]:
                     quiet()
         try:
             import ctypes
-            kernel32 = ctypes.windll.kernel32
+            kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]  # Windows-only
             feature_map = {6: "sse", 10: "sse2", 13: "sse3", 19: "neon", 28: "rdrand"}
             flags.extend(name for code, name in feature_map.items() if kernel32.IsProcessorFeaturePresent(code))
         except Exception:

package/latticeai/setup/wizard.py

@@ -352,7 +352,7 @@ def _detect_cpu() -> Dict[str, Any]:
                     quiet()
         try:
             import ctypes
-            kernel32 = ctypes.windll.kernel32
+            kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]  # Windows-only
             feature_map = {
                 6: "sse",
                 10: "sse2",
@@ -836,9 +836,18 @@ def get_recommendations(env: Dict[str, Any]) -> Dict[str, Any]:
         if cid == "homebrew":
             action = {"type": "url", "url": OFFICIAL_DOWNLOADS["homebrew"], "binary": "brew"}
         elif tools.get("brew") and brew_pkg:
-            action = {"type": "brew", "package": brew_pkg, "binary": binary, "official_url": OFFICIAL_DOWNLOADS.get(cid)}
+            action = {
+                "type": "brew",
+                "package": brew_pkg,
+                "binary": binary or "",
+                "official_url": OFFICIAL_DOWNLOADS.get(cid, ""),
+            }
         else:
-            action = {"type": "url", "url": OFFICIAL_DOWNLOADS.get(cid, ""), "binary": binary}
+            action = {
+                "type": "url",
+                "url": OFFICIAL_DOWNLOADS.get(cid, ""),
+                "binary": binary or "",
+            }
         components.append({
             "id": f"component_{cid}", "name": name,
             "subtitle": subtitle, "status": "available",

package/latticeai/tools/computer.py

@@ -17,7 +17,9 @@ _PLATFORM = platform.system()
 
 # ── Computer Use ──────────────────────────────────────────────────────────────
 _CU_AVAILABLE = False
-_pyautogui = None
+# Optional dependency: None until _init_computer_use() imports it, and the
+# _CU_AVAILABLE flag is what every call site checks.
+_pyautogui: Any = None
 
 def _init_computer_use():
     global _CU_AVAILABLE, _pyautogui

package/latticeai/tools/documents.py

@@ -51,7 +51,7 @@ def create_docx(title: str, body, filename: str = "document.docx") -> Dict[str,
         text = block.strip()
         if text:
             document.add_paragraph(text)
-    document.save(target)
+    document.save(str(target))
     return {"path": _relative(target), "bytes": target.stat().st_size}
 
 
@@ -107,7 +107,7 @@ def create_pptx(title: str, slides: List[Dict[str, Any]], filename: str = "prese
             paragraph.text = str(bullet)
             paragraph.level = 0
 
-    presentation.save(target)
+    presentation.save(str(target))
     return {"path": _relative(target), "slides": len(presentation.slides), "bytes": target.stat().st_size}
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "10.2.0",
+  "version": "10.4.0",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -61,7 +61,8 @@
     "test:vscode-extension": "cd vscode-extension && npm run build && cd .. && node --test tests/vscode-extension.test.cjs",
     "check:i18n-namespaces": "node scripts/check_i18n_namespace_coverage.mjs",
     "typecheck:python": "node scripts/run_python.mjs -m mypy",
-    "test:coverage": "node scripts/run_python.mjs -m pytest tests/ -q --cov --cov-report=term:skip-covered"
+    "test:coverage": "node scripts/run_python.mjs -m pytest tests/ -q --cov --cov-report=term:skip-covered",
+    "test:frontend:coverage": "vitest run --coverage"
   },
   "keywords": [
     "ltcai",
@@ -137,6 +138,7 @@
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^6.0.2",
+    "@vitest/coverage-v8": "^4.1.10",
     "autoprefixer": "^10.5.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",