@melaya/runner 1.0.105 → 1.0.108

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]
 
@@ -677,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`.
@@ -1013,6 +1030,13 @@ export async function connect(opts) {
             activeAssistants.set(sid, session);
             console.log(chalk.hex("#7c6ff0")(`  ◆ Assistant session ${sid.slice(0, 10)}… (${payload.provider})`));
             proc.stdout?.on("data", (data) => {
+                // ANY host output means the turn is actively working — refresh the idle
+                // clock. Without this, lastActivity was set ONLY at turn start (assistant_turn),
+                // so a SINGLE long turn (a phone task is one turn with ~100 tool calls streaming
+                // for >15 min) was reaped mid-action by the idle sweep despite continuous
+                // activity ("idle-swept" while properly working). Now only a genuinely silent
+                // host (no output for ASSISTANT_IDLE_MS) is swept.
+                session.lastActivity = Date.now();
                 session.stdoutBuf += data.toString();
                 let idx;
                 while ((idx = session.stdoutBuf.indexOf("\n")) >= 0) {
@@ -1066,6 +1090,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})`));
@@ -1146,6 +1177,14 @@ export async function connect(opts) {
             activeAssistants.delete(String(payload.sessionId));
         }
     });
+    // Keepalive: the server is blocked waiting on the user's behalf (a HITL approval
+    // poll, a slow phone action) so the host emits no stdout, but the turn is ALIVE.
+    // Refresh the idle clock so the idle sweep doesn't reap a host mid-approval.
+    socket.on("runner:assistant_keepalive", (payload) => {
+        const s = activeAssistants.get(String(payload.sessionId || ""));
+        if (s)
+            s.lastActivity = Date.now();
+    });
     // Cooperative cancel: the user pressed STOP in chat. Write a cancel line to the
     // host's stdin — its stdin reader thread flips a flag the running turn's
     // hooks poll, so the agent loop aborts BETWEEN steps (right where the next

package/package.json

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