clawmatrix 0.1.14 → 0.1.15

package/src/peer-manager.ts

@@ -5,9 +5,11 @@ import type { ClawMatrixConfig, PeerConfig } from "./config.ts";
 import { Connection } from "./connection.ts";
 import type { WsTransport } from "./connection.ts";
 import { Router } from "./router.ts";
+import { collectDeviceInfo } from "./device-info.ts";
 import type {
   AnyClusterFrame,
   ClusterFrame,
+  DeviceInfo,
   NodeCapabilities,
   PeerInfo,
   PeerSync,
@@ -24,6 +26,7 @@ export interface PeerManagerEvents {
 
 export class PeerManager extends EventEmitter<PeerManagerEvents> {
   readonly router: Router;
+  readonly localDeviceInfo: DeviceInfo;
   private config: ClawMatrixConfig;
   private localCapabilities: NodeCapabilities;
   private httpServer: Server | null = null;
@@ -35,19 +38,22 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
   private inboundConnections = new Map<WsWebSocket, Connection>();
   private gossipDebounceTimer: ReturnType<typeof setTimeout> | null = null;
 
-  constructor(config: ClawMatrixConfig) {
+  constructor(config: ClawMatrixConfig, openclawVersion?: string) {
     super();
     this.config = config;
+    this.localDeviceInfo = collectDeviceInfo(openclawVersion);
     this.localCapabilities = {
       nodeId: config.nodeId,
       agents: config.agents,
       models: config.models,
       tags: config.tags,
+      deviceInfo: this.localDeviceInfo,
     };
     this.router = new Router(config.nodeId, {
       agents: config.agents,
       models: config.models,
       tags: config.tags,
+      deviceInfo: this.localDeviceInfo,
     });
   }
 
@@ -230,6 +236,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     this.router.addDirectPeer(nodeId, conn, caps);
 
     conn.on("message", (frame) => this.onFrame(frame, conn));
+    conn.on("latency", (ms) => this.router.updateLatency(nodeId, ms));
     conn.on("close", () => this.onPeerDisconnected(conn));
 
     this.sendPeerSync(conn);
@@ -329,8 +336,10 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
       if (peer.nodeId === from.remoteNodeId) {
         const prev = this.router.getRoute(peer.nodeId);
         const hadAgents = prev?.agents.length ?? 0;
+        const hadDirectPeers = prev?.directPeers.length ?? 0;
         this.router.updatePeerCapabilities(peer.nodeId, peer);
-        if (peer.agents.length !== hadAgents || peer.models.length !== (prev?.models.length ?? 0)) {
+        if (peer.agents.length !== hadAgents || peer.models.length !== (prev?.models.length ?? 0)
+            || (peer.directPeers?.length ?? 0) !== hadDirectPeers) {
           changed = true;
         }
       } else {

package/src/router.ts

@@ -1,4 +1,4 @@
-import type { ClusterFrame, AnyClusterFrame, PeerInfo, AgentInfo, ModelInfo } from "./types.ts";
+import type { ClusterFrame, AnyClusterFrame, PeerInfo, AgentInfo, ModelInfo, DeviceInfo } from "./types.ts";
 import type { Connection } from "./connection.ts";
 
 const DEFAULT_TTL = 3;
@@ -15,6 +15,8 @@ export interface RouteEntry {
   reachableVia: string | null; // relay nodeId, null = direct
   lastSeen: number;
   latencyMs: number;
+  directPeers: string[]; // nodeIds this node has direct connections to
+  deviceInfo?: DeviceInfo;
 }
 
 export class Router {
@@ -22,6 +24,7 @@ export class Router {
   private localAgents: AgentInfo[];
   private localModels: ModelInfo[];
   private localTags: string[];
+  private localDeviceInfo?: DeviceInfo;
   private routes = new Map<string, RouteEntry>();
   private connections = new Map<string, Connection>(); // nodeId → direct connection
   private seenFrames = new Map<string, number>(); // frameId → timestamp
@@ -29,12 +32,13 @@ export class Router {
 
   constructor(
     nodeId: string,
-    localCapabilities?: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[] },
+    localCapabilities?: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[]; deviceInfo?: DeviceInfo },
   ) {
     this.nodeId = nodeId;
     this.localAgents = localCapabilities?.agents ?? [];
     this.localModels = localCapabilities?.models ?? [];
     this.localTags = localCapabilities?.tags ?? [];
+    this.localDeviceInfo = localCapabilities?.deviceInfo;
 
     this.pruneTimer = setInterval(() => this.pruneSeenFrames(true), PRUNE_INTERVAL);
   }
@@ -52,7 +56,7 @@ export class Router {
   addDirectPeer(
     nodeId: string,
     connection: Connection,
-    capabilities: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[] },
+    capabilities: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[]; deviceInfo?: DeviceInfo },
   ) {
     this.connections.set(nodeId, connection);
     this.routes.set(nodeId, {
@@ -64,6 +68,8 @@ export class Router {
       reachableVia: null,
       lastSeen: Date.now(),
       latencyMs: 0,
+      directPeers: [],
+      deviceInfo: capabilities.deviceInfo,
     });
   }
 
@@ -83,6 +89,8 @@ export class Router {
       reachableVia: viaNodeId,
       lastSeen: Date.now(),
       latencyMs: 0,
+      directPeers: peer.directPeers ?? [],
+      deviceInfo: peer.deviceInfo,
     });
   }
 
@@ -99,17 +107,30 @@ export class Router {
 
   updatePeerCapabilities(
     nodeId: string,
-    capabilities: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[] },
+    capabilities: { agents: AgentInfo[]; models: ModelInfo[]; tags: string[]; directPeers?: string[]; deviceInfo?: DeviceInfo },
   ) {
     const entry = this.routes.get(nodeId);
     if (entry) {
       entry.agents = capabilities.agents;
       entry.models = capabilities.models;
       entry.tags = capabilities.tags;
+      if (capabilities.directPeers) {
+        entry.directPeers = capabilities.directPeers;
+      }
+      if (capabilities.deviceInfo) {
+        entry.deviceInfo = capabilities.deviceInfo;
+      }
       entry.lastSeen = Date.now();
     }
   }
 
+  updateLatency(nodeId: string, latencyMs: number) {
+    const entry = this.routes.get(nodeId);
+    if (entry) {
+      entry.latencyMs = latencyMs;
+    }
+  }
+
   // ── Routing ────────────────────────────────────────────────────
   getRoute(nodeId: string): RouteEntry | undefined {
     return this.routes.get(nodeId);
@@ -152,24 +173,6 @@ export class Router {
     return candidates[0];
   }
 
-  /** Find node that has a specific model. */
-  resolveModel(modelId: string): RouteEntry | undefined {
-    let candidates: RouteEntry[] = [];
-    for (const entry of this.routes.values()) {
-      if (entry.models.some((m) => m.id === modelId)) {
-        candidates.push(entry);
-      }
-    }
-    if (candidates.length === 0) return undefined;
-
-    candidates.sort((a, b) => {
-      const aDirect = a.connection ? 0 : 1;
-      const bDirect = b.connection ? 0 : 1;
-      if (aDirect !== bDirect) return aDirect - bDirect;
-      return a.latencyMs - b.latencyMs;
-    });
-    return candidates[0];
-  }
 
   /** Resolve a node target (nodeId or "tags:<tag>"). */
   resolveNode(target: string): RouteEntry | undefined {
@@ -275,12 +278,15 @@ export class Router {
   /** Build PeerInfo list for peer_sync. */
   buildPeerSyncPayload(): PeerInfo[] {
     const peers: PeerInfo[] = [];
-    // Include ourselves
+    // Include ourselves with our direct peer list
+    const myDirectPeers = [...this.connections.keys()];
     peers.push({
       nodeId: this.nodeId,
       agents: this.localAgents,
       models: this.localModels,
       tags: this.localTags,
+      directPeers: myDirectPeers,
+      deviceInfo: this.localDeviceInfo,
     });
     for (const entry of this.routes.values()) {
       peers.push({
@@ -289,6 +295,8 @@ export class Router {
         models: entry.models,
         tags: entry.tags,
         reachableVia: entry.reachableVia ?? undefined,
+        directPeers: entry.directPeers.length > 0 ? entry.directPeers : undefined,
+        deviceInfo: entry.deviceInfo,
       });
     }
     return peers;

package/src/types.ts

@@ -23,6 +23,7 @@ export interface AuthRequest extends ClusterFrame {
     agents?: AgentInfo[];
     models?: ModelInfo[];
     tags?: string[];
+    deviceInfo?: DeviceInfo;
   };
 }
 
@@ -33,6 +34,7 @@ export interface AuthOk extends ClusterFrame {
     agents: AgentInfo[];
     models: ModelInfo[];
     tags: string[];
+    deviceInfo?: DeviceInfo;
   };
 }
 
@@ -74,6 +76,8 @@ export interface ModelRequest extends ClusterFrame {
   id: string;
   payload: {
     model: string;
+    provider?: string;
+    api?: string;
     messages: unknown[];
     temperature?: number;
     maxTokens?: number;
@@ -87,6 +91,9 @@ export interface ModelResponse extends ClusterFrame {
   payload: {
     success: boolean;
     content?: string;
+    /** Full message object from upstream (choices[0].message or responses output).
+     *  Carries tool_calls, refusal, etc. that `content` alone cannot represent. */
+    message?: unknown;
     usage?: { inputTokens: number; outputTokens: number };
     error?: string;
   };
@@ -97,6 +104,9 @@ export interface ModelStreamChunk extends ClusterFrame {
   id: string;
   payload: {
     delta: string;
+    /** Full delta object from upstream (choices[0].delta).
+     *  Carries tool_calls chunks that `delta` string cannot represent. */
+    deltaObj?: unknown;
     done: boolean;
     usage?: { inputTokens: number; outputTokens: number };
   };
@@ -163,6 +173,17 @@ export interface ToolProxyResponse extends ClusterFrame {
   };
 }
 
+// ── Device info ───────────────────────────────────────────────────
+export interface DeviceInfo {
+  os: string; // e.g. "Darwin 24.6.0", "Linux 6.1.0"
+  arch: string; // e.g. "arm64", "x64"
+  cpuModel: string; // e.g. "Apple M1 Pro"
+  cpuCores: number; // logical CPU cores
+  totalMemoryMB: number; // total system memory in MB
+  hostname: string; // machine hostname
+  openclawVersion?: string; // e.g. "2026.3.7"
+}
+
 // ── Shared info types ──────────────────────────────────────────────
 export interface AgentInfo {
   id: string;
@@ -198,6 +219,8 @@ export interface PeerInfo {
   models: ModelInfo[];
   tags: string[];
   reachableVia?: string; // nodeId of the relay node
+  directPeers?: string[]; // nodeIds this node has direct connections to
+  deviceInfo?: DeviceInfo; // system/hardware info
 }
 
 export interface NodeCapabilities {
@@ -205,6 +228,7 @@ export interface NodeCapabilities {
   agents: AgentInfo[];
   models: ModelInfo[];
   tags: string[];
+  deviceInfo?: DeviceInfo;
 }
 
 // ── Union of all frame types ───────────────────────────────────────

package/src/web-ui.ts

@@ -94,11 +94,14 @@ ${CSS}
     <div class="panel-right">
       <div class="card chat-card">
         <div class="card-header">
-          <h2>Chat</h2>
+          <h2 id="chat-title">Chat</h2>
           <div class="chat-selects">
             <select id="chat-model" title="Model">
               <option value="">Select model...</option>
             </select>
+            <select id="chat-agent" title="Agent" class="hidden">
+              <option value="">Select agent...</option>
+            </select>
           </div>
         </div>
         <div id="chat-messages" class="chat-messages">
@@ -381,6 +384,8 @@ body {
   padding: 16px 18px;
   font-size: 13px;
   line-height: 1.7;
+  max-height: 320px;
+  overflow-y: auto;
 }
 
 .detail-body .detail-section {
@@ -395,6 +400,34 @@ body {
   margin-bottom: 4px;
 }
 
+.detail-body .detail-label.collapsible {
+  cursor: pointer;
+  user-select: none;
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.detail-body .detail-label.collapsible::before {
+  content: '▶';
+  font-size: 8px;
+  transition: transform 0.15s;
+  display: inline-block;
+}
+
+.detail-body .detail-label.collapsible.expanded::before {
+  transform: rotate(90deg);
+}
+
+.detail-body .detail-items {
+  display: none;
+  padding-top: 2px;
+}
+
+.detail-body .detail-items.expanded {
+  display: block;
+}
+
 .detail-body .detail-tags {
   display: flex;
   flex-wrap: wrap;
@@ -410,6 +443,18 @@ body {
   color: var(--text-secondary);
 }
 
+.detail-body .detail-grid {
+  display: grid;
+  grid-template-columns: auto 1fr;
+  gap: 4px 12px;
+  font-size: 12px;
+}
+
+.detail-body .detail-key {
+  color: var(--text-dim);
+  font-weight: 500;
+}
+
 .detail-body .item-row {
   display: flex;
   align-items: center;
@@ -584,6 +629,8 @@ const JS = `
   let chatStreaming = false;
   let meshNodes = [];
   let meshEdges = [];
+  let chatMode = 'model'; // 'model' | 'handoff'
+  let handoffNodeId = null;
   let hoveredNode = null;
   let dragNode = null;
   let dragOffset = { x: 0, y: 0 };
@@ -755,14 +802,31 @@ const JS = `
 
     // Build edges
     meshEdges = [];
+    const edgeSet = new Set();
+    function addEdge(a, b, type) {
+      const key = [a, b].sort().join('::') + '::' + type;
+      if (edgeSet.has(key)) return;
+      edgeSet.add(key);
+      meshEdges.push({ from: a, to: b, type: type });
+    }
+
+    // Edges from self to direct peers
     for (const p of state.peers) {
       if (p.connection === 'direct') {
-        meshEdges.push({ from: state.nodeId, to: p.nodeId, type: 'direct' });
+        addEdge(state.nodeId, p.nodeId, 'direct');
       } else if (p.reachableVia) {
-        meshEdges.push({ from: p.reachableVia, to: p.nodeId, type: 'relay' });
-        // Also ensure edge from self to relay node
-        if (!meshEdges.find(e => (e.from === state.nodeId && e.to === p.reachableVia) || (e.to === state.nodeId && e.from === p.reachableVia))) {
-          meshEdges.push({ from: state.nodeId, to: p.reachableVia, type: 'direct' });
+        addEdge(p.reachableVia, p.nodeId, 'relay');
+        addEdge(state.nodeId, p.reachableVia, 'direct');
+      }
+    }
+
+    // Edges between remote peers (from directPeers data)
+    for (const p of state.peers) {
+      if (p.directPeers) {
+        for (const dp of p.directPeers) {
+          if (dp !== state.nodeId) {
+            addEdge(p.nodeId, dp, 'direct');
+          }
         }
       }
     }
@@ -1000,6 +1064,7 @@ const JS = `
       // Also select on click
       selectedNode = hit.id;
       updateDetail(hit.id);
+      setChatMode(hit.id !== state.nodeId ? 'handoff' : 'model', hit.id !== state.nodeId ? hit.id : null);
     }
   }
 
@@ -1031,6 +1096,7 @@ const JS = `
       if (!hit) {
         selectedNode = null;
         $('node-detail').classList.add('hidden');
+        setChatMode('model', null);
       }
     }
   }
@@ -1061,6 +1127,22 @@ const JS = `
 
     let html = '';
 
+    // Device info
+    if (nodeData.deviceInfo) {
+      const d = nodeData.deviceInfo;
+      html += '<div class="detail-section">';
+      html += '<div class="detail-label">System</div>';
+      html += '<div class="detail-grid">';
+      html += '<span class="detail-key">OS</span><span>' + esc(d.os) + '</span>';
+      html += '<span class="detail-key">Arch</span><span>' + esc(d.arch) + '</span>';
+      html += '<span class="detail-key">Host</span><span>' + esc(d.hostname) + '</span>';
+      html += '<span class="detail-key">CPU</span><span>' + esc(d.cpuModel) + ' (' + d.cpuCores + ' cores)</span>';
+      html += '<span class="detail-key">Memory</span><span>' + formatMemory(d.totalMemoryMB) + '</span>';
+      if (d.openclawVersion && d.openclawVersion !== 'unknown') html += '<span class="detail-key">OpenClaw</span><span>' + esc(d.openclawVersion) + '</span>';
+      html += '</div>';
+      html += '</div>';
+    }
+
     // Connection info
     if (!isLocal && nodeData.connection === 'relay' && nodeData.reachableVia) {
       html += '<div class="detail-section">';
@@ -1072,27 +1154,29 @@ const JS = `
     // Models
     if (nodeData.models?.length) {
       html += '<div class="detail-section">';
-      html += '<div class="detail-label">Models</div>';
+      html += '<div class="detail-label collapsible" onclick="this.classList.toggle(&#39;expanded&#39;);this.nextElementSibling.classList.toggle(&#39;expanded&#39;)">Models (' + nodeData.models.length + ')</div>';
+      html += '<div class="detail-items">';
       for (const m of nodeData.models) {
         html += '<div class="item-row"><span class="item-icon" style="background:var(--accent)"></span>';
         html += '<span>' + esc(m.id) + '</span>';
         if (m.description) html += '<span style="color:var(--text-dim);font-size:11px"> — ' + esc(m.description) + '</span>';
         html += '</div>';
       }
-      html += '</div>';
+      html += '</div></div>';
     }
 
     // Agents
     if (nodeData.agents?.length) {
       html += '<div class="detail-section">';
-      html += '<div class="detail-label">Agents</div>';
+      html += '<div class="detail-label collapsible" onclick="this.classList.toggle(&#39;expanded&#39;);this.nextElementSibling.classList.toggle(&#39;expanded&#39;)">Agents (' + nodeData.agents.length + ')</div>';
+      html += '<div class="detail-items">';
       for (const a of nodeData.agents) {
         html += '<div class="item-row"><span class="item-icon" style="background:var(--green)"></span>';
         html += '<span>' + esc(a.id) + '</span>';
         if (a.description) html += '<span style="color:var(--text-dim);font-size:11px"> — ' + esc(a.description) + '</span>';
         html += '</div>';
       }
-      html += '</div>';
+      html += '</div></div>';
     }
 
     // Tags
@@ -1116,6 +1200,51 @@ const JS = `
 
   function esc(s) { return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;').replace(/'/g,'&#39;'); }
 
+  function formatMemory(mb) {
+    if (mb >= 1024) return (mb / 1024).toFixed(1) + ' GB';
+    return mb + ' MB';
+  }
+
+  // ── Chat mode ──
+  function setChatMode(mode, nodeId) {
+    if (chatMode === mode && handoffNodeId === nodeId) return;
+    chatMode = mode;
+    handoffNodeId = nodeId;
+
+    const title = $('chat-title');
+    const modelSel = $('chat-model');
+    const agentSel = $('chat-agent');
+
+    if (mode === 'handoff' && nodeId) {
+      title.textContent = 'Handoff \\u2192 ' + nodeId;
+      modelSel.classList.add('hidden');
+      agentSel.classList.remove('hidden');
+      updateAgentSelect();
+    } else {
+      title.textContent = 'Chat';
+      modelSel.classList.remove('hidden');
+      agentSel.classList.add('hidden');
+    }
+
+    // Clear conversation when switching modes
+    chatMessages = [];
+    renderChatMessages();
+  }
+
+  function updateAgentSelect() {
+    const sel = $('chat-agent');
+    const node = state.peers.find(p => p.nodeId === handoffNodeId);
+    sel.innerHTML = '<option value="">Select agent...</option>';
+    if (node?.agents) {
+      for (const a of node.agents) {
+        const opt = document.createElement('option');
+        opt.value = a.id;
+        opt.textContent = a.id + (a.description ? ' \\u2014 ' + a.description : '');
+        sel.appendChild(opt);
+      }
+    }
+  }
+
   // ── Model select ──
   function updateModelSelect() {
     const sel = $('chat-model');
@@ -1169,23 +1298,27 @@ const JS = `
     e.preventDefault();
     if (chatStreaming) return;
 
-    const modelVal = $('chat-model').value;
-    if (!modelVal) { alert('Please select a model'); return; }
-
     const text = chatInput.value.trim();
     if (!text) return;
 
+    if (chatMode === 'handoff') {
+      await submitHandoff(text);
+    } else {
+      await submitChat(text);
+    }
+  });
+
+  async function submitChat(text) {
+    const modelVal = $('chat-model').value;
+    if (!modelVal) { alert('Please select a model'); return; }
+
     chatInput.value = '';
     chatInput.style.height = 'auto';
 
     const [nodeId, ...modelParts] = modelVal.split('/');
     const model = modelParts.join('/');
 
-    // Add user message
     chatMessages.push({ role: 'user', content: text });
-    renderChatMessages();
-
-    // Add placeholder for assistant
     chatMessages.push({ role: 'assistant', content: '' });
     renderChatMessages();
 
@@ -1238,7 +1371,6 @@ const JS = `
         }
       }
 
-      // Clean up empty assistant message
       if (!chatMessages[chatMessages.length - 1].content) {
         chatMessages[chatMessages.length - 1] = { role: 'error', content: 'No response received' };
       }
@@ -1251,11 +1383,86 @@ const JS = `
       $('chat-send').disabled = false;
       chatInput.focus();
     }
-  });
+  }
+
+  async function submitHandoff(text) {
+    const agent = $('chat-agent').value;
+    if (!agent) { alert('Please select an agent'); return; }
+
+    chatInput.value = '';
+    chatInput.style.height = 'auto';
+
+    chatMessages.push({ role: 'user', content: text });
+    chatMessages.push({ role: 'assistant', content: '' });
+    renderChatMessages();
+
+    chatStreaming = true;
+    $('chat-send').disabled = true;
+
+    try {
+      const res = await fetch('/api/handoff', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ nodeId: handoffNodeId, agent, task: text }),
+      });
+
+      if (!res.ok) {
+        const err = await res.text();
+        chatMessages[chatMessages.length - 1] = { role: 'error', content: 'Error: ' + err };
+        renderChatMessages();
+        return;
+      }
+
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6).trim();
+
+          try {
+            const parsed = JSON.parse(data);
+            if (parsed.type === 'delta') {
+              chatMessages[chatMessages.length - 1].content += parsed.content;
+              renderChatMessages();
+            } else if (parsed.type === 'error') {
+              chatMessages[chatMessages.length - 1] = { role: 'error', content: 'Error: ' + parsed.error };
+              renderChatMessages();
+            }
+            // type === 'done' — stream already accumulated the content
+          } catch {}
+        }
+      }
+
+      if (!chatMessages[chatMessages.length - 1].content) {
+        chatMessages[chatMessages.length - 1] = { role: 'error', content: 'No response received' };
+      }
+      renderChatMessages();
+    } catch (err) {
+      chatMessages[chatMessages.length - 1] = { role: 'error', content: 'Error: ' + err.message };
+      renderChatMessages();
+    } finally {
+      chatStreaming = false;
+      $('chat-send').disabled = false;
+      chatInput.focus();
+    }
+  }
 
   function renderChatMessages() {
     if (chatMessages.length === 0) {
-      chatMsgs.innerHTML = '<div class="chat-empty">Select a model and start chatting with your cluster.</div>';
+      const hint = chatMode === 'handoff'
+        ? 'Select an agent and describe your task.'
+        : 'Select a model and start chatting with your cluster.';
+      chatMsgs.innerHTML = '<div class="chat-empty">' + hint + '</div>';
       return;
     }