@melaya/runner 1.0.95 → 1.0.97

package/dist/assistantHost.py

@@ -177,10 +177,15 @@ def _build_agent():
     model = os.environ.get("MEL_ASSISTANT_MODEL", "") or None
     language = os.environ.get("MEL_ASSISTANT_LANGUAGE", "en")
 
-    # 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"
+    # Phone control unlocks on the native mobile app surface OR whenever the user
+    # has a PAIRED phone (MEL_ASSISTANT_PHONE_READY, set by the server from
+    # getPhonePresence). A desktop / web chat drives the paired phone REMOTELY
+    # through the same Redis queue, so it must not be surface-gated — without this,
+    # desktop chats had zero phone_* tools and the model refused phone tasks.
+    phone_enabled = (
+        os.environ.get("MEL_ASSISTANT_SURFACE", "") == "mobile-native"
+        or os.environ.get("MEL_ASSISTANT_PHONE_READY", "") in ("1", "true", "True")
+    )
 
     # Read-only platform tools (melaya_agent); phone control (Device Control) on
     # mobile only. These POST to /api/v1/private/assistant-tool + /phone/command
@@ -201,10 +206,20 @@ def _build_agent():
     try:
         if connector_services:
             from shared.orchestration.lazy_registry import build_lazy_toolkit
+            # Phone tools must ALWAYS be fully passed, never scoped: a phone task
+            # can't afford search_tools/activate_tool round-trips per tap (that is
+            # the "why did it restrict the tools + it's slow" regression). The lazy
+            # toolkit pins active_categories only UP TO `budget` (default 25), so
+            # phone (~23) + melaya_agent got bumped into the deferred pool. When
+            # phone is enabled, widen the budget so the WHOLE phone + base set stays
+            # active/pinned; the connectors still lazy-defer beyond that.
+            _budget = int(os.environ.get("MEL_LAZY_BUDGET", "25"))
+            if phone_enabled:
+                _budget = max(_budget, 64)
             toolkit = build_lazy_toolkit(
                 active_categories=categories,
                 include_categories=categories + connector_services,
-                budget=int(os.environ.get("MEL_LAZY_BUDGET", "25")),
+                budget=_budget,
             )
         else:
             toolkit = build_toolkit(categories=categories)
@@ -237,7 +252,10 @@ def _build_agent():
         "phone_ask_user(question): it expands the Melaya tile ON THE PHONE into a reply "
         "card and BLOCKS for the user's typed answer WITHOUT ending your turn, so the run "
         "continues seamlessly the moment they reply. Use it SPARINGLY, for real decisions "
-        "only — not routine ones. The EXACT-APP rule still holds (a missing app is a stop, "
+        "only — not routine ones. Do NOT call phone_ask_user to cope with repeated tool "
+        "ERRORS or because you feel stuck/struggling — that is a failure to REPORT, not a "
+        "decision for the user; stop and report what failed instead. Only ask for a genuine "
+        "who/which fork. The EXACT-APP rule still holds (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 "

package/dist/connection.js

@@ -77,11 +77,42 @@ export async function connect(opts) {
             const localVersion = getLocalSharedVersion();
             if (!localVersion)
                 return; // nothing cached yet — let assistant_start do it
-            const { ensurePythonEnv } = await import("./pythonEnv.js");
-            await ensurePythonEnv(opts.pythonPath, localVersion, (m) => { if (opts.verbose)
+            const { ensurePythonEnv, getCertBundlePath } = await import("./pythonEnv.js");
+            const envResult = await ensurePythonEnv(opts.pythonPath, localVersion, (m) => { if (opts.verbose)
                 console.log(chalk.gray(`  [assistant prewarm] ${m}`)); });
             if (opts.verbose)
                 console.log(chalk.gray("  [assistant prewarm] ready"));
+            // ALSO pre-import the heavy Python stack so the first real run/chat
+            // doesn't pay the ~6s cold `import shared.runtime.registry`. Spawn it
+            // detached + fire-and-forget with the SAME PYTHONPATH/env a real
+            // pipeline spawn uses (see the runner:run handler below) so `shared.*`
+            // resolves; this heats the OS file cache + bytecode. Never blocks
+            // connect, never throws — swallow everything. Only when a shared
+            // bundle exists locally (mirror the ensurePythonEnv guard above).
+            if (envResult.ok) {
+                try {
+                    const sharedDir = getSharedDir();
+                    if (existsSync(sharedDir)) {
+                        const certBundle = getCertBundlePath();
+                        const warmEnv = {
+                            ...process.env,
+                            PYTHONPATH: sharedDir,
+                            PYTHONIOENCODING: "utf-8",
+                            PYTHONUTF8: "1",
+                            ...(certBundle ? { SSL_CERT_FILE: certBundle, REQUESTS_CA_BUNDLE: certBundle } : {}),
+                        };
+                        const warmChild = spawn(envResult.pythonPath, ["-c", "import shared.runtime.registry"], { env: warmEnv, stdio: "ignore" });
+                        warmChild.on("error", () => { });
+                        warmChild.on("exit", (code) => {
+                            if (code === 0 && opts.verbose) {
+                                console.log(chalk.gray("  [assistant prewarm] import-warmed"));
+                            }
+                        });
+                        warmChild.unref();
+                    }
+                }
+                catch { /* fire-and-forget — never throw */ }
+            }
         }
         catch (e) {
             if (opts.verbose)
@@ -901,6 +932,10 @@ export async function connect(opts) {
                 MEL_ASSISTANT_MODEL: String(payload.model || ""),
                 MEL_ASSISTANT_LANGUAGE: String(payload.language || "en"),
                 MEL_ASSISTANT_SURFACE: String(payload.surface || ""),
+                // Phone toolkit unlocks when the user has a paired phone, on ANY surface
+                // (desktop drives the paired phone remotely). The host ORs this with the
+                // mobile-native surface check. Empty ⇒ not paired ⇒ no phone tools.
+                MEL_ASSISTANT_PHONE_READY: payload.phoneReady ? "1" : "",
                 // Connector tool sets the user enabled for this chat (comma-joined service
                 // ids). The host seeds a lazy toolkit from these so ANY connector's tools
                 // are reachable without exploding context.

package/package.json

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