clawmatrix 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmatrix",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Decentralized mesh cluster plugin for OpenClaw — inter-gateway communication, model proxy, task handoff, and tool proxy.",
   "type": "module",
   "license": "MIT",

package/src/acp-proxy.ts

@@ -38,6 +38,20 @@ import type {
 } from "./types.ts";
 import { TaskActivityBroadcaster } from "./task-activity.ts";
 
+/** Extract a human-readable message from any thrown value (Error, JSON-RPC error object, etc.) */
+function errorMessage(err: unknown): string {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "object" && err !== null) {
+    const obj = err as Record<string, unknown>;
+    if (typeof obj.message === "string") return obj.message;
+    // JSON-RPC error: { code: number, message: string, data?: ... }
+    if (typeof obj.code === "number" && typeof obj.message === "string") return obj.message;
+    // Fallback: try JSON.stringify to avoid [object Object]
+    try { return JSON.stringify(err); } catch { /* fall through */ }
+  }
+  return String(err);
+}
+
 const DEFAULT_TIMEOUT = 600_000;
 const DEFAULT_SESSION_TTL = 1_800_000;
 const DEFAULT_MAX_SESSIONS = 5;
@@ -108,6 +122,8 @@ export class AcpProxy {
   private pendingResumes = new Set<string>();
   private pendingChatHistory = new Set<string>();
   private cleanupTimer: ReturnType<typeof setInterval> | null = null;
+  // Multi-device sync: track which nodes are watching each session
+  private sessionWatchers = new Map<string, Set<string>>();
 
   constructor(config: ClawMatrixConfig, peerManager: PeerManager, openclawConfig?: Record<string, unknown>, gatewayInfo?: GatewayInfo) {
     this.config = config;
@@ -128,6 +144,44 @@ export class AcpProxy {
     this.cleanupTimer = setInterval(() => this.cleanupIdleSessions(), CLEANUP_INTERVAL);
   }
 
+  // ── Multi-device sync helpers ──────────────────────────────────
+
+  private addSessionWatcher(sessionId: string, nodeId: string) {
+    let watchers = this.sessionWatchers.get(sessionId);
+    if (!watchers) {
+      watchers = new Set();
+      this.sessionWatchers.set(sessionId, watchers);
+    }
+    watchers.add(nodeId);
+  }
+
+  /** Send a frame to all session watchers except the specified node (usually the original `from`). */
+  private sendToOtherWatchers(sessionId: string, exclude: string, frame: AcpStreamChunk | AcpTaskResponse) {
+    const watchers = this.sessionWatchers.get(sessionId);
+    if (!watchers) return;
+    for (const nodeId of watchers) {
+      if (nodeId === exclude) continue;
+      this.peerManager.sendTo(nodeId, { ...frame, to: nodeId });
+    }
+  }
+
+  /** Send an acp_res to all session watchers except the original requester. */
+  private sendResponseToOtherWatchers(requestId: string, sessionId: string, exclude: string, payload: AcpTaskResponse["payload"]) {
+    const watchers = this.sessionWatchers.get(sessionId);
+    if (!watchers) return;
+    for (const nodeId of watchers) {
+      if (nodeId === exclude) continue;
+      this.peerManager.sendTo(nodeId, {
+        type: "acp_res",
+        id: requestId,
+        from: this.config.nodeId,
+        to: nodeId,
+        timestamp: Date.now(),
+        payload,
+      } satisfies AcpTaskResponse);
+    }
+  }
+
   // ── Requester side: send prompt ────────────────────────────────
 
   async prompt(
@@ -393,7 +447,7 @@ export class AcpProxy {
     if (frame.payload.event !== "agent_thought_chunk") {
       pending.accumulated += frame.payload.delta;
     }
-    if (pending.onStream && frame.payload.delta) {
+    if (pending.onStream) {
       pending.onStream(frame.payload.delta);
     }
 
@@ -500,7 +554,7 @@ export class AcpProxy {
               try {
                 newSession = await this.createSessionWithResume(agent, resumeAcpSessionId, effectiveCwd, from);
               } catch (resumeErr) {
-                debug("acp", `Resume failed (${resumeErr instanceof Error ? resumeErr.message : String(resumeErr)}), falling back to new session`);
+                debug("acp", `Resume failed (${errorMessage(resumeErr)}), falling back to new session`);
                 newSession = await this.createSession(agent, cwd, from);
               }
             } else {
@@ -509,6 +563,7 @@ export class AcpProxy {
             }
             if (mode === "persistent") {
               this.sessions.set(newSession.sessionId, newSession);
+              this.addSessionWatcher(newSession.sessionId, from);
             }
             if (task) {
               await this.runPrompt(id, from, newSession, task, images);
@@ -535,6 +590,7 @@ export class AcpProxy {
             };
             if (mode === "persistent") {
               this.sessions.set(newId, nativeSession);
+              this.addSessionWatcher(newId, from);
             }
             if (task) {
               await this.runNativePrompt(id, from, nativeSession, task);
@@ -544,10 +600,8 @@ export class AcpProxy {
           }
           return;
         }
-        if (session.from !== from) {
-          this.sendResponse(id, from, { success: false, error: "Not the session owner" });
-          return;
-        }
+        // Track this node as a session watcher for multi-device sync
+        this.addSessionWatcher(sessionId, from);
         session.lastActiveAt = Date.now();
         if (session.kind === "native") {
           await this.runNativePrompt(id, from, session, task);
@@ -569,6 +623,7 @@ export class AcpProxy {
           const session = await this.createSession(agent, cwd, from);
           if (mode === "persistent") {
             this.sessions.set(session.sessionId, session);
+            this.addSessionWatcher(session.sessionId, from);
           }
           if (task) {
             await this.runPrompt(id, from, session, task, images);
@@ -598,6 +653,7 @@ export class AcpProxy {
           };
           if (mode === "persistent") {
             this.sessions.set(newId, nativeSession);
+            this.addSessionWatcher(newId, from);
           }
           if (task) {
             await this.runNativePrompt(id, from, nativeSession, task);
@@ -609,7 +665,7 @@ export class AcpProxy {
     } catch (err) {
       this.sendResponse(id, from, {
         success: false,
-        error: err instanceof Error ? err.message : String(err),
+        error: errorMessage(err),
       });
     }
   }
@@ -680,7 +736,7 @@ export class AcpProxy {
       this.peerManager.sendTo(from, {
         type: "acp_list_res", id, from: this.config.nodeId, to: from,
         timestamp: Date.now(),
-        payload: { success: false, error: err instanceof Error ? err.message : String(err) },
+        payload: { success: false, error: errorMessage(err) },
       } satisfies AcpListResponse);
     }
   }
@@ -707,10 +763,11 @@ export class AcpProxy {
         try {
           session = await this.createSessionWithResume(agent, acpSessionId, cwd, from);
         } catch (resumeErr) {
-          debug("acp", `Resume failed (${resumeErr instanceof Error ? resumeErr.message : String(resumeErr)}), falling back to new session`);
+          debug("acp", `Resume failed (${errorMessage(resumeErr)}), falling back to new session`);
           session = await this.createSession(agent, cwd, from);
         }
         this.sessions.set(session.sessionId, session);
+        this.addSessionWatcher(session.sessionId, from);
 
         this.peerManager.sendTo(from, {
           type: "acp_resume_res", id, from: this.config.nodeId, to: from,
@@ -731,6 +788,7 @@ export class AcpProxy {
           abortController: null,
         };
         this.sessions.set(sessionId, nativeSession);
+        this.addSessionWatcher(sessionId, from);
 
         this.peerManager.sendTo(from, {
           type: "acp_resume_res", id, from: this.config.nodeId, to: from,
@@ -742,7 +800,7 @@ export class AcpProxy {
       this.peerManager.sendTo(from, {
         type: "acp_resume_res", id, from: this.config.nodeId, to: from,
         timestamp: Date.now(),
-        payload: { success: false, error: err instanceof Error ? err.message : String(err) },
+        payload: { success: false, error: errorMessage(err) },
       } satisfies AcpResumeResponse);
     }
   }
@@ -785,7 +843,7 @@ export class AcpProxy {
       this.peerManager.sendTo(from, {
         type: "acp_cancel_res", id, from: this.config.nodeId, to: from,
         timestamp: Date.now(),
-        payload: { success: false, error: err instanceof Error ? err.message : String(err) },
+        payload: { success: false, error: errorMessage(err) },
       } satisfies AcpCancelResponse);
     }
   }
@@ -828,7 +886,7 @@ export class AcpProxy {
       this.peerManager.sendTo(from, {
         type: "acp_set_mode_res", id, from: this.config.nodeId, to: from,
         timestamp: Date.now(),
-        payload: { success: false, error: err instanceof Error ? err.message : String(err) },
+        payload: { success: false, error: errorMessage(err) },
       } satisfies AcpSetModeResponse);
     }
   }
@@ -889,7 +947,7 @@ export class AcpProxy {
       this.peerManager.sendTo(from, {
         type: "chat_history_res", id, from: this.config.nodeId, to: from,
         timestamp: Date.now(),
-        payload: { success: false, error: err instanceof Error ? err.message : String(err) },
+        payload: { success: false, error: errorMessage(err) },
       } satisfies ChatHistoryResponse);
     }
   }
@@ -1056,8 +1114,16 @@ export class AcpProxy {
               streamCallback?.(content.text, updateType);
             }
           } else if (updateType === "tool_call") {
-            const toolName = (update as { name?: string }).name ?? "unknown";
+            const toolName = (update as { title?: string }).title
+              || (update as { toolCallId?: string }).toolCallId
+              || "unknown";
+            debug("acp", `tool_call update: title=${JSON.stringify((update as any).title)} toolCallId=${JSON.stringify((update as any).toolCallId)} keys=${Object.keys(update).join(",")}`);
             streamCallback?.(`\n[tool_call: ${toolName}]\n`, updateType);
+          } else if (updateType === "tool_call_update") {
+            const status = (update as { status?: string }).status;
+            if (status === "completed" || status === "error") {
+              streamCallback?.("", "tool_result");
+            }
           }
         },
       }),
@@ -1154,16 +1220,18 @@ export class AcpProxy {
     // Broadcast task started to mobile nodes
     this.taskActivity.broadcast(requestId, "acp", "started", session.agent, promptStartedAt, task.slice(0, 100));
 
-    // Wire streaming to send acp_stream frames
+    // Wire streaming to send acp_stream frames (to requester + all session watchers)
     session.setStreamCallback((delta, event) => {
-      this.peerManager.sendTo(from, {
+      const streamFrame: AcpStreamChunk = {
         type: "acp_stream",
         id: requestId,
         from: this.config.nodeId,
         to: from,
         timestamp: Date.now(),
-        payload: { delta, event, done: false },
-      } satisfies AcpStreamChunk);
+        payload: { delta, event, done: false, sessionId: session.sessionId },
+      };
+      this.peerManager.sendTo(from, streamFrame);
+      this.sendToOtherWatchers(session.sessionId, from, streamFrame);
 
       // Broadcast progress to mobile nodes (only on meaningful events, not every text chunk)
       if (event === "tool_call") {
@@ -1184,37 +1252,41 @@ export class AcpProxy {
     });
 
     try {
-      const promptParts: Array<{ type: string; text?: string; data?: string; media_type?: string }> = [
+      const promptParts: Array<Record<string, unknown>> = [
         { type: "text", text: task },
       ];
       if (images && images.length > 0) {
         for (const img of images) {
-          promptParts.push({ type: "image", data: img.data, media_type: img.mediaType });
+          promptParts.push({ type: "image", data: img.data, mimeType: img.mediaType });
         }
       }
       const promptResponse = await session.conn.prompt({
         sessionId: session.acpSessionId,
-        prompt: promptParts,
+        prompt: promptParts as any,
       });
 
-      // Send done marker
-      this.peerManager.sendTo(from, {
+      // Send done marker to requester + watchers
+      const doneFrame: AcpStreamChunk = {
         type: "acp_stream",
         id: requestId,
         from: this.config.nodeId,
         to: from,
         timestamp: Date.now(),
-        payload: { delta: "", done: true },
-      } satisfies AcpStreamChunk);
+        payload: { delta: "", done: true, sessionId: session.sessionId },
+      };
+      this.peerManager.sendTo(from, doneFrame);
+      this.sendToOtherWatchers(session.sessionId, from, doneFrame);
 
-      this.sendResponse(requestId, from, {
+      const responsePayload: AcpTaskResponse["payload"] = {
         success: true,
         nodeId: this.config.nodeId,
         agent: session.agent,
         sessionId: this.sessions.has(session.sessionId) ? session.sessionId : undefined,
         acpSessionId: session.acpSessionId,
         stopReason: promptResponse.stopReason,
-      });
+      };
+      this.sendResponse(requestId, from, responsePayload);
+      this.sendResponseToOtherWatchers(requestId, session.sessionId, from, responsePayload);
 
       // Broadcast task completed
       this.taskActivity.broadcast(requestId, "acp", "completed", session.agent, promptStartedAt);
@@ -1222,7 +1294,7 @@ export class AcpProxy {
       // Broadcast task failed
       this.taskActivity.broadcast(
         requestId, "acp", "failed", session.agent, promptStartedAt,
-        err instanceof Error ? err.message : String(err),
+        errorMessage(err),
       );
       throw err;
     } finally {
@@ -1271,31 +1343,35 @@ export class AcpProxy {
         throw new Error(`Gateway returned ${res.status}: ${text}`);
       }
 
-      // Stream SSE response as acp_stream frames
-      const result = await this.streamGatewaySSE(res, requestId, from);
+      // Stream SSE response as acp_stream frames (to requester + watchers)
+      const result = await this.streamGatewaySSE(res, requestId, from, session.sessionId);
 
-      // Send done marker
-      this.peerManager.sendTo(from, {
+      // Send done marker to requester + watchers
+      const doneFrame: AcpStreamChunk = {
         type: "acp_stream",
         id: requestId,
         from: this.config.nodeId,
         to: from,
         timestamp: Date.now(),
-        payload: { delta: "", done: true },
-      } satisfies AcpStreamChunk);
+        payload: { delta: "", done: true, sessionId: session.sessionId },
+      };
+      this.peerManager.sendTo(from, doneFrame);
+      this.sendToOtherWatchers(session.sessionId, from, doneFrame);
 
-      this.sendResponse(requestId, from, {
+      const responsePayload: AcpTaskResponse["payload"] = {
         success: true,
         nodeId: this.config.nodeId,
         agent: session.agent,
         sessionId: session.sessionId,
         result,
-      });
+      };
+      this.sendResponse(requestId, from, responsePayload);
+      this.sendResponseToOtherWatchers(requestId, session.sessionId, from, responsePayload);
       this.taskActivity.broadcast(requestId, "acp", "completed", session.agent, promptStartedAt);
     } catch (err) {
       this.taskActivity.broadcast(
         requestId, "acp", "failed", session.agent, promptStartedAt,
-        err instanceof Error ? err.message : String(err),
+        errorMessage(err),
       );
       throw err;
     } finally {
@@ -1304,7 +1380,7 @@ export class AcpProxy {
   }
 
   /** Parse SSE streaming response from gateway and relay as acp_stream chunks. */
-  private async streamGatewaySSE(res: Response, requestId: string, to: string): Promise<string> {
+  private async streamGatewaySSE(res: Response, requestId: string, to: string, sessionId?: string): Promise<string> {
     const body = res.body;
     if (!body) return "";
 
@@ -1332,14 +1408,16 @@ export class AcpProxy {
             const delta = parsed.choices?.[0]?.delta?.content;
             if (delta) {
               full += delta;
-              this.peerManager.sendTo(to, {
+              const streamFrame: AcpStreamChunk = {
                 type: "acp_stream",
                 id: requestId,
                 from: this.config.nodeId,
                 to,
                 timestamp: Date.now(),
-                payload: { delta, done: false },
-              } satisfies AcpStreamChunk);
+                payload: { delta, done: false, sessionId },
+              };
+              this.peerManager.sendTo(to, streamFrame);
+              if (sessionId) this.sendToOtherWatchers(sessionId, to, streamFrame);
             }
           } catch {
             // skip malformed SSE lines
@@ -1414,8 +1492,16 @@ export class AcpProxy {
               streamCallback?.(content.text, updateType);
             }
           } else if (updateType === "tool_call") {
-            const toolName = (update as { name?: string }).name ?? "unknown";
+            const toolName = (update as { title?: string }).title
+              || (update as { toolCallId?: string }).toolCallId
+              || "unknown";
+            debug("acp", `tool_call update: title=${JSON.stringify((update as any).title)} toolCallId=${JSON.stringify((update as any).toolCallId)} keys=${Object.keys(update).join(",")}`);
             streamCallback?.(`\n[tool_call: ${toolName}]\n`, updateType);
+          } else if (updateType === "tool_call_update") {
+            const status = (update as { status?: string }).status;
+            if (status === "completed" || status === "error") {
+              streamCallback?.("", "tool_result");
+            }
           }
         },
       }),
@@ -1628,16 +1714,38 @@ export class AcpProxy {
 
   private sendResponse(id: string, to: string, payload: AcpTaskResponse["payload"]) {
     debug("acp", `sendResponse: id=${id} to=${to} success=${payload.success} error=${payload.error ?? "(none)"}`);
-    const sent = this.peerManager.sendTo(to, {
-      type: "acp_res",
+    const frame = {
+      type: "acp_res" as const,
       id,
       from: this.config.nodeId,
       to,
       timestamp: Date.now(),
       payload,
-    } satisfies AcpTaskResponse);
+    } satisfies AcpTaskResponse;
+
+    const sent = this.peerManager.sendTo(to, frame);
     if (!sent) {
-      console.error(`[clawmatrix:acp] Failed to send acp_res to ${to} (no route)`);
+      // Peer may be temporarily disconnected (e.g. mobile network change).
+      // Retry a few times with backoff so the response isn't lost.
+      debug("acp", `acp_res to ${to} failed, scheduling retries`);
+      const retryDelays = [2_000, 5_000, 10_000];
+      let attempt = 0;
+      const retry = () => {
+        if (attempt >= retryDelays.length) {
+          console.error(`[clawmatrix:acp] Failed to deliver acp_res to ${to} after ${retryDelays.length} retries`);
+          return;
+        }
+        setTimeout(() => {
+          frame.timestamp = Date.now();
+          if (this.peerManager.sendTo(to, frame)) {
+            debug("acp", `acp_res to ${to} delivered on retry ${attempt + 1}`);
+          } else {
+            attempt++;
+            retry();
+          }
+        }, retryDelays[attempt]);
+      };
+      retry();
     }
   }
 
@@ -1646,6 +1754,7 @@ export class AcpProxy {
     for (const [id, session] of this.sessions) {
       if (now - session.lastActiveAt > this.sessionTTL) {
         this.sessions.delete(id);
+        this.sessionWatchers.delete(id);
         this.destroySession(session);
       }
     }
@@ -1671,6 +1780,7 @@ export class AcpProxy {
       this.destroySession(session);
     }
     this.sessions.clear();
+    this.sessionWatchers.clear();
   }
 }
 

package/src/handoff.ts

@@ -51,6 +51,8 @@ export class HandoffManager {
   private inputRequiredTargets = new Map<string, string>(); // handoffId → targetNodeId
   private staleCleanupTimer: ReturnType<typeof setInterval> | null = null;
   private taskActivity: TaskActivityBroadcaster;
+  // Multi-device sync: track which nodes are watching each handoff session (by sessionId)
+  private sessionWatchers = new Map<string, Set<string>>();
 
   constructor(config: ClawMatrixConfig, peerManager: PeerManager, gatewayInfo: GatewayInfo) {
     this.config = config;
@@ -62,6 +64,27 @@ export class HandoffManager {
     this.staleCleanupTimer = setInterval(() => this.cleanupStale(), STALE_CLEANUP_INTERVAL);
   }
 
+  // ── Multi-device sync helpers ──────────────────────────────────
+
+  private addSessionWatcher(sessionId: string, nodeId: string) {
+    let watchers = this.sessionWatchers.get(sessionId);
+    if (!watchers) {
+      watchers = new Set();
+      this.sessionWatchers.set(sessionId, watchers);
+    }
+    watchers.add(nodeId);
+  }
+
+  /** Send a handoff frame to all session watchers except the specified node. */
+  private sendToOtherWatchers(sessionId: string, exclude: string, frame: HandoffStreamChunk | HandoffResponse | HandoffInputRequired) {
+    const watchers = this.sessionWatchers.get(sessionId);
+    if (!watchers) return;
+    for (const nodeId of watchers) {
+      if (nodeId === exclude) continue;
+      this.peerManager.sendTo(nodeId, { ...frame, to: nodeId });
+    }
+  }
+
   /** Remove stale input_required and canceled entries that exceeded TTL. */
   private cleanupStale() {
     const now = Date.now();
@@ -275,6 +298,9 @@ export class HandoffManager {
       : payload.task;
     const images = payload.images;
 
+    // Track this node as a session watcher for multi-device sync
+    this.addSessionWatcher(sessionId, from);
+
     const activeEntry: ActiveHandoff = {
       abortController: null,
       status: "working",
@@ -367,7 +393,7 @@ export class HandoffManager {
         throw new Error(`Gateway returned ${res.status}: ${text}`);
       }
 
-      const output = await this.streamSSE(res, id, from);
+      const output = await this.streamSSE(res, id, from, activeEntry.sessionId);
 
       if (activeEntry.status === "canceled") {
         this.active.delete(id);
@@ -380,7 +406,7 @@ export class HandoffManager {
       // Broadcast task completed
       this.taskActivity.broadcast(id, "handoff", "completed", agent, activeEntry.startedAt);
 
-      this.peerManager.sendTo(from, {
+      const resFrame: HandoffResponse = {
         type: "handoff_res",
         id,
         from: this.config.nodeId,
@@ -393,7 +419,9 @@ export class HandoffManager {
           result: output.trim(),
           sessionId: activeEntry.sessionId,
         },
-      } satisfies HandoffResponse);
+      };
+      this.peerManager.sendTo(from, resFrame);
+      this.sendToOtherWatchers(activeEntry.sessionId, from, resFrame);
     } catch (err) {
       if (activeEntry.status === "canceled") {
         this.active.delete(id);
@@ -429,6 +457,7 @@ export class HandoffManager {
     res: Response,
     handoffId: string,
     to: string,
+    sessionId?: string,
   ): Promise<string> {
     const body = res.body;
     if (!body) return "";
@@ -457,14 +486,16 @@ export class HandoffManager {
             const delta = parsed.choices?.[0]?.delta?.content;
             if (delta) {
               full += delta;
-              this.peerManager.sendTo(to, {
+              const streamFrame: HandoffStreamChunk = {
                 type: "handoff_stream",
                 id: handoffId,
                 from: this.config.nodeId,
                 to,
                 timestamp: Date.now(),
-                payload: { delta, done: false },
-              } satisfies HandoffStreamChunk);
+                payload: { delta, done: false, sessionId },
+              };
+              this.peerManager.sendTo(to, streamFrame);
+              if (sessionId) this.sendToOtherWatchers(sessionId, to, streamFrame);
 
               // Broadcast progress to mobile nodes (throttled, detail is just
               // a heartbeat — don't send token-level deltas as they're meaningless fragments)
@@ -484,15 +515,17 @@ export class HandoffManager {
       reader.releaseLock();
     }
 
-    // Send final done marker
-    this.peerManager.sendTo(to, {
+    // Send final done marker to requester + watchers
+    const doneFrame: HandoffStreamChunk = {
       type: "handoff_stream",
       id: handoffId,
       from: this.config.nodeId,
       to,
       timestamp: Date.now(),
-      payload: { delta: "", done: true },
-    } satisfies HandoffStreamChunk);
+      payload: { delta: "", done: true, sessionId },
+    };
+    this.peerManager.sendTo(to, doneFrame);
+    if (sessionId) this.sendToOtherWatchers(sessionId, to, doneFrame);
 
     return full;
   }
@@ -641,6 +674,7 @@ export class HandoffManager {
     }
     this.active.clear();
     this.inputRequiredTargets.clear();
+    this.sessionWatchers.clear();
   }
 }
 

package/src/index.ts

@@ -39,7 +39,7 @@ function discoverModels(
   const result: ClawMatrixConfig["models"] = [];
   const seenIds = new Set<string>(); // "provider/modelId"
 
-  // 1. Discover from models.providers (explicit provider configs)
+  // Discover from models.providers (explicit provider configs with baseUrl + apiKey)
   const providers = (cfg.models as { providers?: Record<string, ProviderEntry> } | undefined)?.providers;
   if (providers && typeof providers === "object") {
     for (const [providerId, providerConfig] of Object.entries(providers)) {
@@ -72,47 +72,6 @@ function discoverModels(
     }
   }
 
-  // 2. Discover from agents.defaults.model (primary + fallbacks) — the user's
-  //    configured model list, which includes pi-ai built-in models like
-  //    anthropic/claude-opus-4-6 that aren't in models.providers.
-  const agentDefaults = (cfg.agents as { defaults?: { model?: { primary?: string; fallbacks?: string[] } } } | undefined)?.defaults;
-  const modelConfig = agentDefaults?.model;
-  if (modelConfig) {
-    const refs: string[] = [];
-    if (modelConfig.primary) refs.push(modelConfig.primary);
-    if (Array.isArray(modelConfig.fallbacks)) refs.push(...modelConfig.fallbacks);
-
-    for (const modelRef of refs) {
-      if (typeof modelRef !== "string") continue;
-      const slashIdx = modelRef.indexOf("/");
-      if (slashIdx <= 0) continue;
-      const provider = modelRef.slice(0, slashIdx);
-      const modelId = modelRef.slice(slashIdx + 1);
-      if (!modelId) continue;
-
-      const key = `${provider}/${modelId}`;
-      if (seenIds.has(key)) continue;
-      if (proxyNodeIds.has(provider)) continue;
-      seenIds.add(key);
-
-      // Look up provider config for richer model info if available
-      const providerConfig = providers?.[provider];
-      const providerModel = providerConfig?.models?.find((m: Record<string, unknown>) => m.id === modelId);
-      result.push({
-        id: modelId,
-        provider,
-        description: providerModel?.name as string | undefined,
-        baseUrl: providerConfig?.baseUrl,
-        apiKey: typeof providerConfig?.apiKey === "string" ? providerConfig.apiKey : undefined,
-        api: (providerModel?.api ?? providerConfig?.api) as ClawMatrixConfig["models"][0]["api"],
-        contextWindow: providerModel?.contextWindow as number | undefined,
-        maxTokens: providerModel?.maxTokens as number | undefined,
-        reasoning: providerModel?.reasoning as boolean | undefined,
-        input: providerModel?.input as ("text" | "image")[] | undefined,
-      });
-    }
-  }
-
   if (result.length > 0) {
     debug("models", `Auto-discovered ${result.length} model(s): ${result.map((m) => `${m.provider}/${m.id}`).join(", ")}`);
   }
@@ -158,15 +117,16 @@ const plugin = {
         }
       }
 
-      // Filter out models that have no direct API endpoint — these rely on OpenClaw's
-      // internal API key management and cannot be served to remote cluster nodes.
-      // Without this filter, remote nodes discover and try to use these models via
-      // model_req, only to get "No direct API endpoint configured" errors.
-      const openclawProviders = ((api.config as Record<string, unknown>).models as { providers?: Record<string, { baseUrl?: string }> } | undefined)?.providers;
+      // Filter out models that have no direct API endpoint with apiKey — these rely
+      // on OpenClaw's internal API key management and cannot be served to remote
+      // cluster nodes. Built-in providers (e.g. anthropic) may have a default baseUrl
+      // but no apiKey in the provider config, so we must check both.
+      const openclawProviders = ((api.config as Record<string, unknown>).models as { providers?: Record<string, { baseUrl?: string; apiKey?: string }> } | undefined)?.providers;
       const servable = config.models.filter((m) => {
-        if (m.baseUrl) return true;
-        if (openclawProviders?.[m.provider]?.baseUrl) return true;
-        return false;
+        const providerCfg = openclawProviders?.[m.provider];
+        const baseUrl = m.baseUrl || providerCfg?.baseUrl;
+        const apiKey = m.apiKey || (typeof providerCfg?.apiKey === "string" ? providerCfg.apiKey : undefined);
+        return !!(baseUrl && apiKey);
       });
       if (servable.length < config.models.length) {
         const dropped = config.models.length - servable.length;

package/src/types.ts

@@ -198,6 +198,7 @@ export interface HandoffStreamChunk extends ClusterFrame {
     delta: string;
     done: boolean;
     artifacts?: Artifact[];
+    sessionId?: string;     // included for session watchers (multi-device sync)
   };
 }
 
@@ -472,6 +473,7 @@ export interface AcpStreamChunk extends ClusterFrame {
     delta: string;
     event?: string;         // "agent_message_chunk" | "tool_call" | etc.
     done: boolean;
+    sessionId?: string;     // included for session watchers (multi-device sync)
   };
 }