@melaya/runner 1.1.37 → 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/package.json

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