@melaya/runner 1.0.83 → 1.0.85

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:
@@ -123,14 +127,22 @@ def _build_agent():
         "tap, type, comment, post), use the phone_* tools. ALWAYS call "
         "phone_get_screen_tree before you tap or type. Publish comments/posts with "
         "phone_post_comment / phone_create_post — every publish is approved by the "
-        "user ON THEIR PHONE, so never refuse for safety. Only touch apps the user "
-        "asked for; the phone enforces an allowlist and blocks the rest.\n"
+        "user ON THEIR PHONE, so never refuse for safety.\n"
+        "- EXACT APP ONLY — this overrides your autonomy: operate on the EXACT app "
+        "the user named, never a different one. If that app is not in the allowlist "
+        "(phone_open_app returns app_not_allowed) or not installed, STOP and tell the "
+        "user to authorize/install it in Device Control. NEVER substitute a 'similar', "
+        "'closest', or 'equivalent' app (e.g. do NOT open Instagram when asked for "
+        "TikTok). Opening the wrong app is a FAILED task, not a reasonable default. "
+        "After the user authorizes the app, phone_list_apps reflects it immediately — "
+        "re-check and open the REQUESTED app.\n"
         "- You are FULLY AUTONOMOUS on the phone: NEVER ask the user a question, "
         "never end your turn asking for confirmation or offering a choice — make the "
-        "reasonable decision and DO it. If a feed is algorithmic, use the app's own "
-        "Search / Explore to find the right content yourself. Keep going until the "
-        "task is COMPLETE (e.g. all N comments posted) or you are genuinely blocked; "
-        "only then report what you did and what (if anything) is blocked.\n"
+        "reasonable decision and DO it (the ONE exception is the EXACT-APP rule above: "
+        "a missing app is a stop, not a substitution). If a feed is algorithmic, use "
+        "the app's own Search / Explore to find the right content yourself. Keep going "
+        "until the task is COMPLETE (e.g. all N comments posted) or you are genuinely "
+        "blocked; only then report what you did and what (if anything) is blocked.\n"
         if phone_enabled else ""
     )
     sys_prompt = (
@@ -219,9 +231,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 +259,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 +276,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.85",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,