@melaya/runner 1.1.78 → 1.1.80

package/dist/assistantHost.py

@@ -229,7 +229,42 @@ def _render_summary_text(summary) -> str:
 # STOP flag: set by the stdin-reader thread, polled by the running turn.
 _stream = {"turnId": "", "lens": {}, "cancel": False, "usedBrowser": False,
            "deltaBuf": "", "deltaMid": "", "deltaAt": 0.0,
-           "thinkLens": {}, "toolIds": set()}
+           "thinkLens": {}, "toolIds": set(),
+           # Progress watchdog (see _progress_watchdog): what the turn is doing
+           # right now and when the client last heard from it.
+           "activity": "", "lastEmitAt": 0.0, "turnStartAt": 0.0}
+
+# One event line at a time: the progress watchdog writes from its own thread.
+_EMIT_LOCK = threading.Lock()
+
+# A turn that is silent this long gets a visible "Still working" status line
+# (2026-11-05, conv 33d90517: a Luma → Google Sheet turn went quiet for 5+
+# minutes and the user pressed STOP four times, never seeing what it was doing).
+_PROGRESS_SILENCE_S = 20.0
+
+
+def _fmt_elapsed(seconds: float) -> str:
+    s = int(max(0, seconds))
+    return f"{s // 60}m {s % 60:02d}s" if s >= 60 else f"{s}s"
+
+
+def _progress_watchdog(turn_id: str, stop: "threading.Event") -> None:
+    """While a turn runs, say what it is doing whenever it has been silent for
+    _PROGRESS_SILENCE_S: one `think` line in the chat and one line in the runner
+    log. Never raises, never touches the turn itself."""
+    while not stop.wait(5.0):
+        try:
+            if _stream.get("turnId") != turn_id:
+                return
+            now = time.monotonic()
+            if now - float(_stream.get("lastEmitAt") or now) < _PROGRESS_SILENCE_S:
+                continue
+            activity = _stream.get("activity") or "waiting for the model"
+            line = f"Still working ({_fmt_elapsed(now - float(_stream.get('turnStartAt') or now))}): {activity}"
+            _log(f"progress turn={turn_id[:8]} {line}")
+            _emit(turn_id, "think", content=f"\n{line}\n")
+        except Exception:
+            pass
 
 # Coalesce per-token pre_print fragments before emitting a `delta`. agentscope
 # hands us one cumulative snapshot per model chunk; a streaming Anthropic/OpenAI
@@ -689,8 +724,12 @@ def _emit(turn_id: str, kind: str, **fields) -> None:
     """Write one structured event line to stdout (flushed) for the runner to relay."""
     try:
         payload = {"turnId": turn_id, "kind": kind, **fields}
-        sys.stdout.write(_EVENT_PREFIX + json.dumps(payload, ensure_ascii=False, default=str) + "\n")
-        sys.stdout.flush()
+        line = _EVENT_PREFIX + json.dumps(payload, ensure_ascii=False, default=str) + "\n"
+        with _EMIT_LOCK:
+            sys.stdout.write(line)
+            sys.stdout.flush()
+        if turn_id:
+            _stream["lastEmitAt"] = time.monotonic()
     except Exception:
         # Never let event emission crash the turn loop.
         pass
@@ -761,6 +800,24 @@ def _emit_turn_files(turn_id: str) -> int:
     return n
 
 
+def _last_tool_input_size(content) -> "tuple[str, int]":
+    """(name, characters of its arguments so far) of the last tool call in a
+    streamed message, so a long silent argument write can be reported."""
+    blocks = content if isinstance(content, (list, tuple)) else [content]
+    for b in reversed(list(blocks)):
+        btype = b.get("type") if isinstance(b, dict) else getattr(b, "type", None)
+        if btype != "tool_use":
+            continue
+        name = b.get("name") if isinstance(b, dict) else getattr(b, "name", "")
+        args = b.get("input") if isinstance(b, dict) else getattr(b, "input", None)
+        try:
+            size = len(args) if isinstance(args, str) else len(json.dumps(args or {}, default=str))
+        except Exception:
+            size = 0
+        return str(name or ""), size
+    return "", 0
+
+
 def _split_stream_blocks(content):
     """Split a streamed message's content into (answer_text, thinking_text,
     [(tool_id, tool_name)]).
@@ -1430,6 +1487,16 @@ def _register_stream_hooks(agent) -> None:
                 return
             mid = str(getattr(msg, "id", "") or id(msg))
             text, thinking, tool_uses = _split_stream_blocks(getattr(msg, "content", msg))
+            # What the progress watchdog reports if the turn goes quiet.
+            if tool_uses:
+                _tname_now, _tchars = _last_tool_input_size(getattr(msg, "content", msg))
+                if _tname_now:
+                    _stream["activity"] = (f"writing the {_tname_now} call ({_tchars // 1024} KB so far)"
+                                           if _tchars >= 1024 else f"writing the {_tname_now} call")
+            elif text:
+                _stream["activity"] = "writing the answer"
+            elif thinking:
+                _stream["activity"] = "thinking"
             # Reasoning (Codex reasoning summaries, Claude thinking) streams to the
             # thinking strip as `think`, never into the answer bubble.
             if thinking:
@@ -1531,8 +1598,29 @@ def _register_stream_hooks(agent) -> None:
         except Exception:
             return False
 
+    def _pre_acting_hook(_self, kw, *_rest) -> None:
+        # Progress only: which tool is running now (no event of its own).
+        try:
+            if getattr(_self, "name", "") != "Assistant" or not _stream.get("turnId") or not isinstance(kw, dict):
+                return
+            tc = kw.get("tool_call") or {}
+            name = tc.get("name", "") if isinstance(tc, dict) else getattr(tc, "name", "")
+            if name:
+                _stream["activity"] = f"running {name}"
+        except Exception:
+            pass
+
+    def _progress_after_tool(_self, kw, *_rest) -> None:
+        try:
+            if getattr(_self, "name", "") == "Assistant" and _stream.get("turnId"):
+                _stream["activity"] = "waiting for the model"
+        except Exception:
+            pass
+
     ok_a = _reg("pre_print", "mel_assistant_delta", _pre_print_hook)
     ok_b = _reg("post_acting", "mel_assistant_tool", _post_acting_hook)
+    _reg("pre_acting", "mel_assistant_progress", _pre_acting_hook)
+    _reg("post_acting", "mel_assistant_progress", _progress_after_tool)
     _HOOKS_REGISTERED = ok_a or ok_b
     _log(f"stream hooks registered (delta={ok_a} tool={ok_b})")
 
@@ -1575,6 +1663,11 @@ def _run_turn(agent, turn_id: str, message: str, browser_turn: bool = False, ima
     _stream["deltaMid"] = ""
     _stream["cancel"] = False  # fresh turn — clear any stale STOP
     _stream["usedBrowser"] = False
+    _stream["activity"] = "waiting for the model"
+    _stream["turnStartAt"] = _stream["lastEmitAt"] = time.monotonic()
+    _progress_stop = threading.Event()
+    threading.Thread(target=_progress_watchdog, args=(turn_id, _progress_stop),
+                     name="mel-progress", daemon=True).start()
 
     # Reset the per-turn sub-agent delegation budget so the breadth cap is per
     # turn, not per session. Best-effort: never let a stale/absent bundle break a
@@ -1622,7 +1715,10 @@ def _run_turn(agent, turn_id: str, message: str, browser_turn: bool = False, ima
         return task.result()
 
     try:
-        result = asyncio.run(_go())
+        try:
+            result = asyncio.run(_go())
+        finally:
+            _progress_stop.set()
     except Exception as exc:
         _log("turn error:\n" + traceback.format_exc())
         _stream["turnId"] = ""

package/dist/pythonEnv.js

@@ -583,12 +583,26 @@ async function _ensurePythonEnvImpl(systemPython, expectedVersion, onProgress =
     // blocked by a uv edge case.
     const _uvBin = _resolveUvBin();
     let acode;
+    // Always in the runner log (onProgress is silent outside verbose mode): a deps
+    // change reinstalls every runner's venv once, and nobody could tell it happened,
+    // how long it took or why it failed (Mac, 2026-10-30).
+    const installStart = Date.now();
+    const installTail = [];
+    const installOut = (line) => {
+        installTail.push(line);
+        if (installTail.length > 12)
+            installTail.shift();
+        onProgress(line);
+    };
+    console.log(`  python venv: installing ${PIP_DEPS.length} deps with ${_uvBin ? "uv" : "pip"} (deps changed)`);
     if (_uvBin) {
         onProgress(`installing ${PIP_DEPS.length} python deps via uv (fast; cached reinstalls take seconds)`);
-        acode = await runProc(_uvBin, ["pip", "install", "--python", venvPython(), "--quiet", ...PIP_DEPS], onProgress, { UV_SYSTEM_CERTS: "1" });
+        acode = await runProc(_uvBin, ["pip", "install", "--python", venvPython(), "--quiet", ...PIP_DEPS], installOut, { UV_SYSTEM_CERTS: "1" });
         if (acode !== 0) {
             onProgress("uv install failed — falling back to pip (--no-cache-dir)");
-            acode = await runProc(venvPython(), ["-m", "pip", "install", "--use-feature=truststore", "--no-cache-dir", "--quiet", "--disable-pip-version-check", ...PIP_DEPS], onProgress);
+            console.warn(`  python venv: uv failed (exit ${acode}), falling back to pip:\n    ${installTail.join("\n    ")}`);
+            installTail.length = 0;
+            acode = await runProc(venvPython(), ["-m", "pip", "install", "--use-feature=truststore", "--no-cache-dir", "--quiet", "--disable-pip-version-check", ...PIP_DEPS], installOut);
         }
     }
     else {
@@ -599,9 +613,10 @@ async function _ensurePythonEnvImpl(systemPython, expectedVersion, onProgress =
         // importantly, guarantees a corrupt cached wheel can never install a subtly
         // broken package into a fresh runner venv. Costs a re-download on rebuild,
         // which is rare (only on a deps change or a manual clear).
-        acode = await runProc(venvPython(), ["-m", "pip", "install", "--use-feature=truststore", "--no-cache-dir", "--quiet", "--disable-pip-version-check", ...PIP_DEPS], onProgress);
+        acode = await runProc(venvPython(), ["-m", "pip", "install", "--use-feature=truststore", "--no-cache-dir", "--quiet", "--disable-pip-version-check", ...PIP_DEPS], installOut);
     }
     if (acode !== 0) {
+        console.warn(`  python venv: install failed (exit ${acode}) after ${Math.round((Date.now() - installStart) / 1000)} s:\n    ${installTail.join("\n    ")}`);
         return {
             ok: false,
             pythonPath: systemPython,
@@ -685,5 +700,6 @@ async function _ensurePythonEnvImpl(systemPython, expectedVersion, onProgress =
     }
     writeFileSync(VENV_MARK, venvMarkerValue(expectedVersion), "utf-8");
     onProgress(`✓ venv ready (python=${venvPython()})`);
+    console.log(`  python venv: ready in ${Math.round((Date.now() - installStart) / 1000)} s (python=${venvPython()})`);
     return { ok: true, pythonPath: venvPython() };
 }

package/dist/sharedVendor.d.ts

@@ -16,3 +16,5 @@
 export declare function getLocalSharedVersion(): string | null;
 export declare function getSharedDir(): string;
 export declare function ensureSharedModules(serverUrl: string, expectedVersion: string, runnerToken: string): Promise<void>;
+/** No data for this long aborts the download (a slow one keeps going). */
+export declare const SHARED_STALL_MS = 30000;

package/dist/sharedVendor.js

@@ -68,6 +68,48 @@ export function ensureSharedModules(serverUrl, expectedVersion, runnerToken) {
     _sharedInFlight.set(expectedVersion, p);
     return p;
 }
+/** No data for this long aborts the download (a slow one keeps going). */
+export const SHARED_STALL_MS = 30_000;
+/** Hard ceiling for one download, however slowly it trickles. */
+const SHARED_MAX_MS = 5 * 60_000;
+/** GET the bundle (gzip accepted: about 4 MB instead of 24), aborting only on a stall. */
+async function fetchSharedBundle(url, runnerToken) {
+    const ac = new AbortController();
+    let stall;
+    const arm = () => {
+        if (stall)
+            clearTimeout(stall);
+        stall = setTimeout(() => ac.abort(new Error(`no data for ${SHARED_STALL_MS / 1000} s`)), SHARED_STALL_MS);
+    };
+    const ceiling = setTimeout(() => ac.abort(new Error(`not done after ${SHARED_MAX_MS / 1000} s`)), SHARED_MAX_MS);
+    arm();
+    try {
+        const res = await fetch(url, {
+            headers: { Authorization: `Bearer ${runnerToken}`, "Accept-Encoding": "gzip" },
+            signal: ac.signal,
+        });
+        if (!res.ok)
+            throw new Error(`Failed to fetch shared modules: HTTP ${res.status}`);
+        if (!res.body)
+            throw new Error("Failed to fetch shared modules: empty response");
+        const reader = res.body.getReader();
+        const chunks = [];
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value)
+                chunks.push(value);
+            arm();
+        }
+        return JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+    }
+    finally {
+        if (stall)
+            clearTimeout(stall);
+        clearTimeout(ceiling);
+    }
+}
 async function _ensureSharedModulesImpl(serverUrl, expectedVersion, runnerToken) {
     mkdirSync(CACHE_DIR, { recursive: true });
     // Check cached version. We require BOTH a version match AND a valid nested
@@ -90,14 +132,26 @@ async function _ensureSharedModulesImpl(serverUrl, expectedVersion, runnerToken)
     // Fetch from server
     const httpUrl = serverUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
     const url = `${httpUrl}/api/v1/runner/shared-bundle?v=${expectedVersion}`;
-    const res = await fetch(url, {
-        headers: { Authorization: `Bearer ${runnerToken}` },
-        signal: AbortSignal.timeout(30_000),
-    });
-    if (!res.ok) {
-        throw new Error(`Failed to fetch shared modules: HTTP ${res.status}`);
+    // Right after a deploy every runner downloads the new bundle at once: a slow but
+    // live download must not fail the run (run 3751301796504315, 2026-10-30, hit the
+    // old flat 30 s limit). Abort only when no data arrives for SHARED_STALL_MS, retry
+    // once, and if both fail while a previous bundle is still valid on disk, run with
+    // it and say so (the next run fetches the new one).
+    let body;
+    try {
+        body = await fetchSharedBundle(url, runnerToken).catch(async (e) => {
+            console.warn(`  ⚠ shared modules ${expectedVersion}: download failed (${e?.message}), retrying once`);
+            return fetchSharedBundle(url, runnerToken);
+        });
+    }
+    catch (e) {
+        if (existsSync(VERSION_FILE) && cacheLooksValid()) {
+            const cached = readFileSync(VERSION_FILE, "utf-8").trim();
+            console.warn(`  ⚠ shared modules ${expectedVersion}: download failed again (${e?.message}); running with the cached ${cached}`);
+            return;
+        }
+        throw e;
     }
-    const body = await res.json();
     // Verify integrity
     const computed = createHash("sha256").update(JSON.stringify(body.files)).digest("hex");
     if (computed !== body.hash) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.1.78",
+  "version": "1.1.80",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "Apache-2.0",
   "author": "Melaya Labs LLC",