@melaya/runner 1.0.104 → 1.0.106

package/dist/assistantHost.py

@@ -72,24 +72,49 @@ def _memory_watermark(agent) -> int:
         return 0
 
 
+def _sync_ollama_memory_budget(agent) -> None:
+    """P2-6 (persistent host): the Assistant builds ONE agent + BoundedMemory, so an
+    OOM num_ctx downgrade that shrinks the ollama context cache would otherwise leave
+    the live memory budgeting against the OLD (too-large) window — packing more than
+    the GPU can hold and re-OOMing every turn. Re-resolve the budget from the (now
+    downgraded) cache each turn and LOWER max_tokens to match. Ratchets DOWN only;
+    best-effort + ollama-only (a cloud/CLI provider never touches this)."""
+    if (os.environ.get("MEL_ASSISTANT_PROVIDER", "") or "").lower() != "ollama":
+        return
+    try:
+        from shared.runtime.agent_factory import _resolve_memory_budget
+        budget = _resolve_memory_budget("ollama", os.environ.get("MEL_ASSISTANT_MODEL", "") or "")
+        mem = _agent_memory(agent)
+        if mem is not None and hasattr(mem, "max_tokens") and budget > 0:
+            cur = int(getattr(mem, "max_tokens", 0) or 0)
+            if cur <= 0 or budget < cur:
+                mem.max_tokens = budget
+                _log(f"ollama memory budget re-synced {cur}->{budget} (post-OOM downgrade)")
+    except Exception:
+        pass
+
+
 def _config_hash() -> str:
     """PR4 config-drift: a stable hash over the config env that determines host
     behaviour, canonicalized IDENTICALLY to the server (runnerNamespace.ts
     _assistantConfigHash): pipe-delimited provider|model|language|connectors|
-    hitl|phoneReady, language default 'en', connectors lowercased+sorted,
-    phoneReady 1/0. Reported in `ready` so the server can detect env divergence."""
+    phoneReady, language default 'en', connectors lowercased+sorted, phoneReady
+    1/0. Reported in `ready` so the server can detect env divergence.
+
+    NOTE: hitlMode is DELIBERATELY EXCLUDED (it must match the server byte-for-byte,
+    and the server dropped it — it is a PER-TURN parameter carried on every
+    assistant_turn frame, so a safe↔autonomous flip takes effect without a reboot).
+    Including it here made the host hash NEVER match the server's, so config-drift
+    detection was permanently fail-open (a stale-connector host was accepted)."""
     import hashlib
     raw_conn = os.environ.get("MEL_ASSISTANT_CONNECTORS", "") or ""
     connectors = ",".join(sorted(c.lower() for c in raw_conn.split(",") if c.strip()))
-    hitl = os.environ.get("MEL_ASSISTANT_HITL_MODE", "safe") or "safe"
-    if hitl not in ("safe", "autonomous", "payments_only"):
-        hitl = "safe"
     phone = "1" if (os.environ.get("MEL_ASSISTANT_PHONE_READY", "") or "") else "0"
     canon = "|".join([
         os.environ.get("MEL_ASSISTANT_PROVIDER", "") or "",
         os.environ.get("MEL_ASSISTANT_MODEL", "") or "",
         os.environ.get("MEL_ASSISTANT_LANGUAGE", "en") or "en",
-        connectors, hitl, phone,
+        connectors, phone,
     ])
     return hashlib.sha256(canon.encode("utf-8")).hexdigest()[:32]
 
@@ -271,13 +296,25 @@ def _build_agent():
     # then ALWAYS require the in-chat approval card (fail-safe).
     if connector_services and not os.environ.get("MEL_ASSISTANT_CONNECTOR_HITL"):
         os.environ["MEL_ASSISTANT_CONNECTOR_HITL"] = "1"
-    # Core primitives (melaya_core): web_search / web_fetch, files, HTTP, data +
-    # office utilities, scraping, encoding, SQL, etc. — are ALWAYS discoverable via
-    # search_tools/activate_tool. The side-effecting ones run on the USER's OWN
-    # machine (this runner) and are HITL-gated by the assistant's safe/payments
-    # modes, so exposing them for discovery is safe. They stay in the LAZY pool
-    # (not pinned) so the ~73-tool category never explodes the active budget.
-    core_categories = ["melaya_core"]
+    # Core primitives: web_search / web_fetch, files, HTTP, data + office utilities,
+    # scraping, encoding, SQL, etc. — ALWAYS discoverable via search_tools/
+    # activate_tool. The side-effecting ones run on the USER's OWN machine (this
+    # runner) and are HITL-gated by the assistant's safe/payments modes, so exposing
+    # them for discovery is safe. They stay in the LAZY pool (not pinned) so the
+    # ~73-tool family never explodes the active budget.
+    #
+    # IMPORTANT: `melaya_core` is a CLIENT-SIDE DISPLAY bucket (toolServiceMap.ts),
+    # NOT a runtime registry category — the primitives actually live under `tools`,
+    # `scraping`, `msoffice`, `database`, … So we include the AUTHORITATIVE runtime
+    # category list (CORE_TOOL_CATEGORIES). Passing "melaya_core" matched NOTHING,
+    # which is why web_search/web_fetch never appeared in search_tools.
+    try:
+        from shared.runtime.registry import CORE_TOOL_CATEGORIES as core_categories
+    except Exception:
+        # Fallback if an older shared bundle predates the constant — hardcode the set.
+        core_categories = ["tools", "scraping", "data_utils", "msoffice", "aiml",
+                           "media", "knowledge", "netutil_tools", "qr_tools",
+                           "ics_tools"]  # excluded (need a connector): video_pipeline, database, devops
     try:
         from shared.orchestration.lazy_registry import build_lazy_toolkit
         # Base tools (melaya_agent + phone) stay active+pinned; core + any selected
@@ -339,6 +376,18 @@ def _build_agent():
         "data — read it from the connector.\n"
         if connector_services else ""
     )
+    # Core primitives are ALWAYS in the lazy pool now, so the model must be told
+    # they exist (they are not pinned/loaded upfront) — otherwise it concludes "no
+    # web-search tool is available" and refuses, exactly the reported failure.
+    core_rule = (
+        "- You have built-in CORE tools that are NOT loaded upfront: web_search "
+        "(live web search) and web_fetch (fetch a URL's content), plus file read/"
+        "write, HTTP requests, scraping, data/CSV/Excel utilities, SQL, QR and media. "
+        "To use any of them, call search_tools(query=...) (e.g. search_tools(\"web "
+        "search\")), then activate_tool(name=\"web_search\"), then call it. Whenever a "
+        "question needs live/current web data or a page's contents, use web_search / "
+        "web_fetch — do NOT claim you lack a web tool.\n"
+    )
     sys_prompt = (
         "You are the Melaya Assistant, the in-app copilot of the Melaya "
         "agent-orchestration platform. You have READ-ONLY tools over the data "
@@ -351,6 +400,7 @@ def _build_agent():
         "supports dimension='pipeline' to find which pipeline cost the most.\n"
         + phone_rule
         + connector_rule
+        + core_rule
         + "- Be concise and concrete; format small tables or bullet lists when comparing items.\n"
         "- If a question is outside the platform, answer normally without tools.\n"
         + (f"- Answer in the user's language: {language}.\n" if language and language != "en" else "")
@@ -652,6 +702,9 @@ def main() -> int:
         if not message:
             _emit(turn_id, "done")
             continue
+        # P2-6: nudge the live memory budget down if a prior turn's OOM downgraded
+        # the ollama context (no-op for every other provider / when unchanged).
+        _sync_ollama_memory_budget(agent)
         _run_turn(agent, turn_id, message)
 
 

package/dist/connection.js

@@ -898,17 +898,34 @@ export async function connect(opts) {
             return;
         const generation = Number(payload.generation ?? 0) || 0;
         const emitEv = (ev) => socket.emit("runner:assistant_event", { sessionId: sid, turnId: "", ...ev });
-        // A live host already exists — report ready WITH its last-known memory
-        // watermark so the server doesn't needlessly re-offer a rehydrate (a bare
-        // ready would read as watermark 0). No second spawn.
+        // A live host already exists — normally report ready WITH its last-known memory
+        // watermark so the server doesn't needlessly re-offer a rehydrate (a bare ready
+        // would read as watermark 0) and NO second spawn. BUT first check config drift:
         const live = activeAssistants.get(sid);
-        // Report the live host's ACTUAL boot generation (not just its watermark) so a
-        // server that restarted (its in-memory session map wiped) can DETECT a host
-        // that booted under an older generation and reboot it instead of serving the
-        // next turn from stale memory/config. A bare ready hid this.
+        const expectedConfig = String(payload.configHash || "");
         if (live) {
-            emitEv({ kind: "ready", memoryWatermark: live.memoryWatermark || 0, generation: live.generation, hostInstanceId: live.hostInstanceId, configHash: live.configHash, protocol: ASSISTANT_PROTOCOL_VERSION });
-            return;
+            // SECURITY (config-drift fail-open fix): the server may have RESTARTED and
+            // lost its session map, then sent assistant_start with the CURRENT config
+            // (e.g. a connector the user has since removed). If the live host booted under
+            // a DIFFERENT config, returning it would serve the removed connector's tools +
+            // credentials. Kill the stale host and fall through to spawn a FRESH one under
+            // the new config. Same-config → reuse (the fast path). An empty live.configHash
+            // (a pre-configHash host) is treated as stale so it can't linger fail-open.
+            const drifted = expectedConfig ? (live.configHash !== expectedConfig) : false;
+            if (drifted || (expectedConfig && !live.configHash)) {
+                console.log(chalk.yellow(`  ◆ Assistant host ${sid.slice(0, 10)}… config drift (host=${live.configHash || "∅"} ≠ server=${expectedConfig}) — rebooting`));
+                live.killed = true; // suppress its session_closed (see proc.exit)
+                activeAssistants.delete(sid); // stop returning it immediately
+                try {
+                    live.proc.kill();
+                }
+                catch { /* already dead */ } // SIGTERM → Python atexit cleanup
+                // fall through to the fresh-boot path below (bootingAssistants guards races)
+            }
+            else {
+                emitEv({ kind: "ready", memoryWatermark: live.memoryWatermark || 0, generation: live.generation, hostInstanceId: live.hostInstanceId, configHash: live.configHash, protocol: ASSISTANT_PROTOCOL_VERSION });
+                return;
+            }
         }
         // A boot is already in flight for this sid (concurrent start / server restart
         // mid-boot). Drop this duplicate — the in-flight boot will emit `ready`.
@@ -1066,6 +1083,13 @@ export async function connect(opts) {
                 // would orphan the newcomer and make the next turn "session_not_found".
                 if (activeAssistants.get(sid) === session)
                     activeAssistants.delete(sid);
+                // A host we INTENTIONALLY killed for a config-drift reboot must NOT emit
+                // session_closed — that frame would fail the fresh boot's ready waiter
+                // (the server can't pre-mark it superseded here, the kill is runner-side).
+                if (session.killed) {
+                    console.log(chalk.gray(`  ■ Assistant host ${sid.slice(0, 10)}… replaced (config drift, exit ${code})`));
+                    return;
+                }
                 const detail = code !== 0 && stderrTail.length ? stderrTail.slice(-12).join("\n") : "";
                 socket.emit("runner:assistant_event", { sessionId: sid, turnId: "", kind: "session_closed", code, detail });
                 console.log(chalk.gray(`  ■ Assistant session ${sid.slice(0, 10)}… closed (exit ${code})`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.104",
+  "version": "1.0.106",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,