clawmatrix 0.3.1 → 0.4.1

package/src/index.ts

@@ -17,7 +17,7 @@ import { createClusterAcpTool } from "./tools/cluster-acp.ts";
 import { createClusterTerminalTool } from "./tools/cluster-terminal.ts";
 import { createClusterToolInvokeTool } from "./tools/cluster-tool.ts";
 import { createClusterTransferTool } from "./tools/cluster-transfer.ts";
-import { registerClusterCli } from "./cli.ts";
+import { createClusterNotifyTool } from "./tools/cluster-notify.ts";
 import { spawnProcess } from "./compat.ts";
 
 /**
@@ -304,6 +304,7 @@ const plugin = {
     api.registerTool(createClusterTerminalTool(), { optional: true });
     api.registerTool(createClusterToolInvokeTool(), { optional: true });
     api.registerTool(createClusterTransferTool(), { optional: true });
+    api.registerTool(createClusterNotifyTool(), { optional: true });
 
     // Wire up peer approval with OpenClaw channel API
     if (config.peerApproval.enabled) {
@@ -729,14 +730,455 @@ const plugin = {
       },
     );
 
+    // ── Send / Handoff gateway methods ──────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.send",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node, message } = (params ?? {}) as { node?: string; message?: string };
+          if (!node || !message) {
+            respond(false, { error: "Missing required params: node, message" });
+            return;
+          }
+          const route = runtime.peerManager.router.resolveAgent(node);
+          if (!route) {
+            respond(false, { error: `No reachable agent for target "${node}"` });
+            return;
+          }
+          const sent = runtime.peerManager.sendTo(route.nodeId, {
+            type: "send",
+            from: runtime.config.nodeId,
+            to: route.nodeId,
+            timestamp: Date.now(),
+            payload: { target: node, message },
+          });
+          respond(true, { sent, nodeId: route.nodeId });
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.handoff",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { target, task, context } = (params ?? {}) as {
+            target?: string; task?: string; context?: string;
+          };
+          if (!target || !task) {
+            respond(false, { error: "Missing required params: target, task" });
+            return;
+          }
+          const result = await runtime.handoffManager.handoff(target, task, context);
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    // ── ACP gateway methods ──────────────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.list",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, agent, cwd } = (params ?? {}) as { node?: string; agent?: string; cwd?: string };
+          if (!node) {
+            respond(false, { error: "Missing required param: node" });
+            return;
+          }
+          const result = await runtime.acpProxy.listSessions(node, { agent, cwd });
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.prompt",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, agent, task, sessionId, mode, cwd } = (params ?? {}) as {
+            node?: string; agent?: string; task?: string; sessionId?: string;
+            mode?: "oneshot" | "persistent"; cwd?: string;
+          };
+          if (!node) {
+            respond(false, { error: "Missing required param: node" });
+            return;
+          }
+          if (!agent && !sessionId) {
+            respond(false, { error: "Missing required param: agent (or sessionId for follow-up)" });
+            return;
+          }
+          const result = await runtime.acpProxy.prompt(node, agent ?? "", task ?? "", { sessionId, mode, cwd });
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.resume",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, agent, acpSessionId, cwd } = (params ?? {}) as {
+            node?: string; agent?: string; acpSessionId?: string; cwd?: string;
+          };
+          if (!node || !agent || !acpSessionId) {
+            respond(false, { error: "Missing required params: node, agent, acpSessionId" });
+            return;
+          }
+          const result = await runtime.acpProxy.resumeSession(node, agent, acpSessionId, cwd ?? process.cwd());
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.cancel",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, sessionId } = (params ?? {}) as { node?: string; sessionId?: string };
+          if (!node || !sessionId) {
+            respond(false, { error: "Missing required params: node, sessionId" });
+            return;
+          }
+          const result = await runtime.acpProxy.cancelSession(node, sessionId);
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.close",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, sessionId } = (params ?? {}) as { node?: string; sessionId?: string };
+          if (!node || !sessionId) {
+            respond(false, { error: "Missing required params: node, sessionId" });
+            return;
+          }
+          const result = await runtime.acpProxy.closeSession(node, sessionId);
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    // ── Diagnostic gateway method ────────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.diagnostic",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node, action, command, timeout = 30 } = (params ?? {}) as {
+            node?: string; action?: string; command?: string; timeout?: number;
+          };
+          if (!node || !action) {
+            respond(false, { error: "Missing required params: node, action" });
+            return;
+          }
+          const sentinelNodeId = node.endsWith(":sentinel") ? node : `${node}:sentinel`;
+          const route = runtime.peerManager.router.getRoute(sentinelNodeId);
+          if (!route) {
+            respond(false, { error: `Sentinel "${sentinelNodeId}" is not reachable` });
+            return;
+          }
+          const id = (await import("node:crypto")).randomUUID();
+          const timeoutMs = timeout * 1000;
+
+          const frameType = action === "exec" ? "diagnostic_exec" : "diagnostic_status";
+          const responseType = action === "exec" ? "diagnostic_exec_res" : "diagnostic_status_res";
+          const frame = {
+            type: frameType,
+            id,
+            from: runtime.config.nodeId,
+            to: sentinelNodeId,
+            timestamp: Date.now(),
+            ...(action === "exec" ? { payload: { command, timeout } } : {}),
+          };
+
+          const result = await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+              cleanup();
+              reject(new Error(`Diagnostic timed out after ${timeoutMs}ms`));
+            }, timeoutMs + (action === "exec" ? 5000 : 0));
+
+            const handler = (incoming: any) => {
+              if (incoming.type === responseType && incoming.id === id) {
+                cleanup();
+                resolve(incoming.payload);
+              }
+            };
+
+            const cleanup = () => {
+              clearTimeout(timer);
+              runtime.peerManager.off("frame", handler);
+            };
+
+            runtime.peerManager.on("frame", handler);
+            const sent = runtime.peerManager.router.sendTo(sentinelNodeId, frame as any);
+            if (!sent) {
+              cleanup();
+              reject(new Error(`No route to ${sentinelNodeId}`));
+            }
+          });
+
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    // ── Notify gateway method ────────────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.notify",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { action = "start", taskId: providedTaskId, title, detail, progress, tool, success = true } = (params ?? {}) as {
+            action?: string; taskId?: string; title?: string; detail?: string;
+            progress?: number; tool?: string; success?: boolean;
+          };
+
+          const peers = runtime.peerManager.router.getAllPeers();
+          const mobileTargets = peers.filter((p) =>
+            p.tags.some((t: string) => t === "mobile" || t === "ios" || t === "phone"),
+          );
+
+          if (mobileTargets.length === 0) {
+            respond(false, undefined, { code: "NO_MOBILE_PEERS", message: "No mobile peers connected" });
+            return;
+          }
+
+          const { randomUUID } = require("node:crypto");
+          const taskId = providedTaskId || randomUUID();
+          const now = Date.now();
+
+          let status: string;
+          if (action === "start") status = "started";
+          else if (action === "end") status = success ? "completed" : "failed";
+          else status = "progress";
+
+          const frame = {
+            type: "task_activity",
+            from: runtime.config.nodeId,
+            timestamp: now,
+            payload: {
+              taskId,
+              taskType: "notify",
+              status,
+              agent: title || runtime.config.nodeId,
+              nodeId: runtime.config.nodeId,
+              title: title || runtime.config.nodeId,
+              detail,
+              startedAt: now,
+              elapsedMs: 0,
+              progress,
+              tool,
+            },
+          };
+
+          for (const target of mobileTargets) {
+            runtime.peerManager.sendTo(target.nodeId, { ...frame, to: target.nodeId });
+          }
+
+          respond(true, { taskId, action, targets: mobileTargets.length });
+        } catch {
+          respond(false, undefined, { code: "SERVICE_ERROR", message: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    // ── Terminal gateway methods ──────────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.list",
+      ({ respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          respond(true, runtime.terminalManager.listSessions());
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.open",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node, shell, cols, rows, cwd } = (params ?? {}) as {
+            node?: string; shell?: string; cols?: number; rows?: number; cwd?: string;
+          };
+          if (!node) {
+            respond(false, { error: "Missing required param: node" });
+            return;
+          }
+          const sessionId = await runtime.terminalManager.open(node, { shell, cols, rows, cwd });
+          await new Promise((r) => setTimeout(r, 500));
+          const initial = runtime.terminalManager.readOutput(sessionId);
+          respond(true, { sessionId, nodeId: node, initialOutput: initial.data });
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.input",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { sessionId, data } = (params ?? {}) as { sessionId?: string; data?: string };
+          if (!sessionId || !data) {
+            respond(false, { error: "Missing required params: sessionId, data" });
+            return;
+          }
+          runtime.terminalManager.sendInput(sessionId, data);
+          respond(true, { sent: true });
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.read",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { sessionId } = (params ?? {}) as { sessionId?: string };
+          if (!sessionId) {
+            respond(false, { error: "Missing required param: sessionId" });
+            return;
+          }
+          const output = runtime.terminalManager.readOutput(sessionId);
+          respond(true, output);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.resize",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { sessionId, cols, rows } = (params ?? {}) as { sessionId?: string; cols?: number; rows?: number };
+          if (!sessionId) {
+            respond(false, { error: "Missing required param: sessionId" });
+            return;
+          }
+          runtime.terminalManager.resize(sessionId, cols ?? 80, rows ?? 24);
+          respond(true, { resized: true });
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.close",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { sessionId } = (params ?? {}) as { sessionId?: string };
+          if (!sessionId) {
+            respond(false, { error: "Missing required param: sessionId" });
+            return;
+          }
+          runtime.terminalManager.close(sessionId);
+          respond(true, { closed: true });
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    // ── File transfer gateway method ─────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.transfer",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const ftm = runtime.fileTransferManager;
+          if (!ftm) {
+            respond(false, { error: "File transfer not enabled" });
+            return;
+          }
+          const { source_node, source_path, target_node, target_path } = (params ?? {}) as {
+            source_node?: string; source_path?: string; target_node?: string; target_path?: string;
+          };
+          if (!source_path || !target_path) {
+            respond(false, { error: "Missing required params: source_path, target_path" });
+            return;
+          }
+          if ((source_node && target_node) || (!source_node && !target_node)) {
+            respond(false, { error: "Provide exactly one of source_node (pull) or target_node (push)" });
+            return;
+          }
+          let result;
+          if (source_node) {
+            result = await ftm.pullFile(source_node, source_path, target_path);
+          } else {
+            result = await ftm.pushFile(target_node!, source_path, target_path);
+          }
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
     // Log model selection on each LLM call (fire-and-forget)
     api.on("llm_input", (event) => {
       api.logger.debug(`[clawmatrix] llm_input: provider=${event.provider} model=${event.model}`);
     });
 
-    // CLI subcommand
-    api.registerCli(registerClusterCli, { commands: ["clawmatrix"] });
-
     // Auto-install global `clawmatrix` shim next to the `openclaw` binary.
     // Runs once on plugin load; non-blocking, best-effort.
     installGlobalCliShim(api.logger);
@@ -824,17 +1266,11 @@ const plugin = {
         // Rebuild system context only when peer count changes
         if (peerCount !== cachedPeerCount) {
           cachedPeerCount = peerCount;
-          const lines: string[] = [];
           if (peerCount === 0) {
-            lines.push("[ClawMatrix] No peers online. Use cluster_peers to check cluster status.");
+            cachedSystemContext = `[ClawMatrix] node="${config.nodeId}" — no peers online.`;
           } else {
-            lines.push(
-              `[ClawMatrix Cluster] YOU ARE node="${config.nodeId}"${config.tags.length ? ` tags=${config.tags.join(",")}` : ""}. ${peerCount} peer(s) online.`,
-              ...(config.agents.length > 0 ? [`Role: ${config.agents[0]!.description}`] : []),
-              "Use cluster_peers to see topology. Always tell user which remote node you're targeting before calling cluster tools.",
-            );
+            cachedSystemContext = `[ClawMatrix] node="${config.nodeId}"${config.tags.length ? ` tags=${config.tags.join(",")}` : ""}, ${peerCount} peer(s) online.${config.agents.length > 0 ? ` Role: ${config.agents[0]!.description}` : ""}`;
           }
-          cachedSystemContext = lines.join("\n");
         }
 
         // Per-turn: only push pending events (agent must react proactively)
@@ -962,19 +1398,16 @@ function installGlobalCliShim(logger: { info: (msg: string) => void; warn: (msg:
     const fs = require("node:fs") as typeof import("node:fs");
     const path = require("node:path") as typeof import("node:path");
 
-    // Find the real directory where `openclaw` lives (resolve symlinks)
-    const openclawBin = process.argv[0]; // node process running openclaw
-    // Walk up to find the openclaw binary: it's in the same bin dir as node,
-    // or we can resolve it from process.env.PATH
+    // Find the bin directory where `openclaw` symlink lives (NOT the realpath).
+    // e.g. fnm puts symlinks in .../bin/openclaw -> ../lib/node_modules/openclaw/openclaw.mjs
+    // We want the .../bin/ directory so clawmatrix shim is on PATH.
     let binDir: string | null = null;
     const envPath = process.env.PATH ?? "";
     for (const dir of envPath.split(path.delimiter)) {
       const candidate = path.join(dir, "openclaw");
       try {
         fs.accessSync(candidate, fs.constants.X_OK);
-        // Resolve symlinks to get the real bin directory
-        const realPath = fs.realpathSync(candidate);
-        binDir = path.dirname(realPath);
+        binDir = dir;
         break;
       } catch {
         // Not in this dir
@@ -984,20 +1417,30 @@ function installGlobalCliShim(logger: { info: (msg: string) => void; warn: (msg:
 
     const shimPath = path.join(binDir, "clawmatrix");
 
-    // Skip if shim already exists and is our shim (check marker comment)
+    // CRITICAL: If shimPath is a symlink (e.g. fnm/npm may create one),
+    // writeFileSync follows the symlink and overwrites the TARGET file.
+    // This previously destroyed openclaw.mjs. Always remove stale symlinks first.
     try {
-      const existing = fs.readFileSync(shimPath, "utf-8");
-      if (existing.includes("clawmatrix-shim")) return; // already installed
+      const stat = fs.lstatSync(shimPath);
+      if (stat.isSymbolicLink()) {
+        fs.unlinkSync(shimPath);
+        // Proceed to create a regular file below
+      } else if (stat.isFile()) {
+        // Regular file — check if it's already our shim
+        const existing = fs.readFileSync(shimPath, "utf-8");
+        if (existing.includes("clawmatrix-shim")) return; // already installed
+      }
     } catch {
       // File doesn't exist, proceed to create
     }
 
-    const shim = [
-      "#!/usr/bin/env sh",
-      "# clawmatrix-shim: auto-installed by clawmatrix plugin",
-      'exec openclaw clawmatrix "$@"',
-      "",
-    ].join("\n");
+    // Standalone CLI: bypasses openclaw plugin loading entirely.
+    // Resolves cli/bin/clawmatrix.mjs relative to the plugin directory.
+    const cliScript = path.resolve(__dirname, "..", "cli", "bin", "clawmatrix.mjs");
+    const shim = `#!/usr/bin/env sh
+# clawmatrix-shim: auto-installed by clawmatrix plugin
+exec node "${cliScript}" "$@"
+`;
 
     fs.writeFileSync(shimPath, shim, { mode: 0o755 });
     logger.info(`[clawmatrix] Installed global CLI shim: ${shimPath}`);

package/src/knowledge-sync.ts

@@ -87,6 +87,20 @@ async function pMap<T, R>(items: T[], fn: (item: T) => Promise<R>, concurrency:
   return results;
 }
 
+/** Race a promise against a timeout; calls onTimeout before rejecting. */
+function withTimeout<T>(promise: Promise<T>, ms: number, onTimeout?: () => void): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      onTimeout?.();
+      reject(new Error(`Timed out after ${ms}ms`));
+    }, ms);
+    promise.then(
+      (v) => { clearTimeout(timer); resolve(v); },
+      (e) => { clearTimeout(timer); reject(e); },
+    );
+  });
+}
+
 async function streamToString(stream: ReadableStream | null): Promise<string> {
   if (!stream) return "";
   const reader = stream.getReader();
@@ -1074,20 +1088,20 @@ export class KnowledgeSync {
   }
 
   private async gitCommit(message: string) {
+    const GIT_TIMEOUT_MS = 3000;
     try {
       const add = spawnProcess(["git", "add", "-A"], {
         cwd: this.opts.workspacePath,
         stdout: "pipe",
         stderr: "pipe",
       });
-      await add.exited;
-
+      await withTimeout(add.exited, GIT_TIMEOUT_MS, () => add.kill());
       const diff = spawnProcess(["git", "diff", "--cached", "--quiet"], {
         cwd: this.opts.workspacePath,
         stdout: "pipe",
         stderr: "pipe",
       });
-      const diffCode = await diff.exited;
+      const diffCode = await withTimeout(diff.exited, GIT_TIMEOUT_MS, () => diff.kill());
       if (diffCode === 0) return;
 
       const commit = spawnProcess(
@@ -1098,7 +1112,7 @@ export class KnowledgeSync {
           stderr: "pipe",
         },
       );
-      const commitCode = await commit.exited;
+      const commitCode = await withTimeout(commit.exited, GIT_TIMEOUT_MS, () => commit.kill());
       if (commitCode !== 0) {
         const stderr = await streamToString(commit.stderr);
         debug(TAG, `git commit failed (exit ${commitCode}): ${stderr}`);

package/src/model-proxy.ts

@@ -43,6 +43,7 @@ interface PendingModelReq {
   stream: boolean;
   responseFormat: ResponseFormat;
   model?: string;
+  targetNodeId?: string;
   controller?: ReadableStreamDefaultController;
   encoder?: TextEncoder;
   /** Whether real content (not just setup events) has been sent to the stream. */
@@ -356,12 +357,25 @@ export class ModelProxy {
     this.httpServer.listen(this.config.proxyPort, "127.0.0.1");
   }
 
+  /** Check if there are pending model requests targeting a specific node. */
+  hasPendingForNode(nodeId: string): boolean {
+    for (const p of this.pending.values()) {
+      if (p.targetNodeId === nodeId) return true;
+    }
+    return false;
+  }
+
   stop() {
     if (this.cacheCleanupTimer) {
       clearInterval(this.cacheCleanupTimer);
       this.cacheCleanupTimer = null;
     }
     if (this.httpServer) {
+      // Force-close all keep-alive connections so the port is released immediately
+      const server = this.httpServer as typeof this.httpServer & { closeAllConnections?: () => void };
+      if (typeof server.closeAllConnections === "function") {
+        server.closeAllConnections();
+      }
       this.httpServer.close();
       this.httpServer = null;
     }
@@ -648,6 +662,7 @@ export class ModelProxy {
     this.pending.set(requestId, {
       resolve: () => {}, reject: () => {},
       timer, stream: true, responseFormat, model,
+      targetNodeId,
       controller, encoder,
       hasContent: false,
       failoverCandidates,
@@ -822,6 +837,7 @@ export class ModelProxy {
       this.pending.set(requestId, {
         resolve: resolve as (v: unknown) => void,
         reject, timer, stream: false, responseFormat,
+        targetNodeId,
       });
 
       const sent = this.peerManager.sendTo(targetNodeId, frame);