@melaya/runner 1.1.47 → 1.1.49

package/dist/assistantHost.py

@@ -230,21 +230,47 @@ class _RedactingStdout:
     def _scrub(self, s: str) -> str:
         return self._B64.sub(lambda m: f"<redacted base64 {len(m.group(0))} bytes>", s)
 
+    def _flush_transcript(self):
+        # Send any buffered agentscope transcript to STDERR (redacted). Keeping it
+        # off stdout means the runner's stdout channel carries ONLY `MELASSIST `
+        # protocol frames: a transcript print can never glue onto a frame and be
+        # dropped (the missing-delta / garbled-fragment bug), and frame parsing on
+        # the runner stays cheap — no multi-KB base64 transcript lines flooding its
+        # event loop (which was spiking lag and dropping the socket heartbeat).
+        if self._buf:
+            try:
+                sys.stderr.write(self._scrub(self._buf))
+            except Exception:
+                pass
+            self._buf = ""
+
     def write(self, s):
         try:
+            # A protocol frame is emitted in ONE write() call, whole and
+            # newline-terminated (see _emit). Route it to the REAL stdout byte for
+            # byte (no scrub — frames are short structured JSON), after flushing any
+            # pending partial transcript so nothing can glue onto it.
+            if s.startswith(_EVENT_PREFIX):
+                self._flush_transcript()
+                self._real.write(s)
+                self._real.flush()
+                return len(s)
+            # Everything else = agentscope's verbatim message transcript → stderr,
+            # line-buffered + base64-redacted, so it never pollutes the protocol.
             self._buf += s
             while "\n" in self._buf:
                 line, self._buf = self._buf.split("\n", 1)
-                self._real.write(self._scrub(line) + "\n")
+                try:
+                    sys.stderr.write(self._scrub(line) + "\n")
+                except Exception:
+                    pass
             return len(s)
         except Exception:
             return self._real.write(s)
 
     def flush(self):
         try:
-            if self._buf:
-                self._real.write(self._scrub(self._buf))
-                self._buf = ""
+            self._flush_transcript()
             self._real.flush()
         except Exception:
             pass

package/dist/connection.js

@@ -55,6 +55,11 @@ try {
 }
 catch { /* dev tree layout differs — non-fatal */ }
 const activeAssistants = new Map();
+// Line prefix the assistant host uses to frame protocol events on stdout
+// (mirror of assistantHost.py `_EVENT_PREFIX`). Everything else on stdout is
+// raw agentscope transcript (now routed to stderr host-side, but we still parse
+// defensively in case a frame arrives glued to a raw print).
+const _EVENT_PREFIX = "MELASSIST ";
 // Warm pool (size 1): a fully-booted host held in reserve, ready to be ADOPTED
 // by the next new session whose config+generation match — skipping the ~7s cold
 // boot (import + build_agent). Pure optimization: any mismatch or unhealthy
@@ -72,6 +77,11 @@ let warmSpareSeed = null;
 // SYNCHRONOUSLY here closes that window.
 const bootingAssistants = new Set();
 const ASSISTANT_IDLE_MS = 15 * 60 * 1000;
+// OOM backstop for the assistant stdout line-framer: if a single unterminated
+// line (no newline) grows past this, flush + reset rather than let `+=` build an
+// unbounded string. Generous — legitimate frames (tool results, transcripts) are
+// far smaller; a line this large would exceed the socket buffer anyway.
+const ASSISTANT_STDOUT_MAX_CARRY = 64 * 1024 * 1024;
 export async function connect(opts) {
     const spinner = ora("Connecting to Melaya...").start();
     // Connect to the /api/v1/runner NAMESPACE on the existing Socket.IO server.
@@ -1319,15 +1329,37 @@ export async function connect(opts) {
         console.log(chalk.hex("#7c6ff0")(`  ◆ Assistant ${a.forward ? "session" : "spare"} ${a.sid.slice(0, 12)}… (${a.providerLabel})`));
         proc.stdout?.on("data", (data) => {
             session.lastActivity = Date.now();
+            // O(n) line framing: accumulate, split ONCE, carry the trailing partial.
+            // The old `buf += …; while(indexOf/slice)` loop re-sliced the WHOLE buffer
+            // per line — O(n²) on a big burst (a large tool result / browser tree in
+            // the transcript). That blocked the Node event loop long enough that
+            // Socket.IO couldn't service the connection (send the engine.io pong), so
+            // the server's pingTimeout dropped the socket MID-TURN — the "heartbeat
+            // stops while working" failure. Keeping this O(n) means the heartbeat and
+            // pong keep flowing no matter how much the host streams.
             session.stdoutBuf += data.toString();
-            let idx;
-            while ((idx = session.stdoutBuf.indexOf("\n")) >= 0) {
-                const line = session.stdoutBuf.slice(0, idx);
-                session.stdoutBuf = session.stdoutBuf.slice(idx + 1);
+            const parts = session.stdoutBuf.split("\n");
+            session.stdoutBuf = parts.pop() ?? "";
+            // OOM backstop: an unterminated line that keeps growing across chunks would
+            // make the `+=` above quadratic again. Flush it as its own line and reset.
+            if (session.stdoutBuf.length > ASSISTANT_STDOUT_MAX_CARRY) {
+                parts.push(session.stdoutBuf);
+                session.stdoutBuf = "";
+                console.log(chalk.yellow(`  [assistant-stdout] flushed oversized line (${(ASSISTANT_STDOUT_MAX_CARRY / 1048576) | 0}MB+) to protect the event loop`));
+            }
+            for (const line of parts) {
                 const t = line.trim();
-                if (t.startsWith("MELASSIST ")) {
+                // A protocol frame can arrive GLUED to a preceding raw print that had no
+                // trailing newline (agentscope prints the agent transcript to the same
+                // stdout), e.g. `Assistant: GotMELASSIST {"kind":"delta",…}`. Find the
+                // prefix ANYWHERE in the line, not just at the start, or that delta is
+                // dropped as raw output (the missing-deltas / garbled-fragment bug).
+                const mi = t.indexOf(_EVENT_PREFIX);
+                if (mi >= 0) {
+                    if (mi > 0 && opts.verbose)
+                        console.log(chalk.gray(`  [assistant-stdout] ${t.slice(0, mi)}`));
                     try {
-                        const parsed = JSON.parse(t.slice("MELASSIST ".length));
+                        const parsed = JSON.parse(t.slice(mi + _EVENT_PREFIX.length));
                         if (typeof parsed?.memoryWatermark === "number")
                             session.memoryWatermark = parsed.memoryWatermark;
                         if (parsed?.kind === "ready") {
@@ -1343,7 +1375,12 @@ export async function connect(opts) {
                         if (session.forward)
                             socket.emit("runner:assistant_event", { sessionId: session.sid, ...parsed });
                     }
-                    catch { /* skip malformed */ }
+                    catch {
+                        // The literal "MELASSIST " appeared inside raw text (not a real frame)
+                        // — the JSON tail won't parse; treat the whole line as raw output.
+                        if (t && opts.verbose)
+                            console.log(chalk.gray(`  [assistant-stdout] ${t}`));
+                    }
                 }
                 else if (t && opts.verbose) {
                     console.log(chalk.gray(`  [assistant-stdout] ${t}`));

package/package.json

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