ltcai 10.3.0 → 10.4.0

package/lattice_brain/graph/retrieval.py

@@ -1,8 +1,19 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 # ruff: noqa: F403,F405
 from ._kg_common import *  # noqa: F403,F401
 
+# The cross-mixin surface (`_connect`, `_upsert_node`, …) is declared in
+# `_kg_contract.KnowledgeGraphCore`. It is a typing-only base: at runtime this
+# is `object`, so the MRO of `KnowledgeGraphStore` is unchanged.
+if TYPE_CHECKING:
+    from ._kg_contract import KnowledgeGraphCore as _Core
+else:
+    _Core = object
+
+
 # --- Compat seam (v9.9.5 decomposition) -------------------------------------
 # The non-search read surface (list_documents / workspaces_of /
 # filter_scoped_nodes / neighbors / get_node / relationship_search /
@@ -46,7 +57,7 @@ def context_quality_signal(
     return {"mode": mode, "nodes": nodes, "limited": limited, "reason": reason}
 
 
-class KnowledgeGraphRetrievalMixin:
+class KnowledgeGraphRetrievalMixin(_Core):
     _GRAPH_VISIBLE_TYPES = (
         "Computer",  # 내 컴퓨터
         "Drive",  # 드라이브 / 볼륨

package/lattice_brain/graph/retrieval_docgen.py

@@ -1,10 +1,21 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 # ruff: noqa: F403,F405
 from ._kg_common import *  # noqa: F403,F401
 
+# The cross-mixin surface (`_connect`, `_upsert_node`, …) is declared in
+# `_kg_contract.KnowledgeGraphCore`. It is a typing-only base: at runtime this
+# is `object`, so the MRO of `KnowledgeGraphStore` is unchanged.
+if TYPE_CHECKING:
+    from ._kg_contract import KnowledgeGraphCore as _Core
+else:
+    _Core = object
+
+
 
-class KnowledgeGraphDocGenMixin:
+class KnowledgeGraphDocGenMixin(_Core):
     """Multi-hop retrieval specialised for document generation, split out
     of retrieval. Composed into KnowledgeGraphStore alongside the other
     retrieval mixins; shared instance means sibling helpers resolve via MRO.

package/lattice_brain/graph/retrieval_reads.py

@@ -11,11 +11,22 @@ calls (e.g. ``search`` → ``filter_scoped_nodes``) behave exactly as before.
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 # ruff: noqa: F403,F405
 from ._kg_common import *  # noqa: F403,F401
 
+# The cross-mixin surface (`_connect`, `_upsert_node`, …) is declared in
+# `_kg_contract.KnowledgeGraphCore`. It is a typing-only base: at runtime this
+# is `object`, so the MRO of `KnowledgeGraphStore` is unchanged.
+if TYPE_CHECKING:
+    from ._kg_contract import KnowledgeGraphCore as _Core
+else:
+    _Core = object
+
+
 
-class KnowledgeGraphReadsMixin:
+class KnowledgeGraphReadsMixin(_Core):
     def list_documents(self, limit: int = 200) -> Dict[str, Any]:
         """List ingested ``Document`` nodes with their ingest + index state.
 

package/lattice_brain/graph/retrieval_vector.py

@@ -1,10 +1,21 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 # ruff: noqa: F403,F405
 from ._kg_common import *  # noqa: F403,F401
 
+# The cross-mixin surface (`_connect`, `_upsert_node`, …) is declared in
+# `_kg_contract.KnowledgeGraphCore`. It is a typing-only base: at runtime this
+# is `object`, so the MRO of `KnowledgeGraphStore` is unchanged.
+if TYPE_CHECKING:
+    from ._kg_contract import KnowledgeGraphCore as _Core
+else:
+    _Core = object
+
+
 
-class KnowledgeGraphVectorMixin:
+class KnowledgeGraphVectorMixin(_Core):
     """Vector-embedding index build/status/search, split out of retrieval.
 
     Composed into KnowledgeGraphStore alongside KnowledgeGraphRetrievalMixin;

package/lattice_brain/graph/schema.py

@@ -48,6 +48,7 @@ import os
 import sqlite3
 from contextlib import contextmanager
 from enum import Enum
+from pathlib import Path
 from typing import Any, Dict, Optional
 
 from ..quiet import quiet
@@ -423,8 +424,11 @@ class KGStoreV2:
     프로젝션이 담당하므로 native upsert/get/search API 는 두지 않는다.
     """
 
-    def __init__(self, db_path: str):
-        self.db_path = db_path
+    def __init__(self, db_path: "str | Path"):
+        # Callers pass a Path (the store keeps db_path as a Path); sqlite3
+        # accepts either, so the annotation now matches what is actually
+        # handed in instead of forcing every call site to str() it.
+        self.db_path = str(db_path)
 
     @contextmanager
     def _conn(self):

package/lattice_brain/graph/write_master.py

@@ -1,10 +1,21 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 # ruff: noqa: F403,F405
 from ._kg_common import *  # noqa: F403,F401
 
+# The cross-mixin surface (`_connect`, `_upsert_node`, …) is declared in
+# `_kg_contract.KnowledgeGraphCore`. It is a typing-only base: at runtime this
+# is `object`, so the MRO of `KnowledgeGraphStore` is unchanged.
+if TYPE_CHECKING:
+    from ._kg_contract import KnowledgeGraphCore as _Core
+else:
+    _Core = object
+
+
 
-class KnowledgeGraphWriteMixin:
+class KnowledgeGraphWriteMixin(_Core):
     def _upsert_node(
         self,
         conn: sqlite3.Connection,

package/lattice_brain/ingestion.py

@@ -408,7 +408,7 @@ class IngestionResult:
     quality_gate: Optional[Dict[str, Any]] = None
 
     def as_dict(self) -> Dict[str, Any]:
-        payload = {
+        payload: Dict[str, Any] = {
             "status": self.status,
             "source_type": self.source_type,
             "node_id": self.node_id,

package/lattice_brain/quality.py

@@ -268,7 +268,7 @@ class MemoryQualityManager:
 
     def merge(self, cands: List[MemoryCandidate]) -> List[MemoryCandidate]:
         # naive merge by content prefix
-        merged = {}
+        merged: Dict[str, MemoryCandidate] = {}
         for c in cands:
             key = c.content[:30]
             if key not in merged or c.score > merged[key].score:
@@ -365,19 +365,19 @@ class GraphEdgeQualityManager:
         return GraphEdgeQuality(edge.get("id", "e0"), conf, ev, quality_score=q)
 
     def detect_duplicate_edges(self, edges: List[Dict]) -> List[str]:
-        seen = {}
-        dups = []
+        seen: Dict[Any, Any] = {}
+        dups: List[str] = []
         for e in edges:
             key = (e.get("source"), e.get("target"), e.get("type"))
             if key in seen:
-                dups.append(e.get("id"))
+                dups.append(str(e.get("id") or ""))
             else:
                 seen[key] = e.get("id")
         return dups
 
     def merge_duplicate_edges(self, edges: List[Dict]) -> List[Dict]:
         # keep highest confidence
-        best = {}
+        best: Dict[Any, Dict[str, Any]] = {}
         for e in edges:
             key = (e.get("source"), e.get("target"), e.get("type"))
             if key not in best or e.get("confidence", 0) > best[key].get("confidence", 0):

package/lattice_brain/runtime/contracts.py

@@ -435,7 +435,8 @@ def realtime_event_contract(event: Dict[str, Any]) -> Dict[str, Any]:
     """
     body = dict(event or {})
     seq = body.get("seq")
-    payload = body.get("payload") if isinstance(body.get("payload"), dict) else {}
+    raw_payload = body.get("payload")
+    payload: Dict[str, Any] = raw_payload if isinstance(raw_payload, dict) else {}
     contract_body = {
         "run_id": payload.get("run_id") or body.get("run_id"),
         "agent_id": str(payload.get("agent_id") or payload.get("workflow_id") or f"realtime:{body.get('area') or 'workspace'}"),

package/lattice_brain/runtime/multi_agent.py

@@ -47,7 +47,7 @@ from typing import Any, Callable, Dict, List, Optional
 from ..utils import now_iso as _now
 from .contracts import multi_agent_contract
 
-MULTI_AGENT_VERSION = "10.3.0"
+MULTI_AGENT_VERSION = "10.4.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/lattice_brain/workflow.py

@@ -239,7 +239,10 @@ class ApprovalRequired(Exception):
                  permission: Optional[Dict[str, Any]] = None):
         super().__init__(message)
         self.tool = tool
-        self.args = args or {}
+        # Deliberately shadows BaseException.args: callers read
+        # `exc.args` as the failing tool's argument mapping, not the
+        # exception constructor tuple.
+        self.args = args or {}  # type: ignore[assignment]
         self.permission = permission or {}
 
 
@@ -374,7 +377,7 @@ class WorkflowEngine:
         while current is not None and steps < _MAX_STEPS:
             steps += 1
             ntype = current.get("type")
-            nid = current.get("id")
+            nid = str(current.get("id") or "")
             entry: Dict[str, Any] = {
                 "node": nid,
                 "type": ntype,
@@ -386,7 +389,7 @@ class WorkflowEngine:
                 entry["status"] = "ok"
                 entry["trigger"] = (current.get("config") or {}).get("trigger", "manual")
                 run.timeline.append(entry)
-                current = nodes.get(current.get("next")) if current.get("next") else None
+                current = nodes.get(str(current.get("next") or "")) if current.get("next") else None
                 continue
 
             if ntype == "output":
@@ -395,7 +398,7 @@ class WorkflowEngine:
                 entry["output"] = payload if payload is not None else context.get("last_output")
                 run.outputs[nid] = entry["output"]
                 run.timeline.append(entry)
-                current = nodes.get(current.get("next")) if current.get("next") else None
+                current = nodes.get(str(current.get("next") or "")) if current.get("next") else None
                 continue
 
             if ntype == "condition":
@@ -409,14 +412,14 @@ class WorkflowEngine:
                 continue
 
             # Executable node → dispatch to its runner family.
-            family = _RUNNER_FOR.get(ntype)
+            family = _RUNNER_FOR.get(str(ntype or ""))
             runner = self.runners.get(family) if family else None
             if runner is None:
                 entry["status"] = "skipped"
                 entry["reason"] = f"no '{family}' runner configured"
                 had_skip = True
                 run.timeline.append(entry)
-                current = nodes.get(current.get("next")) if current.get("next") else None
+                current = nodes.get(str(current.get("next") or "")) if current.get("next") else None
                 continue
             try:
                 result = runner(node=current, context=context)
@@ -451,7 +454,7 @@ class WorkflowEngine:
                 entry["reason"] = str(exc)
                 had_error = True
             run.timeline.append(entry)
-            current = nodes.get(current.get("next")) if current.get("next") else None
+            current = nodes.get(str(current.get("next") or "")) if current.get("next") else None
 
         if steps >= _MAX_STEPS:
             run.timeline.append({"node": None, "type": "guard", "status": "error", "reason": f"exceeded {_MAX_STEPS} steps (cycle?)", "timestamp": _now()})

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "10.3.0"
+__version__ = "10.4.0"

package/latticeai/api/admin.py

@@ -3,7 +3,7 @@
 import logging
 from collections import defaultdict
 from datetime import datetime, timedelta
-from typing import Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 from fastapi import APIRouter, HTTPException, Query, Request
 from pydantic import BaseModel
@@ -226,7 +226,7 @@ def create_admin_router(
         for email, user in users.items():  # noqa: B007 — the key is the payload; the loop var documents the shape
             role = (get_user_role(email, users) or "user").lower()
             counts[role] += 1
-        matrix = policy_matrix() if policy_matrix else [
+        matrix: List[Dict[str, Any]] = policy_matrix() if policy_matrix else [
             {"role": "admin", "caps": ["all"]},
             {"role": "user", "caps": ["chat", "search"]},
         ]

package/latticeai/api/chat.py

@@ -94,16 +94,20 @@ def create_chat_router(context: AppContext) -> APIRouter:
     api_router = APIRouter()
     model_router = context.model_router
     config = context.config
-    require_user = context.require_user
+    require_user = context.require("require_user")
     workspace_service = context.workspace_service
     allowed_workspaces_for = context.allowed_workspaces_for
+    # Bound once so every handler below calls a resolved dependency rather
+    # than an Optional field (see AppContext.require).
+    enforce_rate_limit = context.require("enforce_rate_limit")
+    append_audit_event = context.require("append_audit_event")
 
     chat_service = ChatService.coerce(
         context.chat_service,
         store=context.workspace_store,
-        get_history=context.get_history,
-        save_to_history=context.save_to_history,
-        get_history_user=context.get_history_user,
+        get_history=context.require("get_history"),
+        save_to_history=context.require("save_to_history"),
+        get_history_user=context.require("get_history_user"),
     )
 
     def notify_chat_message(role: str, text: str, source: Optional[str]) -> None:
@@ -170,9 +174,9 @@ def create_chat_router(context: AppContext) -> APIRouter:
             model_router=model_router,
             execute_tool=execute_tool,
             recent_chat_context=recent_chat_context,
-            clear_history=context.clear_history,
+            clear_history=context.require("clear_history"),
             knowledge_save=knowledge_save,
-            audit=context.append_audit_event,
+            audit=context.require("append_audit_event"),
             hooks=context.hooks,
             brain_memory=context.brain_memory,
         )
@@ -247,7 +251,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
     @api_router.post("/chat")
     async def chat(req: ChatRequest, request: Request):
         current_user = require_user(request)
-        context.enforce_rate_limit(current_user, "chat")
+        enforce_rate_limit(current_user, "chat")
         logging.debug(
             "/chat request: stream=%s image_data_len=%s message_len=%s",
             req.stream,
@@ -352,7 +356,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
                 for match in file_path_pattern.finditer(req.message or "")
             ]
             if requested_paths:
-                context.append_audit_event(
+                append_audit_event(
                     "auto_file_context_blocked",
                     user_email=effective_email,
                     path_count=len(requested_paths),
@@ -393,7 +397,7 @@ def create_chat_router(context: AppContext) -> APIRouter:
         if isinstance(trace_seed, dict):
             trace_seed["context_quality"] = context_quality
         if context.funnel_metrics is not None and int(
-            context_quality.get("nodes") or 0
+            str(context_quality.get("nodes") or 0)
         ) > 0:
             context.funnel_metrics.record_recall_success()
 
@@ -542,12 +546,12 @@ def create_chat_router(context: AppContext) -> APIRouter:
             chat_service=chat_service,
             require_user=require_user,
             scope_for_user=history_scope_for_user,
-            group_conversations=context.group_history_conversations,
-            get_conversation_messages=context.get_conversation_messages,
-            conversation_title=context.conversation_title,
-            clear_conversation=context.clear_conversation,
-            clear_history=context.clear_history,
-            append_audit_event=context.append_audit_event,
+            group_conversations=context.require("group_history_conversations"),
+            get_conversation_messages=context.require("get_conversation_messages"),
+            conversation_title=context.require("conversation_title"),
+            clear_conversation=context.require("clear_conversation"),
+            clear_history=context.require("clear_history"),
+            append_audit_event=context.require("append_audit_event"),
         ),
     )
     agent_controller.register_routes(api_router)

package/latticeai/api/chat_agent_http.py

@@ -11,7 +11,7 @@ import threading
 import time
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Callable, Dict, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
@@ -31,6 +31,20 @@ from latticeai.api.chat_stream import agent_live_stream
 from latticeai.core.agent import AgentRunContext, AgentState, normalize_plan
 from latticeai.core.quiet import quiet
 from latticeai.core.run_explain import explain_run
+
+
+def _bind_case(
+    execute_tool: Callable[[str, Dict[str, Any]], Any],
+    action_name: str,
+    case_input: Dict[str, Any],
+) -> Callable[[], Any]:
+    """Freeze this iteration's action and input into a zero-arg thunk.
+
+    Previously a lambda with default-argument binding, which is correct but
+    invisible to a type checker (`Cannot infer type of lambda`) and one
+    refactor away from every case running the last input.
+    """
+    return lambda: execute_tool(action_name, case_input)
 from latticeai.core.run_store import (
     AgentRunStore,
     hash_approval_token,
@@ -200,9 +214,7 @@ class AgentHTTPController:
                     # Bound as defaults: the lambda is invoked inside this
                     # iteration today, so late binding is harmless — until
                     # someone defers it and every case runs the last input.
-                    lambda action_name=action_name, case_input=case_input: self.execute_tool(
-                        action_name, case_input
-                    ),
+                    _bind_case(self.execute_tool, action_name, case_input),
                     source="eval",
                 )
                 criteria = case.get("pass_criteria", "")
@@ -509,7 +521,7 @@ class AgentHTTPController:
                 }
         try:
             for summary in self.run_store.pending_summaries(current_user):
-                run_id = summary.get("run_id")
+                run_id = str(summary.get("run_id") or "")
                 if run_id and run_id not in pending:
                     pending[run_id] = {
                         "run_id": run_id,
@@ -801,7 +813,7 @@ class AgentHTTPController:
                     detail="Agent run belongs to another user.",
                 )
             if now_monotonic >= entry["expires_monotonic"]:
-                self._approvals.pop(req.run_id, None)
+                self._approvals.pop(req.run_id or "", None)
                 try:
                     self.run_store.delete(req.run_id or "")
                 except Exception:  # noqa: BLE001
@@ -820,7 +832,7 @@ class AgentHTTPController:
                     detail="Invalid approval token for this run.",
                 )
             # Token validated — the pending run is consumed either way.
-            self._approvals.pop(req.run_id, None)
+            self._approvals.pop(req.run_id or "", None)
             try:
                 self.run_store.delete(req.run_id or "")
             except Exception as exc:  # noqa: BLE001 — consumption must proceed

package/latticeai/api/chat_helpers.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import json
 import re
-from typing import AsyncIterator, Dict, List, Optional
+from typing import Any, AsyncIterator, Dict, List, Optional
 
 from fastapi import Request
 
@@ -289,17 +289,18 @@ def assess_answer_grounding(
     them". Annotation only — the answer is never modified or blocked.
     """
     answer_text = str(answer or "").strip()
-    trace = trace if isinstance(trace, dict) else {}
-    sources: List[Dict[str, object]] = []
+    trace_map: Dict[str, Any] = trace if isinstance(trace, dict) else {}
+    sources: List[Dict[str, Any]] = []
     seen_ids = set()
-    for node in list(trace.get("graph_nodes") or []):
+    for node in list(trace_map.get("graph_nodes") or []):
         if not isinstance(node, dict):
             continue
         node_id = str(node.get("id") or node.get("node_id") or "")
         if not node_id or node_id in seen_ids:
             continue
         seen_ids.add(node_id)
-        meta = node.get("metadata") if isinstance(node.get("metadata"), dict) else {}
+        raw_meta = node.get("metadata")
+        meta: Dict[str, Any] = raw_meta if isinstance(raw_meta, dict) else {}
         sources.append({
             "id": node_id,
             "title": str(node.get("title") or ""),
@@ -308,7 +309,7 @@ def assess_answer_grounding(
                 for part in (node.get("title"), node.get("summary"), meta.get("filename"))
             ),
         })
-    for src in list(trace.get("source_files") or []):
+    for src in list(trace_map.get("source_files") or []):
         if not isinstance(src, dict):
             continue
         node_id = str(src.get("node_id") or src.get("source") or "")
@@ -349,10 +350,10 @@ def assess_answer_grounding(
 
     answer_tokens = _grounding_tokens(answer_text)
     answer_lower = answer_text.lower()
-    cited: List[Dict[str, object]] = []
+    cited: List[Dict[str, Any]] = []
     best_overlap = 0.0
     for source in sources:
-        source_tokens = _grounding_tokens(source["body"])
+        source_tokens = _grounding_tokens(str(source["body"]))
         if not source_tokens:
             continue
         shared = answer_tokens & source_tokens

package/latticeai/api/chat_stream.py

@@ -57,13 +57,13 @@ def agent_live_stream(
 
     async def _stream() -> AsyncIterator[str]:
         response_model = model_id or router.current_model_id
-        queue: asyncio.Queue = asyncio.Queue()
+        queue: "asyncio.Queue[Dict[str, Any]]" = asyncio.Queue()
 
         def observer(event: Dict[str, Any]) -> None:
             # Called synchronously from the agent coroutine on this loop.
             queue.put_nowait(event)
 
-        task = asyncio.create_task(start(observer))
+        task = asyncio.ensure_future(start(observer))
         try:
             while True:
                 getter = asyncio.create_task(queue.get())

package/latticeai/api/computer_use.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 import re
-from typing import Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
@@ -401,7 +401,7 @@ def create_computer_use_router(
                 yield _send("error", {"error": "No model loaded."})
                 return
 
-            transcript = []
+            transcript: List[Dict[str, Any]] = []
             last_screenshot_b64: Optional[str] = None
             max_steps = max(1, min(req.max_steps, 20))
             yield _send("start", {"task": req.task, "max_steps": max_steps})

package/latticeai/api/hooks.py

@@ -8,7 +8,7 @@ the API.
 
 from __future__ import annotations
 
-from typing import Callable, List, Optional
+from typing import Any, Callable, List, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
@@ -46,7 +46,9 @@ def create_hooks_router(
     *,
     registry: HooksRegistry,
     require_user: Callable[[Request], str],
-    require_admin: Callable[[Request], tuple],
+    # Production returns ``(email, users)``; small adapters return just the
+    # identity, which ``_require_admin_email`` below handles.
+    require_admin: Callable[[Request], Any],
     append_audit_event: Callable[..., None],
 ) -> APIRouter:
     router = APIRouter()

package/latticeai/api/local_files.py

@@ -8,7 +8,7 @@ import time
 import uuid
 from datetime import datetime
 from pathlib import Path
-from typing import Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
 from fastapi.responses import FileResponse
@@ -132,11 +132,15 @@ def create_local_files_router(
                 errors.append(f"graph: {exc}")
 
         # ── watcher + connected sources (real) ────────────────────────────────
-        watch = local_kg_watcher.status() if local_kg_watcher else {"available": False, "active": {}}
-        sources = []
+        watch: Dict[str, Any] = (
+            local_kg_watcher.status()
+            if local_kg_watcher
+            else {"available": False, "active": {}}
+        )
+        sources: List[Any] = []
         try:
             if knowledge_graph is not None:
-                sources = (knowledge_graph.local_sources() or {}).get("sources", [])
+                sources = list((knowledge_graph.local_sources() or {}).get("sources") or [])
         except Exception as exc:
             errors.append(f"sources: {exc}")
         watched = len(watch.get("active", {}) or {})

package/latticeai/api/mcp.py

@@ -360,7 +360,7 @@ def create_mcp_router(
         require_user(request)
         mcp_registry._SKILLS_MARKETPLACE_FETCHED_AT = None
         skills = await _fetch_skills_marketplace()
-        by_author = {}
+        by_author: Dict[str, int] = {}
         for s in skills:
             by_author[s["author"]] = by_author.get(s["author"], 0) + 1
         return {"status": "ok", "total": len(skills), "by_author": by_author}
@@ -399,7 +399,7 @@ def create_mcp_router(
         require_user(request)
         mcp_registry._PLUGIN_DIRECTORY_FETCHED_AT = None
         plugins = await _fetch_plugin_directory()
-        by_license = {}
+        by_license: Dict[str, int] = {}
         for p in plugins:
             lic = p.get("license", "unknown")
             by_license[lic] = by_license.get(lic, 0) + 1

package/latticeai/api/models.py

@@ -155,25 +155,25 @@ def create_models_router(
 
     def _recommended_with_engine_options(
         items: List[Dict[str, object]],
-        engines: Optional[List[Dict[str, object]]] = None,
+        engines: Optional[List[Dict[str, Any]]] = None,
         loaded_ids: Optional[List[str]] = None,
         current_id: Optional[str] = None,
     ) -> List[Dict[str, object]]:
         from latticeai.core.model_compat import model_runtime_compatibility
 
         engine_lookup = {str(engine.get("id") or ""): engine for engine in engines or []}
-        model_lookup: Dict[str, Dict[str, object]] = {}
+        model_lookup: Dict[str, Dict[str, Any]] = {}
         for engine in engines or []:
             engine_id = str(engine.get("id") or "")
-            for model in engine.get("models") or []:
+            for model in list(engine.get("models") or []):
                 if isinstance(model, dict):
                     model_lookup[str(model.get("id") or "")] = {**model, "_engine": engine_id}
         loaded = set(loaded_ids or [])
-        out: List[Dict[str, object]] = []
+        out: List[Dict[str, Any]] = []
         for item in items:
             short_id = str(item["id"]).lower()
             aliases = MODEL_ENGINE_ALIASES.get(short_id) or {}
-            options: List[Dict[str, object]] = []
+            options: List[Dict[str, Any]] = []
             for engine_name in ("local_mlx", "ollama", "lmstudio", "llamacpp", "vllm"):
                 real = aliases.get(engine_name)
                 if not real: