open-agents-ai 0.103.28 → 0.103.29

package/dist/index.js

@@ -12206,7 +12206,43 @@ async function handleCmd(cmd) {
         const node = nexus.network?.node;
         const peers = node?.getPeers?.() || [];
         const list = peers.slice(0, 20).map(p => p.toString?.() || String(p));
-        writeResp(id, { ok: true, output: 'Peers: ' + list.length + '\\n' + list.map(p => '  ' + p.slice(0, 20) + '...').join('\\n') });
+        // Include NATS-discovered peers with capabilities
+        var dpNatsFile = join(nexusDir, 'discovered-peers.json');
+        var dpNats = {};
+        try { if (existsSync(dpNatsFile)) dpNats = JSON.parse(readFileSync(dpNatsFile, 'utf8')); } catch {}
+        var dpNatsCount = Object.keys(dpNats).length;
+        var dpLines = ['Connected peers: ' + list.length];
+        for (var dpi = 0; dpi < list.length; dpi++) {
+          dpLines.push('  ' + list[dpi]);
+        }
+        if (dpNatsCount > 0) {
+          dpLines.push('NATS-discovered peers: ' + dpNatsCount);
+          for (var dpKey of Object.keys(dpNats)) {
+            var dpEntry = dpNats[dpKey];
+            var dpAge = Math.round((Date.now() - dpEntry.lastSeen) / 1000);
+            dpLines.push('  ' + dpKey.slice(0, 20) + '... (' + dpEntry.agentName + ') caps=' + (dpEntry.capabilities || []).length + ' seen=' + dpAge + 's ago');
+          }
+        }
+        writeResp(id, { ok: true, output: dpLines.join('\\n') });
+        break;
+      }
+      case 'discover_peer_caps': {
+        var dpcPeerId = args.peer_id;
+        if (!dpcPeerId) { writeResp(id, { ok: false, output: 'peer_id is required' }); return; }
+        var dpcFile = join(nexusDir, 'discovered-peers.json');
+        var dpcPeers = {};
+        try { if (existsSync(dpcFile)) dpcPeers = JSON.parse(readFileSync(dpcFile, 'utf8')); } catch {}
+        var dpcEntry = dpcPeers[String(dpcPeerId)];
+        if (dpcEntry && dpcEntry.capabilities && dpcEntry.capabilities.length > 0) {
+          var dpcAge = Date.now() - dpcEntry.lastSeen;
+          if (dpcAge < 5 * 60 * 1000) { // 5 minute freshness
+            writeResp(id, { ok: true, output: JSON.stringify(dpcEntry, null, 2) });
+          } else {
+            writeResp(id, { ok: false, output: 'Peer data stale (' + Math.round(dpcAge / 1000) + 's old). Wait for NATS re-announce.' });
+          }
+        } else {
+          writeResp(id, { ok: false, output: 'Peer not found in NATS discovery cache. Peer may not have announced yet (announcements every 30s).' });
+        }
         break;
       }
       case 'list_rooms': {
@@ -12224,8 +12260,34 @@ async function handleCmd(cmd) {
       case 'find_agent': {
         const peerId = args.peer_id;
         if (!peerId) { writeResp(id, { ok: false, output: 'peer_id is required' }); return; }
-        const profile = await nexus.findAgent(peerId);
-        writeResp(id, { ok: true, output: profile ? JSON.stringify(profile, null, 2) : 'Agent not found: ' + peerId });
+        try {
+          var FIND_TIMEOUT = 15000;
+          var findPromise = nexus.findAgent(peerId);
+          var findTimeoutPromise = new Promise(function(resolve) { setTimeout(function() { resolve(null); }, FIND_TIMEOUT); });
+          var profile = await Promise.race([findPromise, findTimeoutPromise]);
+          writeResp(id, { ok: true, output: profile ? JSON.stringify(profile, null, 2) : 'Agent not found: ' + peerId });
+        } catch (findErr) {
+          writeResp(id, { ok: false, output: 'find_agent error: ' + (findErr.message || String(findErr)) });
+        }
+        break;
+      }
+      case 'query_peer_caps': {
+        var qpcPeerId = args.peer_id;
+        if (!qpcPeerId) { writeResp(id, { ok: false, output: 'peer_id is required' }); return; }
+        dlog('query_peer_caps: peer=' + String(qpcPeerId).slice(0, 20));
+        try {
+          var QPC_TIMEOUT = 15000;
+          var qpcInput = {};
+          if (args.auth_key) qpcInput.auth_key = args.auth_key;
+          var qpcPromise = nexus.invokeCapability(String(qpcPeerId), '__list_capabilities', qpcInput, { stream: false, maxDurationMs: 10000 });
+          var qpcTimeoutPromise = new Promise(function(_, reject) { setTimeout(function() { reject(new Error('query_peer_caps timed out after 15s')); }, QPC_TIMEOUT); });
+          var qpcResult = await Promise.race([qpcPromise, qpcTimeoutPromise]);
+          dlog('query_peer_caps: SUCCESS');
+          writeResp(id, { ok: true, output: typeof qpcResult === 'string' ? qpcResult : JSON.stringify(qpcResult, null, 2) });
+        } catch (qpcErr) {
+          dlog('query_peer_caps: ERROR ' + (qpcErr.message || String(qpcErr)));
+          writeResp(id, { ok: false, output: 'query_peer_caps error: ' + (qpcErr.message || String(qpcErr)) });
+        }
         break;
       }
       case 'invoke_capability': {
@@ -12849,6 +12911,30 @@ async function handleCmd(cmd) {
           dlog('system_metrics capability registered');
         }
 
+        // Register __list_capabilities \u2014 allows remote peers to discover available models
+        if (typeof nexus.registerCapability === 'function') {
+          nexus.registerCapability('__list_capabilities', async (request, stream) => {
+            dlog('__list_capabilities invoked from ' + (request.from || 'unknown'));
+            await stream.write({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: true });
+            var allCaps = typeof nexus.getRegisteredCapabilities === 'function' ? nexus.getRegisteredCapabilities() : [];
+            var modelsInfo = [];
+            for (var ci = 0; ci < pricingMenu.length; ci++) {
+              var pm = pricingMenu[ci];
+              modelsInfo.push({
+                name: pm.model,
+                parameterSize: pm.parameterSize || '',
+                family: pm.family || '',
+                quantization: pm.quantization || '',
+              });
+            }
+            var capsPayload = JSON.stringify({ capabilities: allCaps, models: modelsInfo, agentName: agentName, peerId: nexus.peerId });
+            await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'result', data: capsPayload });
+            await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: capsPayload.length } });
+            stream.close();
+          });
+          dlog('__list_capabilities capability registered');
+        }
+
         // Write pricing menu to file
         const pricingFile = join(nexusDir, 'pricing.json');
         writeFileSync(pricingFile, JSON.stringify({ updated: new Date().toISOString(), models: pricingMenu }, null, 2));
@@ -13014,6 +13100,35 @@ process.on('unhandledRejection', (reason) => {
       }
     } catch {}
 
+    // Subscribe to NATS peer announcements \u2014 cache remote peer capabilities
+    var discoveredPeers = {};
+    var discoveredPeersFile = join(nexusDir, 'discovered-peers.json');
+    try {
+      if (existsSync(discoveredPeersFile)) {
+        discoveredPeers = JSON.parse(readFileSync(discoveredPeersFile, 'utf8'));
+      }
+    } catch {}
+    try {
+      if (nexus.nats && typeof nexus.nats.subscribe === 'function') {
+        nexus.nats.subscribe(function(announcement) {
+          if (!announcement || !announcement.peerId) return;
+          if (announcement.peerId === nexus.peerId) return; // skip self
+          discoveredPeers[announcement.peerId] = {
+            peerId: announcement.peerId,
+            agentName: announcement.agentName || '',
+            capabilities: announcement.capabilities || [],
+            multiaddrs: announcement.multiaddrs || [],
+            lastSeen: Date.now(),
+          };
+          try { writeFileSync(discoveredPeersFile, JSON.stringify(discoveredPeers, null, 2)); } catch {}
+          dlog('NATS peer discovered: ' + String(announcement.peerId).slice(0, 20) + ' caps=' + (announcement.capabilities || []).length);
+        });
+        dlog('NATS peer discovery subscription active');
+      }
+    } catch (natsSubErr) {
+      dlog('NATS subscribe failed: ' + (natsSubErr.message || natsSubErr));
+    }
+
     writeStatus();
     console.log('Nexus daemon connected as ' + nexus.peerId);
   } catch (err) {
@@ -13215,6 +13330,9 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             case "discover_peers":
               result = await this.sendDaemonCmd("discover_peers", args);
               break;
+            case "discover_peer_caps":
+              result = await this.sendDaemonCmd("discover_peer_caps", args, 5e3);
+              break;
             case "list_rooms":
               result = await this.sendDaemonCmd("list_rooms", args);
               break;
@@ -13224,6 +13342,9 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             case "find_agent":
               result = await this.sendDaemonCmd("find_agent", args, 3e4);
               break;
+            case "query_peer_caps":
+              result = await this.sendDaemonCmd("query_peer_caps", args, 2e4);
+              break;
             case "invoke_capability":
               result = await this.sendDaemonCmd("invoke_capability", args, 1e5);
               break;
@@ -29845,26 +29966,102 @@ async function fetchPeerModels(peerId) {
       } catch {
       }
     }
-    const result = await nexusTool.execute({
-      action: "find_agent",
-      peer_id: peerId
-    });
-    if (result.success && result.output) {
-      const models = [];
-      const capMatches = result.output.matchAll(/inference:([^\s,\]]+)/g);
-      for (const m of capMatches) {
-        const capName = m[1];
-        const modelName = capName.replace(/_(\d+[bBmMkK])$/, ":$1").replace(/_latest$/, ":latest");
-        models.push({
-          name: modelName,
-          size: "",
-          modified: "",
-          sizeBytes: 0,
-          parameterSize: "remote"
-        });
+    try {
+      const capsResult = await nexusTool.execute({
+        action: "query_peer_caps",
+        peer_id: peerId
+      });
+      if (capsResult.success && capsResult.output) {
+        let capsData = null;
+        try {
+          capsData = JSON.parse(capsResult.output);
+        } catch {
+        }
+        if (capsData?.models && capsData.models.length > 0) {
+          return capsData.models.map((m) => ({
+            name: m.name || "unknown",
+            size: m.parameterSize || "",
+            modified: "",
+            sizeBytes: 0,
+            parameterSize: m.parameterSize || "remote"
+          }));
+        }
+        if (capsData?.capabilities && capsData.capabilities.length > 0) {
+          const models = [];
+          for (const cap of capsData.capabilities) {
+            if (typeof cap === "string" && cap.startsWith("inference:")) {
+              const capName = cap.slice(10);
+              const modelName = capName.replace(/_(\d+[bBmMkK])$/, ":$1").replace(/_latest$/, ":latest");
+              models.push({
+                name: modelName,
+                size: "",
+                modified: "",
+                sizeBytes: 0,
+                parameterSize: "remote"
+              });
+            }
+          }
+          if (models.length > 0)
+            return models;
+        }
       }
-      if (models.length > 0)
-        return models;
+    } catch {
+    }
+    try {
+      const natsResult = await nexusTool.execute({
+        action: "discover_peer_caps",
+        peer_id: peerId
+      });
+      if (natsResult.success && natsResult.output) {
+        let natsPeer = null;
+        try {
+          natsPeer = JSON.parse(natsResult.output);
+        } catch {
+        }
+        if (natsPeer?.capabilities && natsPeer.capabilities.length > 0) {
+          const models = [];
+          for (const cap of natsPeer.capabilities) {
+            if (typeof cap === "string" && cap.startsWith("inference:")) {
+              const capName = cap.slice(10);
+              const modelName = capName.replace(/_(\d+[bBmMkK])$/, ":$1").replace(/_latest$/, ":latest");
+              models.push({
+                name: modelName,
+                size: "",
+                modified: "",
+                sizeBytes: 0,
+                parameterSize: "remote"
+              });
+            }
+          }
+          if (models.length > 0)
+            return models;
+        }
+      }
+    } catch {
+    }
+    try {
+      const result = await nexusTool.execute({
+        action: "find_agent",
+        peer_id: peerId
+      });
+      if (result.success && result.output) {
+        const models = [];
+        const capMatches = result.output.matchAll(/inference:([^\s,\]]+)/g);
+        for (const m of capMatches) {
+          const capName = m[1];
+          const modelName = capName.replace(/_(\d+[bBmMkK])$/, ":$1").replace(/_latest$/, ":latest");
+          models.push({
+            name: modelName,
+            size: "",
+            modified: "",
+            sizeBytes: 0,
+            parameterSize: "remote"
+          });
+        }
+        if (models.length > 0)
+          return models;
+      }
+    } catch {
     }
     if (isLocalPeer) {
       const pricingPath = join55(nexusDir, "pricing.json");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.28",
+  "version": "0.103.29",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",