ltcai 11.7.0 → 12.0.0

package/latticeai/api/agent_worker_seam.py

@@ -53,7 +53,7 @@ from __future__ import annotations
 
 import asyncio
 import os
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel, Field
@@ -78,6 +78,16 @@ MAX_MAX_TOKENS = 8192
 MIN_TEMPERATURE = 0.0
 MAX_TEMPERATURE = 2.0
 
+#: How many stop strings one completion may name. The kernel sends two.
+MAX_STOP_STRINGS = 8
+
+#: Longest forced completion prefix one call may name (v12.0.0). The prefix is
+#: prepended to the prompt, so an unbounded one is an unbounded prompt. The
+#: kernel sends two, and both are short: the executor's opening brace
+#: (``{"thoughts": "``) and the guided menu's answer label — a few dozen
+#: characters between them, and nothing legitimate needs a paragraph.
+MAX_PREFIX_CHARS = 256
+
 #: Rate-limit bucket. Deliberately *not* the ``"agent"`` bucket ``/agent`` uses:
 #: that one is sized per *run* (10 burst, one refill per 10s) because one HTTP
 #: call there is a whole agent run. Here one call is a single loop step, and a
@@ -101,6 +111,26 @@ class AgentLLMRequest(BaseModel):
     context: Optional[str] = None
     max_tokens: int = 4096
     temperature: float = 0.2
+    #: Strings that end the reply (v11.9.0). Optional, and absent means what it
+    #: always meant: generate to ``max_tokens``. The kernel sends it on exactly
+    #: one call — the strict verification re-ask, whose reply is one short
+    #: closed object — because a stop string that is safe there ("\n```") would
+    #: truncate any reply carrying file content. Bounded so a caller cannot make
+    #: the sampler check a thousand needles per token.
+    stop: Optional[List[str]] = Field(default=None, max_length=MAX_STOP_STRINGS)
+    #: Characters the reply is **forced to begin with** (v12.0.0).
+    #:
+    #: The cheapest structural guarantee the seam can offer: instead of asking
+    #: a weak model to start at ``{`` and repairing the markdown fence it emits
+    #: instead, the worker prefills those characters and the model continues
+    #: from them. The response's ``text`` always starts with the prefix, so a
+    #: caller reads one shape whether the local prefill or a cloud provider's
+    #: assistant-prefill message produced it.
+    #:
+    #: Bounded because it is prepended to the prompt: an unbounded prefix would
+    #: be an unbounded prompt on the single MLX executor. The kernel sends
+    #: fourteen characters.
+    prefix: Optional[str] = Field(default=None, max_length=MAX_PREFIX_CHARS)
 
 
 class AgentToolRequest(BaseModel):
@@ -247,6 +277,18 @@ def create_agent_worker_seam_router(
             context=req.context,
             max_tokens=req.max_tokens,
             temperature=req.temperature,
+            stop=req.stop or None,
+            prefix=req.prefix or None,
+            # **The seam's ``context`` is a prompt, not a corpus** (v12.0.0).
+            # ``_compose_system`` appends the citation mandate to any non-empty
+            # context, which is right for chat (where it really is retrieved
+            # passages) and wrong here: the Rust kernel sends its whole executor
+            # prompt as ``context``, so every agent turn was being told its own
+            # instructions were sources to "cite inline as [1], [2]". Small
+            # models obey that — a 0.5B wrote ``[1] …`` into a file and a 2B
+            # answered a tool call with the citation instruction. A caller that
+            # wants citations puts them in its own prompt.
+            cite_sources=False,
         )
         return {"text": str(text)}
 
@@ -305,6 +347,7 @@ def create_agent_worker_seam_router(
 
 __all__ = [
     "MAX_MAX_TOKENS",
+    "MAX_PREFIX_CHARS",
     "MAX_TEMPERATURE",
     "MIN_MAX_TOKENS",
     "MIN_TEMPERATURE",

package/latticeai/api/models.py

@@ -2,15 +2,24 @@
 
 Extracted from ``server_app.py`` in v1.3.0 with the whole ``/models*`` +
 ``/engines*`` + ``/setup/set-api-key`` surface. v11.6.0 kept the eight routes
-that are *this interpreter's* business — loading, switching and unloading MLX
-models, and the resolve → download-if-consented → load → smoke prepare flow —
-and moved the rest to ``lattice-host``: engine installation and cloud-key
-verification are host operations, ``/setup/set-api-key`` is account state, and
-the two catalogue reads (``/models/compat-profiles``, ``/models/recommendations``)
-are product views.
+that are *this interpreter's* business and moved the rest to ``lattice-host``:
+engine installation and cloud-key verification are host operations,
+``/setup/set-api-key`` is account state, and the two catalogue reads
+(``/models/compat-profiles``, ``/models/recommendations``) are product views.
 
-The download itself stays because it is ``huggingface_hub`` / ``ollama``
-running here (v11.6.0 gateway integration §4a).
+v11.8.0 took three of those eight away, because nothing called them — not the
+Rust surface, not the SPA client, not either extension:
+
+* ``POST /engines/pull-model`` — every caller reaches a download through
+  ``/engines/prepare-model``, which resolves, downloads on consent, loads and
+  smoke-tests in one step. The bare pull was the older door, and with it went
+  this module's only use of ``huggingface_hub`` / ``ollama`` (both still run
+  here, under ``services/model_loading.py``, for the prepare flow).
+* ``POST /models/switch/{model_id:path}`` — ``/models/load`` is what every
+  surface sends, and it switches as part of loading.
+* ``DELETE /models/unload-all`` — unloading is per-model everywhere.
+
+What is left is list, load, unload-one and the two prepare flows.
 
 Mirrors the established router-factory convention: the heavy provider/runtime
 helpers are injected as bound service callables. This module owns the sole
@@ -21,14 +30,13 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import subprocess
 from typing import Any, Callable, Dict, List, NoReturn, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
-from latticeai.core.messages import http_error, resolve_language, translate
+from latticeai.core.messages import http_error, resolve_language
 from latticeai.services.model_errors import ModelRuntimeError
 
 
@@ -76,11 +84,6 @@ class LoadModelRequest(BaseModel):
 
 
 
-class PullModelRequest(BaseModel):
-    model: str
-    allow_download: bool = False
-
-
 class PrepareModelRequest(BaseModel):
     model: str
     engine: Optional[str] = None
@@ -94,13 +97,9 @@ def create_models_router(
     model_router: Any,
     require_user: Callable[[Request], str],
     require_admin: Callable[[Request], tuple],
-    normalize_local_model_request: Callable[..., str],
-    download_hf_model: Callable[..., Dict],
     prepare_and_load_model: Callable[..., Any],
     prepare_and_load_model_stream: Callable[..., Any],
     sse_event: Callable[[str, Dict], str],
-    ensure_ollama_server: Callable[[], None],
-    local_binary: Callable[[str], Optional[str]],
     engine_status: Callable[[], List[Dict]],
     filter_lower_family_versions: Callable[[List[Dict]], List[Dict]],
     list_compat_profiles: Callable[[], Any],
@@ -289,80 +288,6 @@ def create_models_router(
 
     # ── Engines ───────────────────────────────────────────────────────────
 
-
-    @router.post("/engines/pull-model")
-    async def pull_ollama_model(req: PullModelRequest, request: Request):
-        _authorize_model_admin(request)
-        if not req.allow_download:
-            raise HTTPException(
-                status_code=403,
-                detail=translate("models.download_consent_required", resolve_language(request)),
-            )
-        model_ref = normalize_local_model_request(req.model, None)
-        if not model_ref:
-            raise http_error(400, "models.identifier_empty", resolve_language(request))
-
-        if ":" in model_ref and model_ref.split(":", 1)[0].strip().lower() in {"ollama", "vllm", "lmstudio", "llamacpp", "local_mlx", "mlx"}:
-            provider, model_name = model_ref.split(":", 1)
-            provider = provider.strip().lower()
-            model_name = model_name.strip()
-        else:
-            provider, model_name = "local_mlx", model_ref
-
-        if not model_name:
-            raise http_error(400, "models.name_empty", resolve_language(request))
-
-        if provider == "ollama":
-            try:
-                # Starts the daemon and waits for it — blocking, like the pull
-                # below, and for the same reason it may not run on the loop.
-                await asyncio.to_thread(ensure_ollama_server)
-            except ModelRuntimeError as exc:
-                _raise_model_http(exc)
-            ollama = local_binary("ollama")
-            if not ollama:
-                raise http_error(400, "models.ollama_missing", resolve_language(request))
-            try:
-                # A model pull is minutes of network I/O. Held on the event loop
-                # it stalled every other request — including the health check the
-                # UI uses to decide the server is alive — until the pull finished.
-                completed = await asyncio.to_thread(
-                    lambda: subprocess.run(
-                        [ollama, "pull", model_name],
-                        capture_output=True, text=True, timeout=900, check=False,
-                    )
-                )
-            except subprocess.TimeoutExpired:
-                raise http_error(408, "models.download_timeout", resolve_language(request))
-            if completed.returncode != 0:
-                raise HTTPException(
-                    status_code=500,
-                    detail=completed.stderr[-2000:]
-                    or translate("models.pull_failed", resolve_language(request)),
-                )
-            return {"provider": provider, "model": model_name, "returncode": completed.returncode}
-
-        if provider == "lmstudio":
-            raise HTTPException(
-                status_code=400,
-                detail=(
-                    "LM Studio 모델은 Lattice에서 Hugging Face로 pull하지 않습니다. "
-                    "LM Studio 앱에서 모델을 다운로드하고 Local Server를 켠 뒤 모델을 로드하세요. "
-                    "그러면 모델 선택창에 실제 /v1/models 항목이 표시됩니다."
-                ),
-            )
-
-        if provider in {"vllm", "llamacpp", "local_mlx", "mlx"}:
-            download_provider = "local_mlx" if provider == "mlx" else provider
-            try:
-                # Multi-gigabyte Hugging Face download; same rule as the pull above.
-                result = await asyncio.to_thread(download_hf_model, model_name, download_provider)
-            except ModelRuntimeError as exc:
-                _raise_model_http(exc)
-            return {"provider": provider, "model": model_name, "returncode": 0, **result}
-
-        raise http_error(400, "models.download_not_automated", resolve_language(request), provider=provider)  # pragma: no cover — every prefix the check above accepts is handled, and the fallback is local_mlx
-
     @router.post("/engines/prepare-model")
     async def engines_prepare_model(req: PrepareModelRequest, request: Request):
         current_user = _authorize_model_admin(request, req.user_email)
@@ -484,27 +409,10 @@ def create_models_router(
                 detail=friendly_model_runtime_error(e, model_id=req.model_id, engine=req.engine),
             )
 
-    @router.post("/models/switch/{model_id:path}")
-    async def switch_model(model_id: str, request: Request):
-        _authorize_model_admin(request)
-        try:
-            _router.switch_model(model_id)
-            return {"status": "ok", "current": _router.current_model_id}
-        except KeyError:
-            raise http_error(404, "chat.model_not_loaded", resolve_language(request), model=model_id)
-
     @router.delete("/models/unload/{model_id:path}")
     async def unload_model(model_id: str, request: Request):
         _authorize_model_admin(request)
         _router.unload_model(model_id)
         return {"status": "ok", "unloaded": model_id}
 
-    @router.delete("/models/unload-all")
-    async def unload_all_models(request: Request):
-        _authorize_model_admin(request)
-        unloaded = _router.loaded_model_ids
-        _router.unload_all()
-        return {"status": "ok", "unloaded": unloaded}
-
-
     return router

package/latticeai/api/search.py

@@ -10,6 +10,11 @@ it is the one that was asked for.
 ``GET /api/embeddings/status`` therefore reports the **embedder**, not the
 index. Index completeness is a native jobs route now, and reporting it from
 here would have meant re-opening a store the worker no longer holds.
+
+It is now the module's only route. ``GET /api/embeddings/providers`` — the
+static catalogue of provider ids and the env vars each needs — was removed in
+v11.8.0: no surface in the tree asked for it, and a catalogue nothing reads is
+a second place for the provider list to go stale.
 """
 
 from __future__ import annotations
@@ -18,7 +23,6 @@ from typing import Any, Callable, Dict, NoReturn, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 
-from latticeai.core.embedding_providers import embedding_provider_profiles
 from latticeai.services.search_service import SearchService
 
 
@@ -31,8 +35,8 @@ def create_search_router(
     router = APIRouter()
 
     def _raise_embedder_error(exc: Exception) -> NoReturn:
-        # NoReturn, not None: both handlers end with this in their except
-        # branch, and without it each one reads as a missing return.
+        # NoReturn, not None: the handler ends with this in its except branch,
+        # and without it the function reads as a missing return.
         raise HTTPException(status_code=404, detail=str(exc)) from exc
 
     @router.get("/api/embeddings/status")
@@ -44,31 +48,4 @@ def create_search_router(
         except ValueError as exc:
             _raise_embedder_error(exc)
 
-    @router.get("/api/embeddings/providers")
-    async def embeddings_providers(request: Request) -> Dict[str, Any]:
-        require_user(request)
-        resolved = embedding_info() if embedding_info else {}
-        profiles = resolved.get("profiles") or embedding_provider_profiles()
-        return {
-            "active": resolved.get("active_provider"),
-            "requested": resolved.get("requested_provider"),
-            "profile": resolved.get("profile") or "",
-            "profiles": profiles,
-            "providers": [
-                {"id": "hash", "label": "Local hash (fallback)", "grade": "fallback",
-                 "requires": [], "detail": "Deterministic offline vectors — always available."},
-                {"id": "mlx", "label": "MLX (Apple Silicon)", "grade": "production",
-                 "requires": ["LATTICEAI_EMBEDDING_MODEL"], "detail": "Local embedding model via MLX."},
-                {"id": "ollama", "label": "Ollama", "grade": "production",
-                 "requires": ["LATTICEAI_EMBEDDING_MODEL", "LATTICEAI_EMBEDDING_BASE_URL"],
-                 "detail": "Local/remote Ollama embedding server."},
-                {"id": "openai", "label": "OpenAI-compatible", "grade": "production",
-                 "requires": ["LATTICEAI_EMBEDDING_MODEL", "LATTICEAI_EMBEDDING_BASE_URL", "LATTICEAI_EMBEDDING_API_KEY"],
-                 "detail": "Any /v1/embeddings endpoint (OpenAI, LM Studio, vLLM, …)."},
-                {"id": "custom", "label": "Custom callable", "grade": "production",
-                 "requires": ["LATTICEAI_EMBEDDING_CUSTOM_TARGET"],
-                 "detail": "User-supplied module:callable returning vectors."},
-            ],
-        }
-
     return router