superlocalmemory 3.8.1 → 3.8.3

package/src/superlocalmemory/server/routes/memories.py

@@ -19,6 +19,25 @@ from .helpers import (
 logger = logging.getLogger("superlocalmemory.routes.memories")
 router = APIRouter()
 
+# v3.8.3: GENEROUS latency budget for recall. SLM's value is quality recall
+# under heavy multi-agent load, so semantic recall is given ample time to
+# finish — the keyword fallback is a LAST-RESORT safety net for a genuine hang
+# (e.g. a wedged embedder), NOT an aggressive speed cutoff. Only if recall
+# exceeds this budget do we serve the fast keyword search so the caller ALWAYS
+# gets a result instead of hanging forever. Tune with SLM_SEARCH_RECALL_TIMEOUT_S.
+# The dashboard's fetch timeout is set ABOVE this so the browser waits for the
+# quality result rather than aborting early.
+_DEFAULT_RECALL_BUDGET_S = 25.0
+
+
+def _search_recall_timeout_s() -> float:
+    import os
+    try:
+        v = float(os.environ.get("SLM_SEARCH_RECALL_TIMEOUT_S", ""))
+        return v if v > 0 else _DEFAULT_RECALL_BUDGET_S
+    except (TypeError, ValueError):
+        return _DEFAULT_RECALL_BUDGET_S
+
 
 def _internal_error(detail: str = "Internal server error") -> HTTPException:
     """SEC-H-02: log the full traceback server-side; return a generic message.
@@ -507,9 +526,14 @@ async def search_memories(request: Request, body: SearchRequest):
         # a stalled connection and aborts with "signal is aborted without reason"
         # before the response arrives. Fix: run in a thread-pool executor so the
         # event loop stays alive to send keepalive frames.
-        # v3.4.64 (regression fix): fast=True skips spreading_activation + agentic
-        # LLM rounds (saves ~7s on cold graph traversal). fast=False is the SLOW
-        # path that enables both; the earlier comment had this inverted.
+        # v3.8.2: fast=True — the dashboard search BOX is a snappy retrieval
+        # list (all six local channels + reranker), never the internal agentic
+        # LLM round, which would reintroduce the multi-second hang this endpoint
+        # is regression-tested against (test_search_fast_param_and_profile_isolation).
+        # The human-facing LLM synthesis lives on separate paths that are NOT the
+        # search list: the "ask" memory-chat (/api/v3/chat/stream, Ollama Mode B)
+        # and the precomputed knowledge-cluster summaries (core.community_summary,
+        # Mode B/C). So search stays fast; synthesis is where the LLM adds value.
         import asyncio
         import time as _time
         engine = _get_engine(request)
@@ -521,35 +545,65 @@ async def search_memories(request: Request, body: SearchRequest):
             _window = getattr(body, "window", None) or ""
             if not _window and getattr(body, "date_from", None) and getattr(body, "date_to", None):
                 _window = f"{body.date_from}..{body.date_to}"
-            response = await loop.run_in_executor(
+            # v3.8.3: bound the synchronous recall. Under a concurrent
+            # maintenance pass or a busy embedder it can run tens of seconds
+            # and the browser aborts the fetch. If it exceeds the budget we
+            # fall through to the fast keyword search below, so the dashboard
+            # ALWAYS returns instead of failing with an abort.
+            _recall_future = loop.run_in_executor(
                 None,
                 lambda: engine.recall(
                     body.query, limit=body.limit, fast=True,
                     window=_window or None,
                 ),
             )
-            elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
-            from superlocalmemory.server.recall_serializer import (
-                recall_response_metadata,
-                serialize_recall_response,
-            )
-            results, no_confident_match = serialize_recall_response(
-                response,
-                limit=body.limit,
-                per_fact_max=300,
-                total_max=max(300, body.limit * 300),
-            )
-            return {
-                "query": body.query,
-                "results": results,
-                "total": len(results),
-                "query_type": getattr(response, "query_type", "semantic"),
-                "retrieval_time_ms": elapsed_ms,
-                "no_confident_match": no_confident_match,
-                **recall_response_metadata(response),
-            }
-
-        # Fallback: direct DB text search (engine not yet initialised)
+            # A run_in_executor thread cannot be cancelled, and wait_for() on it
+            # blocks until the thread finishes (defeating the timeout). So poll
+            # the future without blocking the event loop and give up at the
+            # deadline — the orphaned recall completes in the background and its
+            # result is discarded. This is what bounds dashboard-search latency.
+            _budget = _search_recall_timeout_s()
+            _deadline = loop.time() + _budget
+            while not _recall_future.done() and loop.time() < _deadline:
+                await asyncio.sleep(0.05)
+            if _recall_future.done():
+                response = _recall_future.result()
+            else:
+                # Ensure the orphaned future's eventual result/exception is
+                # retrieved so asyncio doesn't log "never retrieved".
+                _recall_future.add_done_callback(
+                    lambda f: (f.cancelled() or f.exception())
+                )
+                logger.warning(
+                    "search_memories: semantic recall exceeded %.0fs budget for "
+                    "%r — serving keyword fallback",
+                    _budget, (body.query or "")[:80],
+                )
+                response = None
+            if response is not None:
+                elapsed_ms = round((_time.monotonic() - t0) * 1000, 1)
+                from superlocalmemory.server.recall_serializer import (
+                    recall_response_metadata,
+                    serialize_recall_response,
+                )
+                results, no_confident_match = serialize_recall_response(
+                    response,
+                    limit=body.limit,
+                    per_fact_max=300,
+                    total_max=max(300, body.limit * 300),
+                )
+                return {
+                    "query": body.query,
+                    "results": results,
+                    "total": len(results),
+                    "query_type": getattr(response, "query_type", "semantic"),
+                    "retrieval_time_ms": elapsed_ms,
+                    "no_confident_match": no_confident_match,
+                    **recall_response_metadata(response),
+                }
+            # recall timed out — fall through to the fast keyword search.
+
+        # Fallback: direct DB text search (engine not ready OR recall over budget)
         conn = get_db_connection()
         conn.row_factory = dict_factory
         cursor = conn.cursor()

package/src/superlocalmemory/server/routes/v3_api.py

@@ -1060,6 +1060,126 @@ async def set_auto_recall_config(request: Request):
         return _internal_error()
 
 
+# ── Runtime behaviour config (v3.8.2 UX-1) ──────────────────
+# User-facing settings that take effect LIVE (no restart) via the
+# reconfigure_daemon_engine hot-swap path AND persist across restarts via
+# SLMConfig.save(). Scoped deliberately to fields that save() round-trips:
+# retrieval (asdict) + injection (explicit). Excludes setup-time/internal
+# knobs and any field save() doesn't persist (which would silently revert).
+_RUNTIME_CONFIG_FIELDS = (
+    # (section, field, kind, min, max)
+    ("retrieval", "top_k", "int", 1, 200),
+    ("retrieval", "use_cross_encoder", "bool", None, None),
+    ("injection", "enabled", "bool", None, None),
+    ("injection", "core_block_enabled", "bool", None, None),
+    ("injection", "core_block_max_facts", "int", 0, 50),
+)
+
+
+def _runtime_config_snapshot(config) -> dict:
+    """Current values of the exposed runtime fields, grouped by section."""
+    out: dict = {}
+    for section, field, *_ in _RUNTIME_CONFIG_FIELDS:
+        sec = getattr(config, section, None)
+        out.setdefault(section, {})[field] = (
+            getattr(sec, field, None) if sec is not None else None
+        )
+    return out
+
+
+@router.get("/runtime/config")
+async def get_runtime_config(request: Request):
+    """User-facing runtime behaviour settings.
+
+    Recall depth (top_k), reranker on/off (use_cross_encoder), and memory
+    injection (master + core-block). All apply live via the daemon hot-swap —
+    no restart — and persist across restarts.
+    """
+    try:
+        from superlocalmemory.core.config import SLMConfig
+        config = getattr(request.app.state, "config", None) or SLMConfig.load()
+        return {"success": True, "config": _runtime_config_snapshot(config)}
+    except Exception:
+        return _internal_error()
+
+
+@router.put("/runtime/config")
+async def set_runtime_config(request: Request):
+    """Validate, persist, and hot-apply runtime behaviour settings.
+
+    Body: ``{"retrieval": {"top_k": 30}, "injection": {"enabled": false}}``.
+    Only known fields are accepted; a bad type/range is rejected 400 and
+    nothing is applied (fail-fast — never let a bad value wedge the engine).
+    """
+    _require_manage(request)
+    try:
+        import dataclasses as _dc
+        from superlocalmemory.core.config import SLMConfig
+
+        body = await request.json()
+        if not isinstance(body, dict):
+            return JSONResponse({"error": "body must be an object"}, status_code=400)
+
+        # Validate everything BEFORE mutating anything.
+        updates: dict[str, dict] = {}
+        for section, field, kind, lo, hi in _RUNTIME_CONFIG_FIELDS:
+            sec_in = body.get(section)
+            if not isinstance(sec_in, dict) or field not in sec_in:
+                continue
+            val = sec_in[field]
+            if kind == "bool":
+                if not isinstance(val, bool):
+                    return JSONResponse(
+                        {"error": f"{section}.{field} must be true or false"},
+                        status_code=400,
+                    )
+            elif kind == "int":
+                # bool is an int subclass — reject it explicitly.
+                if isinstance(val, bool) or not isinstance(val, int):
+                    return JSONResponse(
+                        {"error": f"{section}.{field} must be an integer"},
+                        status_code=400,
+                    )
+                if (lo is not None and val < lo) or (hi is not None and val > hi):
+                    return JSONResponse(
+                        {"error": f"{section}.{field} must be between {lo} and {hi}"},
+                        status_code=400,
+                    )
+            updates.setdefault(section, {})[field] = val
+
+        if not updates:
+            return JSONResponse(
+                {"error": "no known runtime settings in request body"},
+                status_code=400,
+            )
+
+        # These are plain behaviour flags read per-recall — NOT model/mode
+        # swaps. So we apply them the light way: swap the sub-config objects on
+        # the LIVE config the daemon+engine already hold, then persist to disk.
+        # This avoids the heavyweight engine drain+rebuild (which reloads
+        # models and can time out draining in-flight recalls) — the running
+        # engine simply reads the new values on its next recall/injection.
+        live = getattr(request.app.state, "config", None) or SLMConfig.load()
+        targets = [live]
+        engine = getattr(request.app.state, "engine", None)
+        eng_cfg = getattr(engine, "_config", None) if engine is not None else None
+        if eng_cfg is not None and eng_cfg is not live:
+            targets.append(eng_cfg)
+        for cfg in targets:
+            for section, changes in updates.items():
+                sec = getattr(cfg, section, None)
+                if sec is None:
+                    continue
+                # replace() yields a NEW sub-config (works frozen or mutable);
+                # assigning the attribute is an atomic reference swap.
+                setattr(cfg, section, _dc.replace(sec, **changes))
+        request.app.state.config = live
+        live.save(mode_change=False)  # durable across restart
+        return {"success": True, "config": _runtime_config_snapshot(live)}
+    except Exception:
+        return _internal_error()
+
+
 # ── IDE Status ───────────────────────────────────────────────
 
 @router.get("/ide/status")