@melaya/runner 1.1.36 → 1.1.38

package/dist/assistantHost.py

@@ -184,7 +184,16 @@ def _render_summary_text(summary) -> str:
 # 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. `cancel` is the
 # STOP flag: set by the stdin-reader thread, polled by the running turn.
-_stream = {"turnId": "", "lens": {}, "cancel": False, "usedBrowser": False}
+_stream = {"turnId": "", "lens": {}, "cancel": False, "usedBrowser": False,
+           "deltaBuf": "", "deltaMid": ""}
+
+# Coalesce per-token pre_print fragments before emitting a `delta`. agentscope
+# hands us one cumulative snapshot per model chunk; a streaming Anthropic/OpenAI
+# response fragments the answer into 2-15 char pieces, and emitting a MELASSIST
+# line (→ socket → server → SSE → client) PER fragment made streaming read as
+# ultra-choppy / ultra-slow (hundreds of round-trips for one answer). Hold the
+# suffix until it reaches ~a clause or hits a line break, then flush one delta.
+_DELTA_FLUSH_CHARS = 48
 
 # Sentinel returned by a turn's coroutine when the user pressed STOP.
 _CANCELLED = object()
@@ -417,6 +426,18 @@ def _emit(turn_id: str, kind: str, **fields) -> None:
         pass
 
 
+def _flush_delta(turn_id: str) -> None:
+    """Emit any buffered pre_print suffix as one `delta` and clear the buffer.
+
+    Called from the pre_print hook when the buffer fills / a message boundary is
+    crossed, and from _run_turn just before the authoritative `text` swap so the
+    last partial clause is not left un-streamed."""
+    buf = _stream.get("deltaBuf") or ""
+    if buf and turn_id:
+        _emit(turn_id, "delta", content=buf)
+    _stream["deltaBuf"] = ""
+
+
 def _log(msg: str) -> None:
     # Diagnostics go to stderr (the runner logs stderr; stdout is the event channel).
     try:
@@ -826,19 +847,27 @@ def _register_stream_hooks(agent) -> None:
                 return
             prev = _stream["lens"].get(mid, 0)
             if len(text) > prev:
-                # ReAct emits one message PER iteration: the running chain-of-thought
-                # ("Let me...", "Actually...", the plan before each tool call). That
-                # is REASONING, not the answer. Streaming it as `delta` dumped every
-                # round's raw thought into the chat bubble with no separator between
-                # rounds ("...page content.I notice..."), which read as broken run-on
-                # sentences. Route it to `think` instead (the ephemeral thinking
-                # strip) so it MIRRORS the cloud provider mapping (thinking_delta ->
-                # think, answer -> text). The clean authoritative answer still lands
-                # in the bubble via the end-of-turn `text` event (_run_turn), so the
-                # message reads like one professional reply, reasoning stays in its
-                # own channel, and tool chips show the live steps.
-                _emit(tid, "think", content=text[prev:])
+                # ReAct emits one message PER iteration. We stream every message's
+                # growing suffix into the answer bubble as `delta` so the reply
+                # TYPES OUT live (this is the same channel cloud providers stream
+                # on) instead of only landing whole at end-of-turn. The end-of-turn
+                # `text` event (_run_turn) still swaps in the clean, authoritative
+                # markdown answer, so transient tool preambles that streamed here
+                # get replaced by the final professional reply. A blank line
+                # separates successive ReAct messages so rounds don't run together
+                # ("...page content.I notice..."). Fragments are coalesced (see
+                # _DELTA_FLUSH_CHARS) so we emit clause-sized deltas, not one
+                # socket round-trip per token.
+                suffix = text[prev:]
                 _stream["lens"][mid] = len(text)
+                if mid != _stream.get("deltaMid"):
+                    _flush_delta(tid)  # flush the previous message's tail
+                    if _stream.get("deltaMid"):
+                        _stream["deltaBuf"] = "\n\n"
+                    _stream["deltaMid"] = mid
+                _stream["deltaBuf"] = _stream.get("deltaBuf", "") + suffix
+                if len(_stream["deltaBuf"]) >= _DELTA_FLUSH_CHARS or "\n" in suffix:
+                    _flush_delta(tid)
         except Exception:
             pass
 
@@ -921,6 +950,8 @@ def _run_turn(agent, turn_id: str, message: str, browser_turn: bool = False, ima
     _emit(turn_id, "round", n=1)
     _stream["turnId"] = turn_id
     _stream["lens"] = {}
+    _stream["deltaBuf"] = ""   # fresh turn — drop any stale streamed suffix
+    _stream["deltaMid"] = ""
     _stream["cancel"] = False  # fresh turn — clear any stale STOP
     _stream["usedBrowser"] = False
 
@@ -993,6 +1024,7 @@ def _run_turn(agent, turn_id: str, message: str, browser_turn: bool = False, ima
         _emit(turn_id, "done")
         return
 
+    _flush_delta(turn_id)  # push the last buffered clause before the swap
     _stream["turnId"] = ""
     # Authoritative final answer — the client swaps the streamed plain text for
     # this markdown-rendered version.

package/dist/connection.js

@@ -136,14 +136,40 @@ export async function connect(opts) {
         _assistantPrewarmed = true;
         try {
             const { getLocalSharedVersion } = await import("./sharedVendor.js");
-            const localVersion = getLocalSharedVersion();
-            if (!localVersion)
-                return; // nothing cached yet — let assistant_start do it
+            let localVersion = getLocalSharedVersion();
+            const freshSetup = !localVersion;
+            if (!localVersion) {
+                // FIRST LAUNCH: no shared bundle on disk yet. Download it now, on
+                // connect, so the venv is built UP-FRONT instead of making the user wait
+                // 1-2 min mid-chat on their first assistant/pipeline run. Shown to the
+                // user (not verbose-gated) — a silent multi-minute pause reads as "stuck"
+                // and users leave; a clear one-time-setup line keeps their trust.
+                console.log(chalk.hex("#7C6FF0")("\n  ⚙ First-time setup: preparing your local AI runtime (one-time)…"));
+                console.log(chalk.gray("    downloading runtime modules…"));
+                try {
+                    await ensureSharedModules(opts.serverUrl, "latest", opts.token);
+                    localVersion = getLocalSharedVersion();
+                }
+                catch (e) {
+                    console.log(chalk.gray(`    setup deferred (${e?.message || e}) — it will finish on your first run`));
+                    return;
+                }
+                if (!localVersion)
+                    return;
+            }
             const { ensurePythonEnv, getCertBundlePath } = await import("./pythonEnv.js");
+            if (freshSetup)
+                console.log(chalk.gray("    installing Python dependencies (~1-2 min)…"));
             const envResult = await ensurePythonEnv(opts.pythonPath, localVersion, (m) => { if (opts.verbose)
                 console.log(chalk.gray(`  [assistant prewarm] ${m}`)); });
-            if (opts.verbose)
+            if (freshSetup) {
+                console.log(envResult.ok
+                    ? chalk.green("  ✓ Local AI runtime ready — your first chat will start instantly\n")
+                    : chalk.yellow(`  ⚠ runtime setup did not finish (${envResult.reason || "unknown"}); it will retry on your first run\n`));
+            }
+            else if (opts.verbose) {
                 console.log(chalk.gray("  [assistant prewarm] ready"));
+            }
             // ALSO pre-import the heavy Python stack so the first real run/chat
             // doesn't pay the ~6s cold `import shared.runtime.registry`. Spawn it
             // detached + fire-and-forget with the SAME PYTHONPATH/env a real

package/dist/pythonEnv.d.ts

@@ -11,8 +11,10 @@
  */
 export declare function venvPython(): string;
 export declare function getCertBundlePath(): string;
-export declare function ensurePythonEnv(systemPython: string, expectedVersion: string, onProgress?: (msg: string) => void): Promise<{
+type EnsureResult = {
     ok: boolean;
     pythonPath: string;
     reason?: string;
-}>;
+};
+export declare function ensurePythonEnv(systemPython: string, expectedVersion: string, onProgress?: (msg: string) => void): Promise<EnsureResult>;
+export {};

package/dist/pythonEnv.js

@@ -389,7 +389,24 @@ async function ensureNltkData(onProgress) {
 }
 // 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}`))) {
+const _ensureInFlight = new Map();
+export function ensurePythonEnv(systemPython, expectedVersion, onProgress = (m) => console.log(chalk.gray(`  [venv] ${m}`))) {
+    // A valid venv resolves cheaply and must NOT be blocked behind an in-flight
+    // build for a different version — run the impl directly (its own early-return
+    // handles the cache hit). Only route through the singleflight when a build is
+    // actually needed, so two build requests coalesce.
+    if (venvIsValid(expectedVersion) && !_ensureInFlight.has(expectedVersion)) {
+        return _ensurePythonEnvImpl(systemPython, expectedVersion, onProgress);
+    }
+    const existing = _ensureInFlight.get(expectedVersion);
+    if (existing)
+        return existing;
+    const p = _ensurePythonEnvImpl(systemPython, expectedVersion, onProgress)
+        .finally(() => { _ensureInFlight.delete(expectedVersion); });
+    _ensureInFlight.set(expectedVersion, p);
+    return p;
+}
+async function _ensurePythonEnvImpl(systemPython, expectedVersion, onProgress = (m) => console.log(chalk.gray(`  [venv] ${m}`))) {
     if (venvIsValid(expectedVersion)) {
         // 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

package/package.json

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