@melaya/runner 1.0.102 → 1.0.104

package/dist/assistantHost.py

@@ -271,28 +271,29 @@ def _build_agent():
     # then ALWAYS require the in-chat approval card (fail-safe).
     if connector_services and not os.environ.get("MEL_ASSISTANT_CONNECTOR_HITL"):
         os.environ["MEL_ASSISTANT_CONNECTOR_HITL"] = "1"
+    # Core primitives (melaya_core): web_search / web_fetch, files, HTTP, data +
+    # office utilities, scraping, encoding, SQL, etc. — are ALWAYS discoverable via
+    # search_tools/activate_tool. The side-effecting ones run on the USER's OWN
+    # machine (this runner) and are HITL-gated by the assistant's safe/payments
+    # modes, so exposing them for discovery is safe. They stay in the LAZY pool
+    # (not pinned) so the ~73-tool category never explodes the active budget.
+    core_categories = ["melaya_core"]
     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=_budget,
-            )
-        else:
-            toolkit = build_toolkit(categories=categories)
+        from shared.orchestration.lazy_registry import build_lazy_toolkit
+        # Base tools (melaya_agent + phone) stay active+pinned; core + any selected
+        # connectors are deferred + discoverable. Phone tasks need the WHOLE phone
+        # set pinned (no per-tap search_tools round-trips → the old "slow" regression),
+        # so widen the budget when phone is enabled; core/connectors still lazy-defer.
+        _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 + core_categories + connector_services,
+            budget=_budget,
+        )
     except Exception as exc:
-        _log(f"toolkit build failed (connectors={connector_services}): {exc}; retrying melaya_agent only")
+        _log(f"toolkit build failed (connectors={connector_services}, core): {exc}; retrying melaya_agent only")
         try:
             toolkit = build_toolkit(categories=["melaya_agent"])
         except Exception:

package/dist/connection.js

@@ -14,7 +14,7 @@ import { io } from "socket.io-client";
 import chalk from "chalk";
 import ora from "ora";
 import { spawn } from "child_process";
-import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { tmpdir, homedir } from "os";
@@ -28,6 +28,19 @@ import { ensureSharedModules, getSharedDir } from "./sharedVendor.js";
 import { startLumaBrowserBridge } from "./lumaBrowserBridge.js";
 const HEARTBEAT_INTERVAL = 30_000;
 const activeProcesses = new Map();
+// PR4/P1-5: the assistant-session wire protocol version. Bumped whenever the
+// handshake contract changes (this rev adds hostInstanceId + configHash + a
+// versioned ready/hello). The server enforces a MINIMUM: a runner advertising a
+// lower protocol never gets an assistant session routed to it (it gets a clear
+// "update your runner" instead of a silent stale-memory turn).
+const ASSISTANT_PROTOCOL_VERSION = 2;
+// Best-effort read of our own package version (mirrors cli.ts). Advertised in the
+// hello so the server can log / gate on a package floor too.
+let RUNNER_VERSION = "0.0.0";
+try {
+    RUNNER_VERSION = String(JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version || "0.0.0");
+}
+catch { /* dev tree layout differs — non-fatal */ }
 const activeAssistants = new Map();
 // PR4: sid-keyed boot reservation. The guard-then-spawn in runner:assistant_start
 // has an async gap (ensureSharedModules / ensurePythonEnv awaits) between the
@@ -133,7 +146,7 @@ export async function connect(opts) {
         // Advertise capabilities so the server only routes assistant chat sessions
         // to runners new enough to host them (older runners never get one → the
         // server falls back with a clear "update your runner" instead of hanging).
-        socket.emit("runner:hello", { capabilities: ["assistant_session"], package: "@melaya/runner" });
+        socket.emit("runner:hello", { capabilities: ["assistant_session"], package: "@melaya/runner", version: RUNNER_VERSION, assistantProtocol: ASSISTANT_PROTOCOL_VERSION });
         // Start local event relay
         if (!relay) {
             relay = await startLocalRelay(socket, opts.verbose, opts.serverUrl);
@@ -894,7 +907,7 @@ export async function connect(opts) {
         // that booted under an older generation and reboot it instead of serving the
         // next turn from stale memory/config. A bare ready hid this.
         if (live) {
-            emitEv({ kind: "ready", memoryWatermark: live.memoryWatermark || 0, generation: live.generation });
+            emitEv({ kind: "ready", memoryWatermark: live.memoryWatermark || 0, generation: live.generation, hostInstanceId: live.hostInstanceId, configHash: live.configHash, protocol: ASSISTANT_PROTOCOL_VERSION });
             return;
         }
         // A boot is already in flight for this sid (concurrent start / server restart
@@ -993,7 +1006,10 @@ export async function connect(opts) {
                 ...(payload.credentials || {}),
             };
             const proc = spawn(envResult.pythonPath, ["-u", stagedHost], { cwd: workDir, env, stdio: ["pipe", "pipe", "pipe"] });
-            const session = { proc, lastActivity: Date.now(), stdoutBuf: "", generation, memoryWatermark: 0 };
+            // hostInstanceId + configHash are filled from the host's OWN `ready` frame
+            // (assistantHost.py _HOST_ID / _config_hash) as it boots — authoritative and
+            // server-aligned. Start empty; the stdout parser captures them.
+            const session = { proc, lastActivity: Date.now(), stdoutBuf: "", generation, memoryWatermark: 0, hostInstanceId: "", configHash: "" };
             activeAssistants.set(sid, session);
             console.log(chalk.hex("#7c6ff0")(`  ◆ Assistant session ${sid.slice(0, 10)}… (${payload.provider})`));
             proc.stdout?.on("data", (data) => {
@@ -1011,6 +1027,16 @@ export async function connect(opts) {
                             // truthful watermark and the server skips a needless rehydrate.
                             if (typeof parsed?.memoryWatermark === "number")
                                 session.memoryWatermark = parsed.memoryWatermark;
+                            // CAPTURE the host's authoritative identity off its `ready` frame
+                            // (_HOST_ID / _config_hash) so the live-host ready path can re-report
+                            // them without the host re-emitting; ADD only the wire protocol.
+                            if (parsed?.kind === "ready") {
+                                if (typeof parsed.hostInstanceId === "string")
+                                    session.hostInstanceId = parsed.hostInstanceId;
+                                if (typeof parsed.configHash === "string")
+                                    session.configHash = parsed.configHash;
+                                parsed.protocol = ASSISTANT_PROTOCOL_VERSION;
+                            }
                             socket.emit("runner:assistant_event", { sessionId: sid, ...parsed });
                         }
                         catch { /* skip malformed */ }

package/package.json

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