@melaya/runner 1.1.47 → 1.1.48

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
@@ -1325,9 +1330,17 @@ export async function connect(opts) {
                 const line = session.stdoutBuf.slice(0, idx);
                 session.stdoutBuf = session.stdoutBuf.slice(idx + 1);
                 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 +1356,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.48",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,