@melaya/runner 1.0.77 → 1.0.79

package/dist/assistantHost.py

@@ -37,6 +37,10 @@ import traceback
 _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": {}}
+
 
 def _emit(turn_id: str, kind: str, **fields) -> None:
     """Write one structured event line to stdout (flushed) for the runner to relay."""
@@ -96,24 +100,45 @@ def _build_agent():
     model = os.environ.get("MEL_ASSISTANT_MODEL", "") or None
     language = os.environ.get("MEL_ASSISTANT_LANGUAGE", "en")
 
-    # Read-only platform tools (pipelines, runs, costs, usage, templates, evals).
-    # They POST to /api/v1/private/assistant-tool with MELAYA_API_KEY; tenant
-    # scope is enforced server-side.
+    # Phone control is offered ONLY on the native mobile app surface — the same
+    # gate as the server-side melaya_run_phone_task tool. A desktop / web chat
+    # never gets the phone_* tools, even if a phone is paired.
+    phone_enabled = os.environ.get("MEL_ASSISTANT_SURFACE", "") == "mobile-native"
+
+    # Read-only platform tools (melaya_agent); phone control (Device Control) on
+    # mobile only. These POST to /api/v1/private/assistant-tool + /phone/command
+    # with MELAYA_API_KEY; tenant scope is enforced server-side.
+    categories = ["melaya_agent"] + (["phone"] if phone_enabled else [])
     try:
-        toolkit = build_toolkit(categories=["melaya_agent"])
+        toolkit = build_toolkit(categories=categories)
     except Exception as exc:
-        _log(f"build_toolkit(melaya_agent) failed: {exc}; starting tool-less")
-        toolkit = build_toolkit(names=[])
-
+        _log(f"build_toolkit({categories}) failed: {exc}; retrying melaya_agent only")
+        try:
+            toolkit = build_toolkit(categories=["melaya_agent"])
+        except Exception:
+            toolkit = build_toolkit(names=[])
+
+    phone_rule = (
+        "- If the user asks you to DO something on their phone (open an app, browse, "
+        "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"
+        if phone_enabled else ""
+    )
     sys_prompt = (
         "You are the Melaya Assistant, the in-app copilot of the Melaya "
         "agent-orchestration platform. You have READ-ONLY tools over the data "
         "this user is allowed to see: pipelines, runs, LLM costs, plan usage, "
-        "validated workflow templates and eval results.\n"
-        "Rules:\n"
+        "validated workflow templates and eval results"
+        + (" — plus phone-control tools to drive the user's paired phone." if phone_enabled else ".")
+        + "\nRules:\n"
         "- Use tools to answer questions about the user's pipelines, spend, usage, "
-        "templates or evals — never invent numbers.\n"
-        "- Be concise and concrete; format small tables or bullet lists when comparing items.\n"
+        "templates or evals — never invent numbers. For cost, melaya_cost_summary "
+        "supports dimension='pipeline' to find which pipeline cost the most.\n"
+        + phone_rule
+        + "- Be concise and concrete; format small tables or bullet lists when comparing items.\n"
         "- If a question is outside the platform, answer normally without tools.\n"
         + (f"- Answer in the user's language: {language}.\n" if language and language != "en" else "")
     )
@@ -129,14 +154,63 @@ def _build_agent():
         reliability=True,
         bounded_memory=True,
     )
+    _register_stream_hooks(agent)
     return agent
 
 
+def _register_stream_hooks(agent) -> None:
+    """Emit delta / tool events live as the agent produces output (pre_print gives
+    cumulative snapshots per message; we forward the new suffix as a delta)."""
+    try:
+        from shared.runtime.events import _flatten_agent_text
+    except Exception:
+        return
+
+    def _pre_print(*_args, **kwargs) -> None:
+        try:
+            tid = _stream.get("turnId")
+            if not tid:
+                return
+            msg = kwargs.get("msg") or kwargs.get("message")
+            if msg is None:
+                return
+            mid = str(getattr(msg, "id", "") or id(msg))
+            text = _flatten_agent_text(getattr(msg, "content", msg))
+            if not text:
+                return
+            prev = _stream["lens"].get(mid, 0)
+            if len(text) > prev:
+                _emit(tid, "delta", content=text[prev:])
+                _stream["lens"][mid] = len(text)
+        except Exception:
+            pass
+
+    def _post_acting(*_args, **kwargs) -> None:
+        try:
+            tid = _stream.get("turnId")
+            if not tid:
+                return
+            for tc in (kwargs.get("tool_calls") or []):
+                name = tc.get("name", "") if isinstance(tc, dict) else getattr(tc, "name", "")
+                if name:
+                    _emit(tid, "tool", name=str(name))
+        except Exception:
+            pass
+
+    for hook_type, fn in (("pre_print", _pre_print), ("post_acting", _post_acting)):
+        try:
+            agent.register_instance_hook(hook_type, fn)
+        except Exception:
+            pass
+
+
 def _run_turn(agent, turn_id: str, message: str) -> None:
     import asyncio
     from agentscope.message import Msg
 
     _emit(turn_id, "round", n=1)
+    _stream["turnId"] = turn_id
+    _stream["lens"] = {}
 
     async def _go():
         return await agent(Msg("user", message, "user"))
@@ -145,10 +219,14 @@ def _run_turn(agent, turn_id: str, message: str) -> None:
         result = asyncio.run(_go())
     except Exception as exc:
         _log("turn error:\n" + traceback.format_exc())
+        _stream["turnId"] = ""
         _emit(turn_id, "error", message=str(exc) or "assistant turn failed")
         _emit(turn_id, "done")
         return
 
+    _stream["turnId"] = ""
+    # Authoritative final answer — the client swaps the streamed plain text for
+    # this markdown-rendered version.
     text = _extract_text(result)
     _emit(turn_id, "text", content=text)
     _emit(turn_id, "done")

package/dist/connection.js

@@ -825,7 +825,10 @@ export async function connect(opts) {
                 emitEv({ kind: "error", message: "assistantHost.py not found — reinstall @melaya/runner" });
                 return;
             }
-            const workDir = join(tmpdir(), `melaya-assistant-${sid}`);
+            // Sanitize the session id for a filesystem path — it is
+            // `userId:conversationId`, and ':' is illegal in a Windows dir name.
+            const safeSid = sid.replace(/[^A-Za-z0-9._-]/g, "_");
+            const workDir = join(tmpdir(), `melaya-assistant-${safeSid}`);
             mkdirSync(workDir, { recursive: true });
             const stagedHost = join(workDir, "assistantHost.py");
             copyFileSync(hostScript, stagedHost);
@@ -847,6 +850,7 @@ export async function connect(opts) {
                 MEL_ASSISTANT_PROVIDER: String(payload.provider || "claude_code"),
                 MEL_ASSISTANT_MODEL: String(payload.model || ""),
                 MEL_ASSISTANT_LANGUAGE: String(payload.language || "en"),
+                MEL_ASSISTANT_SURFACE: String(payload.surface || ""),
                 // Per-user creds (incl. MELAYA_API_KEY for the tenant-gated tool bridge).
                 ...(payload.credentials || {}),
             };
@@ -872,18 +876,23 @@ export async function connect(opts) {
                     }
                 }
             });
+            const stderrTail = [];
             proc.stderr?.on("data", (data) => {
-                if (!opts.verbose)
-                    return;
                 for (const ln of data.toString().split("\n")) {
                     const t = ln.trimEnd();
-                    if (t)
+                    if (!t)
+                        continue;
+                    if (opts.verbose)
                         console.log(chalk.gray(`  [assistant-stderr] ${t}`));
+                    stderrTail.push(t);
+                    if (stderrTail.length > 40)
+                        stderrTail.shift();
                 }
             });
             proc.on("exit", (code) => {
                 activeAssistants.delete(sid);
-                socket.emit("runner:assistant_event", { sessionId: sid, turnId: "", kind: "session_closed", code });
+                const detail = code !== 0 && stderrTail.length ? stderrTail.slice(-12).join("\n") : "";
+                socket.emit("runner:assistant_event", { sessionId: sid, turnId: "", kind: "session_closed", code, detail });
                 console.log(chalk.gray(`  ■ Assistant session ${sid.slice(0, 10)}… closed (exit ${code})`));
             });
         }

package/package.json

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