ltcai 11.7.0 → 11.9.0

package/latticeai/core/security.py

@@ -1,9 +1,27 @@
-"""Password hashing, rate limiting, IP detection, file-magic validation."""
+"""Token hashing, secret redaction, and the worker's per-user rate limiter.
+
+What is *not* here any more, and why: password hashing / verification, the
+``client_ip`` resolver with its per-IP login limiter, and the file-magic
+extension check were all ported to ``lattice-auth`` / ``lattice-chat`` in
+v11.6.0, when the front door and every write moved to Rust. They were left
+behind as fully orphaned Python — no route, no service, no script called them
+— and a second copy of an authentication rule that nothing enforces is worse
+than no copy: it reads like a live guard.
+
+What stays, stays because something still calls it:
+
+* :func:`enforce_rate_limit` — charged by every ``/worker/*`` and ``/agent/*``
+  seam through ``_admit``.
+* :func:`redact_secret_text` / :func:`redact_secrets` — and they additionally
+  generate the Rust redaction fixture via ``scripts/gen_redact_fixture.py``.
+* the trusted-proxy allowlist — ``_peer_is_trusted_proxy`` is what
+  :mod:`latticeai.core.http_origin` (and through it the CSRF check) asks before
+  believing an ``X-Forwarded-Host``.
+"""
 
 import hashlib
 import ipaddress
 import re
-import secrets
 import threading
 import time
 from typing import Any, Dict, List
@@ -26,21 +44,6 @@ def sha256_hex(text: str) -> str:
     return hashlib.sha256(text.encode("utf-8")).hexdigest()
 
 
-def hash_password(password: str) -> str:
-    salt = secrets.token_hex(16)
-    key = hashlib.scrypt(password.encode(), salt=salt.encode(), n=16384, r=8, p=1)
-    return f"{salt}:{key.hex()}"
-
-
-def verify_password(password: str, hashed: str) -> bool:
-    try:
-        salt, key_hex = hashed.split(":", 1)
-        key = hashlib.scrypt(password.encode(), salt=salt.encode(), n=16384, r=8, p=1)
-        return secrets.compare_digest(key.hex(), key_hex)
-    except Exception:
-        return False
-
-
 def host_is_loopback(host: str) -> bool:
     if host in {"localhost", "127.0.0.1", "::1"}:
         return True
@@ -50,15 +53,15 @@ def host_is_loopback(host: str) -> bool:
         return False
 
 
-# ── Trusted-proxy handling ────────────────────────────────────────────────────
-# ``client_ip`` is the key used for IP rate limiting (login / register) and for
-# audit logging. A forwarded header (``X-Forwarded-For`` / ``CF-Connecting-IP``)
-# is *client-controllable*, so honoring it unconditionally lets anyone spoof
-# their source IP and bypass per-IP rate limits. We therefore trust those headers
-# ONLY when the direct peer is a configured trusted proxy (e.g. the Cloudflare /
-# Vercel edge in front of the app). Default: no trusted proxies → use the peer
-# address, which is the safe, local-first behaviour.
-_FORWARDED_HEADERS = ("CF-Connecting-IP", "X-Forwarded-For")
+# ── Trusted-proxy allowlist ──────────────────────────────────────────────────
+# The per-IP login limiter this list was born for is ``lattice-auth``'s now, and
+# ``client_ip`` went with it. The list itself is still load-bearing on this
+# side: :func:`latticeai.core.http_origin.peer_may_forward` — and through it the
+# CSRF front-door check — asks ``_peer_is_trusted_proxy`` whether an
+# ``X-Forwarded-Host`` from this peer may be believed. Off loopback the answer
+# is "only for an operator-listed proxy", which is what makes forging a front
+# door from another machine impossible. ``configure_trusted_proxies`` is the one
+# way that list is ever non-empty, so it stays with the guard it feeds.
 _trusted_proxies: List["ipaddress._BaseNetwork"] = []
 
 
@@ -96,46 +99,6 @@ def _peer_is_trusted_proxy(peer: str) -> bool:
     return any(addr in net for net in _trusted_proxies)
 
 
-def client_ip(request) -> str:
-    peer = request.client.host if request.client else ""
-    # Only a trusted proxy's forwarded headers are honoured; otherwise the
-    # client-supplied header is ignored so per-IP rate limits cannot be spoofed.
-    if _peer_is_trusted_proxy(peer):
-        for header in _FORWARDED_HEADERS:
-            val = request.headers.get(header)
-            if val:
-                candidate = val.split(",")[0].strip()
-                try:
-                    ipaddress.ip_address(candidate)
-                    return candidate
-                except ValueError:
-                    quiet()
-                    continue
-    return peer or "unknown"
-
-
-_FILE_MAGIC: Dict[str, List[bytes]] = {
-    ".pdf":  [b"%PDF-"],
-    ".docx": [b"PK\x03\x04"],
-    ".xlsx": [b"PK\x03\x04"],
-    ".pptx": [b"PK\x03\x04"],
-    ".zip":  [b"PK\x03\x04", b"PK\x05\x06", b"PK\x07\x08"],
-    ".png":  [b"\x89PNG\r\n\x1a\n"],
-    ".jpg":  [b"\xff\xd8\xff"],
-    ".jpeg": [b"\xff\xd8\xff"],
-    ".gif":  [b"GIF87a", b"GIF89a"],
-}
-
-
-def bytes_match_extension(data: bytes, ext: str) -> bool:
-    ext = (ext or "").lower()
-    signatures = _FILE_MAGIC.get(ext)
-    if not signatures:
-        return True
-    head = data[:16]
-    return any(head.startswith(sig) for sig in signatures)
-
-
 SECRET_KEY_HINTS = (
     "api_key",
     "apikey",
@@ -209,23 +172,6 @@ def redact_secrets(value: Any) -> Any:
     return value
 
 
-# ── IP-based rate limiting (registration / login) ────────────────────────────
-_ip_rate_windows: dict = {}
-_ip_rate_lock = threading.Lock()
-
-
-def check_ip_rate_limit(ip: str, action: str, max_calls: int, window_secs: float) -> None:
-    key = (ip, action)
-    now = time.time()
-    cutoff = now - window_secs
-    with _ip_rate_lock:
-        calls = [t for t in _ip_rate_windows.get(key, []) if t > cutoff]
-        if len(calls) >= max_calls:
-            raise HTTPException(status_code=429, detail="요청이 너무 많습니다. 잠시 후 다시 시도하세요.")
-        calls.append(now)
-        _ip_rate_windows[key] = calls
-
-
 # ── Per-user token-bucket rate limiting ──────────────────────────────────────
 _RATE_LIMITS = {
     "chat":   (30, 0.5),

package/latticeai/core/sessions.py

@@ -4,6 +4,21 @@ v4: bearer tokens are stored **hashed** (sha256) at rest — a process that can
 read ``sessions.json`` must not be able to hijack every session. Pre-v4 files
 holding raw tokens are migrated transparently on load (sessions survive the
 upgrade; the raw token never touches disk again).
+
+11.8.0: the in-memory map is a **cache of the file, not the file itself.**
+Since v11.6.0 the writer is ``lattice-auth``: it creates the session and
+appends it to ``sessions.json``, and this process only ever reads. Loading
+once in ``__init__`` therefore made every login that happened after worker
+boot invisible here — silently under ``trusted_local_owner`` (the anonymous
+owner path answers first), and as a flat 401 under
+``LATTICEAI_REQUIRE_AUTH=true``, for a token that is sitting in the file.
+
+A lookup that misses now re-reads the file before giving up. Two guards keep
+that from turning a token-guessing burst into a disk-read burst: the re-read
+is skipped when the file's ``mtime_ns``/``size`` are unchanged since the last
+load, and — for a file that *is* changing — throttled to one parse per
+``SESSION_RELOAD_MIN_INTERVAL``. Both are checked under the same lock that
+guards the map, so concurrent misses collapse into one read.
 """
 
 import json
@@ -19,6 +34,11 @@ from latticeai.core.security import sha256_hex
 
 SESSION_TTL = 60 * 60 * 24  # 24 hours
 SESSION_REFRESH_THRESHOLD = 60 * 15  # only persist if >15 min since last bump
+#: Floor between two miss-triggered re-reads of ``sessions.json``. A wrong or
+#: expired token is the common case for an unauthenticated probe, and each one
+#: misses; without a floor a burst of them would be a burst of file reads.
+#: Well under any human's retry, so a real login is still picked up at once.
+SESSION_RELOAD_MIN_INTERVAL = 1.0
 _lock = threading.Lock()
 
 _HEX64 = frozenset("0123456789abcdef")
@@ -79,6 +99,19 @@ def persist_sessions(sessions: Dict[str, tuple], data_dir: Optional[Path] = None
         logging.warning("persist_sessions failed: %s", e)
 
 
+def _sessions_stamp(data_dir: Optional[Path] = None) -> Optional[tuple]:
+    """``(mtime_ns, size)`` of ``sessions.json``, or ``None`` when unreadable.
+
+    ``None`` is *not* "unchanged": a file that has just appeared and one that
+    was just removed both need the map rebuilt, and both land here.
+    """
+    try:
+        stat = _sessions_file(data_dir).stat()
+    except OSError:
+        return None
+    return (stat.st_mtime_ns, stat.st_size)
+
+
 def _entry_subject(entry: tuple) -> Optional[str]:
     return entry[0] if entry else None
 
@@ -107,12 +140,63 @@ class SessionStore:
         self._ttl_seconds = int(ttl_seconds or SESSION_TTL)
         self._refresh_threshold_seconds = int(refresh_threshold_seconds or SESSION_REFRESH_THRESHOLD)
         self._sessions: Dict[str, tuple] = load_sessions(data_dir)
+        # Stamped *after* the load, so a pre-v4 file that ``load_sessions``
+        # rewrote on the way in is not mistaken for a foreign write.
+        self._loaded_stamp: Optional[tuple] = _sessions_stamp(data_dir)
+        # ``-inf`` and not "now": the first *changed* file must be free to
+        # load, or a login that lands in the same second as the worker's boot
+        # stays invisible for a second for no reason.
+        self._last_reload_at: float = float("-inf")
+
+    def _reload_if_stale(self, *, force: bool = False) -> bool:
+        """Re-read ``sessions.json`` when it has changed. Caller holds ``_lock``.
+
+        Returns whether the map was replaced. The two guards answer two
+        different costs, in the order that keeps both cheap:
+
+        * the **stamp** runs first and on every miss. It is one ``stat``, and
+          when the file has not moved — the overwhelming case, since a wrong
+          token is what an unauthenticated probe sends — that is the entire
+          cost. No parse, no allocation.
+        * the **interval** runs only once the file *has* moved, and bounds how
+          often a busy file is actually parsed. It never drops the change: the
+          stamp is recorded only when the load really happened, so the next
+          miss past the interval still sees the file as new.
+
+        ``force`` skips the interval only. It is for the two paths that are
+        about to *write* the file: a throttled read there would merge onto a
+        stale map and drop somebody else's session, and a login or a logout is
+        rare enough that the read costs nothing worth counting.
+        """
+        stamp = _sessions_stamp(self._data_dir)
+        if stamp == self._loaded_stamp:
+            return False
+        now = time.monotonic()
+        if not force and now - self._last_reload_at < SESSION_RELOAD_MIN_INTERVAL:
+            return False
+        self._last_reload_at = now
+        self._sessions = load_sessions(self._data_dir)
+        self._loaded_stamp = stamp
+        return True
+
+    def _persist(self) -> None:
+        """Write the map, then re-stamp. Caller holds ``_lock``.
+
+        Re-stamping matters: without it our own write looks like somebody
+        else's the next time a lookup misses, and the store re-reads the file
+        it just produced.
+        """
+        persist_sessions(self._sessions, self._data_dir)
+        self._loaded_stamp = _sessions_stamp(self._data_dir)
 
     def create(self, subject: str, *, email: Optional[str] = None) -> str:
         token = secrets.token_urlsafe(32)
         with _lock:
+            # Merge onto whatever is on disk rather than over it — this process
+            # is not the only writer.
+            self._reload_if_stale(force=True)
             self._sessions[_hash_token(token)] = (subject, time.time(), email or subject)
-            persist_sessions(self._sessions, self._data_dir)
+            self._persist()
         return token
 
     def get_email(self, token: str) -> Optional[str]:
@@ -128,21 +212,28 @@ class SessionStore:
         key = _hash_token(token)
         with _lock:
             entry = self._sessions.get(key)
+            if entry is None and self._reload_if_stale():
+                # A miss is the only thing that can be wrong because the map is
+                # stale: an entry we *do* hold was really issued, and one we
+                # hold that the file no longer has is handled by the TTL and by
+                # ``active_session_email``'s account check on every request.
+                entry = self._sessions.get(key)
             if entry is None:
                 return None
             created_at = _entry_created_at(entry)
             if now - created_at > self._ttl_seconds:
                 self._sessions.pop(key, None)
-                persist_sessions(self._sessions, self._data_dir)
+                self._persist()
                 return None
             if now - created_at > self._refresh_threshold_seconds:
                 refreshed = (_entry_subject(entry), now, _entry_email(entry))
                 self._sessions[key] = refreshed
-                persist_sessions(self._sessions, self._data_dir)
+                self._persist()
                 return refreshed
             return entry
 
     def invalidate(self, token: str) -> None:
         with _lock:
+            self._reload_if_stale(force=True)
             self._sessions.pop(_hash_token(token), None)
-            persist_sessions(self._sessions, self._data_dir)
+            self._persist()

package/latticeai/core/users.py

@@ -4,9 +4,7 @@ from __future__ import annotations
 
 import json
 import shutil
-import sqlite3
 import uuid
-from contextlib import closing
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -83,11 +81,6 @@ def load_users_file(path: Path) -> Dict[str, Any]:
     return migrated
 
 
-def save_users_file(path: Path, users: Dict[str, Any]) -> None:
-    migrated, _, _ = migrate_users(users)
-    atomic_write_json(path, migrated)
-
-
 def user_id_for_email(users: Dict[str, Any], email: Optional[str]) -> Optional[str]:
     if not email:
         return None
@@ -98,34 +91,3 @@ def user_id_for_email(users: Dict[str, Any], email: Optional[str]) -> Optional[s
     if isinstance(user, dict):
         return user.get("id") or stable_user_id(normalized)
     return stable_user_id(normalized)
-
-
-def migrate_knowledge_graph_identity(db_path: Path, email_to_id: Dict[str, str]) -> int:
-    """Rewrite KG owner/creator identity columns from email to stable UUIDs."""
-    if not db_path.exists() or not email_to_id:
-        return 0
-    changed = 0
-    with closing(sqlite3.connect(db_path)) as conn, conn:
-        tables = {
-            row[0] for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")
-        }
-        for email, user_id in email_to_id.items():
-            normalized = normalize_email(email)
-            if "nodes_v2" in tables:
-                cur = conn.execute("UPDATE nodes_v2 SET owner_id=? WHERE LOWER(owner_id)=?", (user_id, normalized))
-                changed += cur.rowcount if cur.rowcount and cur.rowcount > 0 else 0
-            if "edges_v2" in tables:
-                cur = conn.execute("UPDATE edges_v2 SET created_by=? WHERE LOWER(created_by)=?", (user_id, normalized))
-                changed += cur.rowcount if cur.rowcount and cur.rowcount > 0 else 0
-            if "ingestion_provenance" in tables:
-                cur = conn.execute("UPDATE ingestion_provenance SET owner=? WHERE LOWER(owner)=?", (user_id, normalized))
-                changed += cur.rowcount if cur.rowcount and cur.rowcount > 0 else 0
-        if changed:
-            conn.execute(
-                "CREATE TABLE IF NOT EXISTS kg_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)"
-            )
-            conn.execute(
-                "INSERT OR REPLACE INTO kg_meta(key, value) VALUES('identity_uuid_migrated_at', ?)",
-                (_now(),),
-            )
-    return changed

package/latticeai/models/router/catalog.py

@@ -64,6 +64,6 @@ def parse_model_ref(model_id: str) -> tuple[str, str]:
             return provider, model
         if provider in {"local_mlx", "mlx"}:
             return "local_mlx", model
-    if model_id.startswith("local_mlx:"):
-        return "local_mlx", model_id.split(":", 1)[1]  # pragma: no cover — dead: a "local_mlx:" ref always has a ":" and returned above
+    # No trailing ``local_mlx:`` case: such a ref contains a colon, so it was
+    # already answered by the branch above.
     return "local_mlx", model_id

package/latticeai/models/router/generation.py

@@ -10,7 +10,7 @@ mistaken for the model's answer.
 import asyncio
 import base64
 import io
-from typing import Any, AsyncIterator, Optional
+from typing import Any, AsyncIterator, List, Optional
 
 from PIL import Image
 
@@ -20,7 +20,46 @@ from ._contract import RouterCore as _Core
 from .branding import SYSTEM_PROMPT, _compose_system, normalize_branding
 from .catalog import CloudModel
 from .errors import ModelStreamError, _stream_failure
-from .loading import _mlx_sampler, executor
+from .loading import _mlx_sampler, apply_stop_strings, executor
+
+
+def _stream_until_stop(
+    model,
+    tokenizer,
+    prompt: str,
+    image,
+    max_tokens: int,
+    sampler,
+    draft_model,
+    use_vlm: bool,
+    stops: List[str],
+) -> str:
+    """Generate on the worker thread, ending at the first stop string.
+
+    The buffered backends have no stop-string argument, so honouring one means
+    driving the *streaming* backend and breaking out of it. That is the whole
+    difference between a stop string and trimming the answer afterwards: the
+    tokens past the stop are never produced, which is time a 2B model would
+    otherwise spend explaining a tool call it has already emitted.
+
+    Runs inside :data:`executor`, like every other MLX call, so the GPU stream
+    stays on one thread.
+    """
+    if use_vlm:
+        from mlx_vlm import stream_generate as vlm_stream
+
+        chunks = vlm_stream(model, tokenizer, prompt=prompt, image=image, max_tokens=max_tokens, sampler=sampler, draft_model=draft_model, draft_kind="mtp")
+    else:
+        from mlx_lm import stream_generate as lm_stream
+
+        chunks = lm_stream(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=sampler, draft_model=draft_model)
+    text = ""
+    for chunk in chunks:
+        piece = chunk.text if hasattr(chunk, "text") else (chunk[0] if isinstance(chunk, tuple) else str(chunk))
+        text += piece
+        if any(marker in text for marker in stops):
+            break
+    return apply_stop_strings(text, stops)
 
 
 class _GenerationMixin(_Core):
@@ -65,12 +104,22 @@ class _GenerationMixin(_Core):
         max_tokens: int = 4096,
         temperature: float = 0.2,
         image_data: Optional[str] = None,
+        stop: Optional[List[str]] = None,
     ) -> str:
-        """Generate with a request-scoped model without changing the default."""
+        """Generate with a request-scoped model without changing the default.
+
+        ``stop`` ends the reply at the first of the given strings. Local
+        generation switches to the streaming backend to do it, so the tokens
+        after the stop are never produced rather than merely trimmed; the cloud
+        path forwards the list to the provider, which stops server-side. Absent
+        or empty means what it always meant — generate to ``max_tokens``.
+        """
         _selected, cached = self._model_snapshot(model_id)
         if cached is None:
             return "No model."
-        return await self._generate_cached(cached, message, context, max_tokens, temperature, image_data)
+        return await self._generate_cached(
+            cached, message, context, max_tokens, temperature, image_data, stop
+        )
 
     async def generate(
         self,
@@ -79,8 +128,11 @@ class _GenerationMixin(_Core):
         max_tokens: int = 4096,
         temperature: float = 0.2,
         image_data: Optional[str] = None,
+        stop: Optional[List[str]] = None,
     ) -> str:
-        return await self.generate_as(None, message, context, max_tokens, temperature, image_data)
+        return await self.generate_as(
+            None, message, context, max_tokens, temperature, image_data, stop
+        )
 
     async def _generate_cached(
         self,
@@ -90,9 +142,12 @@ class _GenerationMixin(_Core):
         max_tokens: int,
         temperature: float,
         image_data: Optional[str],
+        stop: Optional[List[str]] = None,
     ) -> str:
         if isinstance(cached, CloudModel):
-            return await self._cloud_generate(cached, message, context, max_tokens, temperature)
+            return await self._cloud_generate(
+                cached, message, context, max_tokens, temperature, stop
+            )
 
         model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(cached)
         use_vlm = loader_kind == "mlx_vlm"
@@ -101,27 +156,38 @@ class _GenerationMixin(_Core):
             if use_vlm
             else self._build_prompt(message, context, tokenizer)
         )
-        
+        stops = [marker for marker in (stop or []) if marker]
+
         loop = asyncio.get_event_loop()
-        
+
         def _gen():
             import mlx.core as mx  # type: ignore[no-redef]
 
             mx.set_default_device(mx.gpu)  # type: ignore[arg-type]
+            # Decoded here, not above: base64 + PIL is CPU work, and this
+            # function is the part that runs off the event loop.
+            image = self._prep_image(image_data) if image_data else None
+            sampler = _mlx_sampler(temperature)
+            if stops:
+                return _stream_until_stop(
+                    model, tokenizer, prompt, image, max_tokens, sampler, draft_model,
+                    use_vlm, stops,
+                )
             if use_vlm:
                 from mlx_vlm import generate as vlm_gen
-                return vlm_gen(model, tokenizer, prompt=prompt, image=self._prep_image(image_data) if image_data else None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+                return vlm_gen(model, tokenizer, prompt=prompt, image=image, max_tokens=max_tokens, sampler=sampler, draft_model=draft_model, draft_kind="mtp")
             from mlx_lm import generate as lm_gen
-            return lm_gen(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model)
+            return lm_gen(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=sampler, draft_model=draft_model)
         result = await loop.run_in_executor(executor, _gen)
         # mlx-vlm might return a GenerationResult object; extract the text
-        if hasattr(result, "text"):
-            return normalize_branding(result.text)
-        return normalize_branding(str(result))
+        text = result.text if hasattr(result, "text") else str(result)
+        return normalize_branding(apply_stop_strings(text, stops))
 
-    async def _cloud_generate(self, cloud: CloudModel, message: str, context: Optional[str], max_tokens: int, temperature: float) -> str:
+    async def _cloud_generate(self, cloud: CloudModel, message: str, context: Optional[str], max_tokens: int, temperature: float, stop: Optional[List[str]] = None) -> str:
         context = normalize_branding(context)
         system = _compose_system(SYSTEM_PROMPT, context)
+        stops = [marker for marker in (stop or []) if marker]
+        extra = {"stop": stops} if stops else {}
         try:
             response = await cloud.client.chat.completions.create(
                 model=cloud.model,
@@ -131,6 +197,7 @@ class _GenerationMixin(_Core):
                 ],
                 max_tokens=max_tokens,
                 temperature=temperature,
+                **extra,
             )
         except Exception as e:
             raise RuntimeError(self._local_server_error_hint(cloud, e)) from e

package/latticeai/models/router/loading.py

@@ -25,6 +25,7 @@ import gc
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Dict, List, Optional
 
+from latticeai.core.quiet import quiet
 from latticeai.models.model_providers import (
     OPENAI_COMPATIBLE_PROVIDERS,
     PROVIDER_MODEL_CATALOG,
@@ -120,12 +121,47 @@ def ensure_mlx_runtime() -> None:
 def _mlx_sampler(temperature: float):
     """Build an MLX sampler callable for the given temperature.
 
-    Lattice v2.2 keeps local execution on MLX-VLM only. Returning ``None`` lets
-    MLX-VLM use its bundled default sampler without pulling another generation
-    package into the runtime contract.
+    Until v11.9.0 this discarded its argument and returned ``None``, which let
+    MLX pick its own default sampler. The cost was invisible and large: the
+    agent loop asks for 0.1 when it wants a tool call and 0.0 on the strict
+    verification re-ask, and **locally neither did anything**. A cloud model got
+    the deterministic re-ask it was designed around; the 2B model on this
+    machine got the same creative sampler it had on the first attempt, and the
+    "one strict retry" was one more roll of the same dice.
+
+    ``mlx_lm.sample_utils.make_sampler`` is the sampler both backends accept —
+    ``mlx_vlm`` takes the callable straight through — and it is already an
+    installed dependency of the text path. If it cannot be imported (an
+    MLX-VLM-only install, a version that moved it) the answer is the old one:
+    ``None``, the backend's default. A missing sampler must never be a failed
+    generation.
     """
-    _ = temperature
-    return
+    try:
+        from mlx_lm.sample_utils import make_sampler
+    except Exception:  # noqa: BLE001 — an absent sampler is not a failure
+        quiet("MLX sampler unavailable; using the backend default")
+        return None
+    try:
+        return make_sampler(temp=float(temperature))
+    except Exception:  # noqa: BLE001 — a signature change must not stop a run
+        quiet("MLX sampler construction failed; using the backend default")
+        return None
+
+
+def apply_stop_strings(text: str, stop: Optional[List[str]]) -> str:
+    """Cut ``text`` at the earliest stop string, if any is present.
+
+    Shared by the buffered and streaming local paths so "where does this reply
+    end" has one answer. Empty stop strings are ignored: a caller that sends
+    ``""`` means "no stop", not "stop before the first character".
+    """
+    if not stop:
+        return text
+    cut = min(
+        (text.index(marker) for marker in stop if marker and marker in text),
+        default=-1,
+    )
+    return text if cut < 0 else text[:cut]
 
 
 class _LoadingMixin(_Core):

package/latticeai/runtime/access_runtime.py

@@ -45,8 +45,10 @@ def build_access_runtime(
     # extend this trust to public or non-loopback bindings, even if an invalid
     # caller constructs this runtime with ``require_auth=False`` directly.
     externally_reachable = is_externally_reachable(config)
+    # One flag, not two: "authentication is required" is exactly
+    # ``not trusted_local_owner``, so deriving it separately only creates a
+    # pair that a later edit can put out of step.
     trusted_local_owner = not require_auth and not externally_reachable
-    effective_require_auth = bool(require_auth or externally_reachable)
 
     def get_user_role(email: str, users: Optional[Dict] = None) -> str:
         users = users or load_users()
@@ -128,9 +130,10 @@ def build_access_runtime(
             # shared local vaults, and Local User profile behavior compatible;
             # get_user_role() supplies the explicit owner authorization role.
             return ""
-        if effective_require_auth and not email:
-            raise http_exception(status_code=401, detail="인증이 필요합니다.")
-        return email or ""  # pragma: no cover — unreachable: trusted_local_owner is the exact complement of effective_require_auth
+        # Reaching here means the caller is not the trusted local owner and no
+        # session produced an email — i.e. authentication is required and was
+        # not supplied. There is no third outcome to fall through to.
+        raise http_exception(status_code=401, detail="인증이 필요합니다.")
 
     def require_admin(request: request_type) -> tuple[str, Dict]:
         users = load_users()