@melaya/runner 1.0.82 → 1.0.84

package/dist/assistantHost.py

@@ -38,8 +38,12 @@ _EVENT_PREFIX = "MELASSIST "
 _IDLE_EXIT_SECONDS = int(os.environ.get("MEL_ASSISTANT_IDLE_SECONDS", "900"))  # 15 min
 
 # Streaming state for the CURRENT turn — the pre_print / post_acting hooks read
-# this to emit delta / tool events keyed to the turn in flight.
-_stream = {"turnId": "", "lens": {}}
+# this to emit delta / tool events keyed to the turn in flight. `cancel` is the
+# STOP flag: set by the stdin-reader thread, polled by the running turn.
+_stream = {"turnId": "", "lens": {}, "cancel": False}
+
+# Sentinel returned by a turn's coroutine when the user pressed STOP.
+_CANCELLED = object()
 
 
 def _emit(turn_id: str, kind: str, **fields) -> None:
@@ -219,9 +223,24 @@ def _run_turn(agent, turn_id: str, message: str) -> None:
     _emit(turn_id, "round", n=1)
     _stream["turnId"] = turn_id
     _stream["lens"] = {}
+    _stream["cancel"] = False  # fresh turn — clear any stale STOP
 
+    # Run the agent as a cancellable task and poll the STOP flag (flipped by the
+    # stdin-reader thread when the user presses STOP in chat). asyncio.cancel()
+    # unwinds the agent loop wherever it is awaiting — including mid phone-command
+    # HTTP wait — so the run stops promptly instead of finishing the step first.
     async def _go():
-        return await agent(Msg("user", message, "user"))
+        task = asyncio.ensure_future(agent(Msg("user", message, "user")))
+        while not task.done():
+            if _stream.get("cancel"):
+                task.cancel()
+                try:
+                    await task
+                except BaseException:  # CancelledError + any teardown error
+                    pass
+                return _CANCELLED
+            await asyncio.sleep(0.12)
+        return task.result()
 
     try:
         result = asyncio.run(_go())
@@ -232,6 +251,13 @@ def _run_turn(agent, turn_id: str, message: str) -> None:
         _emit(turn_id, "done")
         return
 
+    if result is _CANCELLED:
+        _stream["turnId"] = ""
+        _log("turn cancelled by user STOP")
+        _emit(turn_id, "text", content="Stopped.")
+        _emit(turn_id, "done")
+        return
+
     _stream["turnId"] = ""
     # Authoritative final answer — the client swaps the streamed plain text for
     # this markdown-rendered version.
@@ -242,9 +268,26 @@ def _run_turn(agent, turn_id: str, message: str) -> None:
 
 def _stdin_reader(q: "queue.Queue[str]") -> None:
     """Feed stdin lines into a queue so the main loop can apply an idle timeout
-    (blocking readline can't be interrupted portably)."""
+    (blocking readline can't be interrupted portably).
+
+    STOP is special: a `{"cancel": true}` line must take effect WHILE a turn is
+    running, but the main thread is blocked in _run_turn and won't drain the
+    queue until it finishes. So handle cancel HERE, on the reader thread — flip
+    the shared flag the running turn polls — and never enqueue it as a new turn.
+    """
     try:
         for line in sys.stdin:
+            s = line.strip()
+            if s:
+                try:
+                    req = json.loads(s)
+                except Exception:
+                    req = None
+                if isinstance(req, dict) and req.get("cancel"):
+                    tid = str(req.get("turnId") or "")
+                    if not tid or tid == _stream.get("turnId"):
+                        _stream["cancel"] = True
+                    continue  # consumed — do not queue as a turn
             q.put(line)
     except Exception:
         pass

package/dist/connection.js

@@ -64,6 +64,30 @@ export async function connect(opts) {
             console.log(chalk.yellow(`  ⚠ Luma browser bridge failed to start: ${e?.message || e}`));
         }
     };
+    // Background warm-up of the assistant Python env, once per process, so the
+    // first assistant chat spawns near-instantly. No-op on a fresh runner (no
+    // shared bundle on disk yet) — the real assistant_start installs it then.
+    let _assistantPrewarmed = false;
+    const _prewarmAssistantEnv = async () => {
+        if (_assistantPrewarmed)
+            return;
+        _assistantPrewarmed = true;
+        try {
+            const { getLocalSharedVersion } = await import("./sharedVendor.js");
+            const localVersion = getLocalSharedVersion();
+            if (!localVersion)
+                return; // nothing cached yet — let assistant_start do it
+            const { ensurePythonEnv } = await import("./pythonEnv.js");
+            await ensurePythonEnv(opts.pythonPath, localVersion, (m) => { if (opts.verbose)
+                console.log(chalk.gray(`  [assistant prewarm] ${m}`)); });
+            if (opts.verbose)
+                console.log(chalk.gray("  [assistant prewarm] ready"));
+        }
+        catch (e) {
+            if (opts.verbose)
+                console.log(chalk.gray(`  [assistant prewarm] skipped: ${e?.message || e}`));
+        }
+    };
     socket.on("connect", async () => {
         spinner.succeed(chalk.green("Connected to Melaya"));
         // Report detected models
@@ -83,6 +107,12 @@ export async function connect(opts) {
         // effort — failure here means Luma POSTs fall back to aiohttp
         // (which 403s under the bot rule) but reads still work.
         await _ensureLumaBridge();
+        // Pre-warm the assistant Python env in the BACKGROUND so the first chat
+        // message doesn't pay the venv check + one-time NLTK/cert self-heal inline
+        // (the biggest chunk of "◆ Assistant session … takes forever to spawn").
+        // We warm with the version already on disk so it hits the cache instead of
+        // reinstalling; skipped on a fresh runner (no bundle yet) to avoid churn.
+        void _prewarmAssistantEnv();
         console.log(chalk.gray("  Waiting for pipeline runs...\n"));
     });
     socket.on("connect_error", (err) => {
@@ -936,6 +966,23 @@ export async function connect(opts) {
             activeAssistants.delete(String(payload.sessionId));
         }
     });
+    // 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
+    // phone action would fire) WITHOUT killing the warm session. The server-side
+    // phone:kill gate independently halts any in-flight phone action, so even a
+    // host that predates this line stops driving the phone; this just also stops
+    // it burning model tokens and keeps the session warm for the next message.
+    socket.on("runner:assistant_cancel", (payload) => {
+        const s = activeAssistants.get(String(payload.sessionId || ""));
+        if (!s)
+            return;
+        s.lastActivity = Date.now();
+        try {
+            s.proc.stdin?.write(JSON.stringify({ turnId: payload.turnId, cancel: true }) + "\n");
+        }
+        catch { /* best-effort */ }
+    });
     // Idle sweep — reap assistant hosts with no turn in ASSISTANT_IDLE_MS.
     setInterval(() => {
         const now = Date.now();

package/dist/pythonEnv.js

@@ -320,13 +320,21 @@ async function ensureNltkData(onProgress) {
         onProgress(`(nltk check exited ${code} — Mode B vector RAG ingest may fail with "Resource 'punkt_tab' not found")`);
     }
 }
+// One-time-per-process guard for the cache-hit self-heal (NLTK + cert bundle).
+let _selfHealedThisProcess = false;
 export async function ensurePythonEnv(systemPython, expectedVersion, onProgress = (m) => console.log(chalk.gray(`  [venv] ${m}`))) {
     if (venvIsValid(expectedVersion)) {
-        // Self-heal: ensure NLTK data is present even when the venv marker
-        // says we're up to date. This is what previously broke for boxes
-        // that upgraded the runner without invalidating the marker.
-        await ensureNltkData(onProgress);
-        await _resolveAndCacheCertBundle(onProgress);
+        // Self-heal: ensure NLTK data + the cert bundle are present even when the
+        // venv marker says we're up to date (this is what previously broke for
+        // boxes that upgraded the runner without invalidating the marker). Both are
+        // stable for the process lifetime, so run them ONCE per runner process — the
+        // old code spawned two extra Python processes on EVERY assistant/pipeline
+        // start (~0.5-1.5s of pure latency on the assistant-spawn critical path).
+        if (!_selfHealedThisProcess) {
+            _selfHealedThisProcess = true;
+            await ensureNltkData(onProgress);
+            await _resolveAndCacheCertBundle(onProgress);
+        }
         return { ok: true, pythonPath: venvPython() };
     }
     if (!existsSync(AGENTSCOPE)) {

package/dist/sharedVendor.d.ts

@@ -7,5 +7,12 @@
  * runtime from the server's /api/v1/agents/shared-bundle endpoint,
  * integrity-verified via SHA-256, and cached at ~/.melaya-runner/shared/.
  */
+/**
+ * The shared-bundle version currently installed on disk (from shared-version.txt),
+ * or null if none/incomplete. Used to pre-warm the Python env on connect with the
+ * SAME version the cache already holds, so the warm-up hits the cache instead of
+ * triggering a reinstall.
+ */
+export declare function getLocalSharedVersion(): string | null;
 export declare function getSharedDir(): string;
 export declare function ensureSharedModules(serverUrl: string, expectedVersion: string, runnerToken: string): Promise<void>;

package/dist/sharedVendor.js

@@ -14,6 +14,22 @@ import { createHash, createHmac, timingSafeEqual } from "crypto";
 const CACHE_DIR = join(homedir(), ".melaya-runner");
 const SHARED_DIR = join(CACHE_DIR, "shared");
 const VERSION_FILE = join(CACHE_DIR, "shared-version.txt");
+/**
+ * The shared-bundle version currently installed on disk (from shared-version.txt),
+ * or null if none/incomplete. Used to pre-warm the Python env on connect with the
+ * SAME version the cache already holds, so the warm-up hits the cache instead of
+ * triggering a reinstall.
+ */
+export function getLocalSharedVersion() {
+    try {
+        if (existsSync(VERSION_FILE) && cacheLooksValid()) {
+            const v = readFileSync(VERSION_FILE, "utf-8").trim();
+            return v || null;
+        }
+    }
+    catch { /* best-effort */ }
+    return null;
+}
 export function getSharedDir() {
     // Return the CACHE_DIR root (not shared/ subdir) because the bundle
     // now includes agentscope/ and crews/ alongside shared/. PYTHONPATH

package/package.json

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