@melaya/runner 1.0.83 → 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

@@ -966,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/package.json

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