open-agents-ai 0.186.13 → 0.186.15

package/dist/index.js

@@ -5343,7 +5343,7 @@ var init_nexus = __esm({
  * Usage: node nexus-daemon.mjs <nexus-dir> <agent-name> [agent-type]
  */
 
-import { NexusClient } from 'open-agents-nexus';
+import { NexusClient, buildNknEnvelope, parseNknEnvelope, deriveNknSeed } from 'open-agents-nexus';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync, appendFileSync, watch as fsWatch } from 'node:fs';
 import { join } from 'node:path';
 import { homedir, hostname } from 'node:os';
@@ -5639,12 +5639,33 @@ async function handleCmd(cmd) {
           writeResp(id, { ok: false, output: 'NATS not connected \u2014 cannot announce sponsorship' });
           return;
         }
+        // NX-07: Fetch per-model metadata from Ollama for capacity announcements
+        var _saModels = args.models || [];
+        var _saModelDetails = [];
+        try {
+          var _saOllamaUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
+          var _saTagsResp = await fetch(_saOllamaUrl + '/api/tags');
+          var _saTags = await _saTagsResp.json();
+          for (var _saM of (_saTags.models || [])) {
+            var _saName = _saM.name || '';
+            if (_saModels.length > 0 && !_saModels.includes(_saName)) continue;
+            _saModelDetails.push({
+              name: _saName,
+              sizeGB: Math.round((_saM.size || 0) / (1024*1024*1024) * 10) / 10,
+              paramCount: _saM.details?.parameter_size || '',
+              quantization: _saM.details?.quantization_level || '',
+              family: _saM.details?.family || '',
+              contextLength: 0, // would need /api/show per model \u2014 too slow for announce
+            });
+          }
+        } catch {}
         var sponsorData = {
           type: 'sponsor.announce',
           peerId: globalThis._daemonPeerId || 'unknown',
           libp2pPeerId: globalThis._daemonPeerId || '',
           name: args.name || 'Anonymous Sponsor',
-          models: args.models || [],
+          models: _saModels.length > 0 ? _saModels : _saModelDetails.map(function(m) { return m.name; }),
+          modelDetails: _saModelDetails, // NX-07: per-model capacity
           tunnelUrl: args.tunnel_url || null,
           authKey: args.auth_key || '',
           limits: {
@@ -5690,9 +5711,101 @@ async function handleCmd(cmd) {
             await rooms.get('sponsors').send(JSON.stringify(sponsorData), { format: 'application/json' });
           } catch {}
         }
-        writeResp(id, { ok: true, output: 'Sponsor announced: ' + sponsorData.name + ' (' + sponsorData.models.length + ' models)' });
+        // NX-04: GossipSub meta topic announcement (multi-layer discovery)
+        try {
+          var _node = nexus.network ? nexus.network.node : nexus.node;
+          if (_node && _node.services && _node.services.pubsub) {
+            var _metaTopic = '/nexus/meta';
+            var _metaMsg = JSON.stringify({
+              version: 1,
+              type: 'capability',
+              id: Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+              timestamp: Date.now(),
+              sender: nexus.peerId || 'unknown',
+              topic: _metaTopic,
+              payload: {
+                capabilities: [{
+                  name: 'sponsor_inference',
+                  protocol: '/nexus/invoke/1.1.0',
+                  description: 'Sponsored inference via ' + sponsorData.name,
+                  pricing: 'free',
+                  rateLimit: String(sponsorData.limits.maxRequestsPerMinute) + '/min',
+                }],
+                sponsor: sponsorData,
+              },
+            });
+            try { await _node.services.pubsub.subscribe(_metaTopic); } catch {}
+            await _node.services.pubsub.publish(_metaTopic, new TextEncoder().encode(_metaMsg));
+            dlog('sponsor_announce: published to GossipSub /nexus/meta');
+          }
+        } catch (gsErr) {
+          dlog('sponsor_announce: GossipSub meta failed: ' + (gsErr.message || gsErr));
+        }
+        writeResp(id, { ok: true, output: 'Sponsor announced: ' + sponsorData.name + ' (' + sponsorData.models.length + ' models) [NATS+KV+Room+GossipSub]' });
+        break;
+      }
+      // NX-05 + NX-06: Register sponsor_inference capability for P2P inference relay.
+      // When a sponsor activates, this registers an invoke handler that proxies
+      // chat completions to local Ollama \u2014 no tunnel needed for P2P inference.
+      case 'register_sponsor_inference': {
+        var _rsiOllamaUrl = args.ollama_url || process.env.OLLAMA_HOST || 'http://localhost:11434';
+        var _rsiAllowedModels = args.models ? String(args.models).split(',') : null;
+        if (typeof nexus.registerCapability !== 'function') {
+          writeResp(id, { ok: false, output: 'registerCapability not available' });
+          break;
+        }
+        nexus.registerCapability('sponsor_inference', async (request, stream) => {
+          var _rsiInput = '';
+          stream.onData(function(msg) {
+            if (msg.type === 'invoke.chunk') {
+              _rsiInput += (typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data));
+            }
+          });
+          // Wait for input to finish (accept fires when sender signals done)
+          await stream.accept();
+          try {
+            var _rsiReq = JSON.parse(_rsiInput);
+            var _rsiModel = _rsiReq.model || '';
+            // Check model allowlist
+            if (_rsiAllowedModels && !_rsiAllowedModels.includes(_rsiModel)) {
+              stream.write({ type: 'invoke.error', error: 'Model not allowed: ' + _rsiModel });
+              return;
+            }
+            // Proxy to local Ollama /v1/chat/completions
+            var _rsiBody = JSON.stringify({
+              model: _rsiModel,
+              messages: _rsiReq.messages || [],
+              stream: true,
+            });
+            var _rsiResp = await fetch(_rsiOllamaUrl + '/v1/chat/completions', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: _rsiBody,
+            });
+            if (!_rsiResp.ok) {
+              stream.write({ type: 'invoke.error', error: 'Ollama returned HTTP ' + _rsiResp.status });
+              return;
+            }
+            // Stream response back via invoke protocol
+            var _rsiReader = _rsiResp.body?.getReader();
+            if (_rsiReader) {
+              var _rsiDecoder = new TextDecoder();
+              while (true) {
+                var _rsiChunk = await _rsiReader.read();
+                if (_rsiChunk.done) break;
+                stream.write({ type: 'invoke.event', data: _rsiDecoder.decode(_rsiChunk.value, { stream: true }) });
+              }
+            }
+            stream.write({ type: 'invoke.done' });
+            dlog('sponsor_inference: served ' + _rsiModel + ' to ' + (request.from || '?').slice(0, 16));
+          } catch (rsiErr) {
+            stream.write({ type: 'invoke.error', error: String(rsiErr.message || rsiErr) });
+          }
+        });
+        writeResp(id, { ok: true, output: 'Registered sponsor_inference capability (P2P relay active)' });
         break;
       }
+
       case 'sponsor_discover': {
         var foundSponsors = [];
         var discoverTimeout = parseInt(args.timeout_ms || '5000', 10);
@@ -7270,6 +7383,153 @@ async function handleCmd(cmd) {
         writeResp(id, { ok: true, output: 'pong' });
         break;
       }
+
+      // \u2500\u2500 NKN Backup Comms Layer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      // Persistent NKN addresses for fallback agent-to-agent communication.
+      // Each OA instance gets a deterministic NKN address derived from the
+      // mnemonic agent name. Messages are signed with HMAC to verify the
+      // AGENT sent them (not a human spoofing).
+
+      case 'nkn_status': {
+        var _nknIdFile = join(nexusDir, 'nkn-identity.json');
+        var _nknPeersFile = join(nexusDir, 'nkn-peers.json');
+        var _nknId = existsSync(_nknIdFile) ? JSON.parse(readFileSync(_nknIdFile, 'utf8')) : null;
+        var _nknPeers = existsSync(_nknPeersFile) ? JSON.parse(readFileSync(_nknPeersFile, 'utf8')) : { peers: [] };
+        var _nknConnected = nexus.nkn && nexus.nkn.isConnected;
+        writeResp(id, { ok: true, output: JSON.stringify({
+          enabled: !!nexus.nkn,
+          connected: _nknConnected,
+          address: _nknId ? _nknId.address : (nexus.nkn ? nexus.nkn.address : null),
+          publicKey: _nknId ? _nknId.publicKey : null,
+          peerCount: _nknPeers.peers ? _nknPeers.peers.length : 0,
+          libp2pPeerId: nexus.peerId || null,
+          agentName: agentName,
+        }) });
+        break;
+      }
+
+      case 'nkn_peers': {
+        // List all known NKN peer addresses (agents we've discovered)
+        var _npFile = join(nexusDir, 'nkn-peers.json');
+        var _npData = existsSync(_npFile) ? JSON.parse(readFileSync(_npFile, 'utf8')) : { peers: [] };
+        writeResp(id, { ok: true, output: JSON.stringify(_npData) });
+        break;
+      }
+
+      case 'nkn_inbox': {
+        // Read NKN inbox messages (most recent first, capped)
+        var _niDir = join(inboxDir, '_nkn');
+        var _niMessages = [];
+        try {
+          if (existsSync(_niDir)) {
+            var _niFiles = readdirSync(_niDir).filter(f => f.endsWith('.json')).sort().reverse().slice(0, 50);
+            for (var _niF of _niFiles) {
+              try { _niMessages.push(JSON.parse(readFileSync(join(_niDir, _niF), 'utf8'))); } catch {}
+            }
+          }
+        } catch {}
+        writeResp(id, { ok: true, output: JSON.stringify({ messages: _niMessages, count: _niMessages.length }) });
+        break;
+      }
+
+      case 'nkn_send': {
+        // Send a DM to another agent via NKN
+        // args: { to: "nkn-address", message: "text", verify: true }
+        var _nsTo = args.to || args.address;
+        var _nsMsg = args.message || args.content || '';
+        if (!_nsTo || !_nsMsg) {
+          writeResp(id, { ok: false, output: 'Required: to (NKN address) and message' });
+          break;
+        }
+        // Lazy NKN init \u2014 uses open-agents-nexus API (deriveNknSeed, NknFallback)
+        if (!nexus.nkn || !nexus.nkn.isConnected) {
+          try {
+            var _nsSeedFile = join(nexusDir, 'nkn-seed.hex');
+            var _nsSeed = undefined;
+            if (existsSync(_nsSeedFile)) {
+              _nsSeed = readFileSync(_nsSeedFile, 'utf8').trim();
+            } else {
+              // Use open-agents-nexus deriveNknSeed() for deterministic address
+              var _nsKeyData = existsSync(keyPath) ? readFileSync(keyPath) : Buffer.from(agentName);
+              _nsSeed = deriveNknSeed(_nsKeyData);
+              writeFileSync(_nsSeedFile, _nsSeed, { mode: 0o600 });
+            }
+            if (nexus.nkn && typeof nexus.nkn.connect === 'function') {
+              await nexus.nkn.connect(_nsSeed);
+            } else {
+              // Direct NKN init via nkn-sdk
+              var nknSdk = await import('nkn-sdk');
+              var _nknMC = new nknSdk.default.MultiClient({ seed: _nsSeed, identifier: 'oa-' + agentName.replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 20), numSubClients: 3 });
+              await new Promise(function(resolve, reject) {
+                _nknMC.onConnect(resolve);
+                setTimeout(function() { reject(new Error('NKN connect timeout (15s)')); }, 15000);
+              });
+              var _nsIdFile = join(nexusDir, 'nkn-identity.json');
+              writeFileSync(_nsIdFile, JSON.stringify({
+                address: _nknMC.addr,
+                publicKey: _nknMC.getPublicKey(),
+                agentName: agentName,
+                libp2pPeerId: nexus.peerId || null,
+                createdAt: new Date().toISOString(),
+              }, null, 2), { mode: 0o600 });
+              dlog('NKN connected: ' + _nknMC.addr);
+              // Receive handler \u2014 uses open-agents-nexus parseNknEnvelope() for HMAC verification
+              _nknMC.onMessage(function({ src, payload }) {
+                var _body = typeof payload === 'string' ? payload : new TextDecoder().decode(payload);
+                var _niDir2 = join(inboxDir, '_nkn');
+                mkdirSync(_niDir2, { recursive: true });
+                var _entry = parseNknEnvelope(src, _nknMC.addr, _body);
+                try { writeFileSync(join(_niDir2, Date.now() + '.json'), JSON.stringify(_entry, null, 2)); } catch {}
+              });
+              nexus._nknDirect = _nknMC;
+            }
+          } catch (nknErr) {
+            writeResp(id, { ok: false, output: 'NKN connect failed: ' + (nknErr.message || nknErr) });
+            break;
+          }
+        }
+        // Build verified message using open-agents-nexus buildNknEnvelope()
+        var _nsClient = nexus._nknDirect || (nexus.nkn && nexus.nkn.client);
+        if (!_nsClient) { writeResp(id, { ok: false, output: 'NKN not connected' }); break; }
+        var _nsMyAddr = _nsClient.addr || (nexus.nkn ? nexus.nkn.address : '');
+        var _nsEnvelope = buildNknEnvelope(_nsMyAddr, _nsTo, agentName, _nsMsg, nexus.peerId || undefined);
+        try {
+          await _nsClient.send(_nsTo, _nsEnvelope, { msgHoldingSeconds: 3600 });
+          // Add to peer list if not already there
+          var _nsPeersFile = join(nexusDir, 'nkn-peers.json');
+          var _nsPeers = existsSync(_nsPeersFile) ? JSON.parse(readFileSync(_nsPeersFile, 'utf8')) : { peers: [] };
+          if (!_nsPeers.peers.find(function(p) { return p.nknAddress === _nsTo; })) {
+            _nsPeers.peers.push({ nknAddress: _nsTo, lastContact: _nsTimestamp, agentName: args.to_agent || 'unknown' });
+            writeFileSync(_nsPeersFile, JSON.stringify(_nsPeers, null, 2));
+          }
+          writeResp(id, { ok: true, output: 'Sent to ' + _nsTo + ' (HMAC verified, held 1h if offline)' });
+        } catch (sendErr) {
+          writeResp(id, { ok: false, output: 'NKN send failed: ' + (sendErr.message || sendErr) });
+        }
+        break;
+      }
+
+      case 'nkn_add_peer': {
+        // Manually add a peer's NKN address to the address book
+        var _napAddr = args.nkn_address || args.address;
+        var _napName = args.agent_name || args.name || 'unknown';
+        var _napPeerId = args.libp2p_peer_id || args.peer_id || '';
+        if (!_napAddr) { writeResp(id, { ok: false, output: 'Required: nkn_address' }); break; }
+        var _napFile = join(nexusDir, 'nkn-peers.json');
+        var _napData = existsSync(_napFile) ? JSON.parse(readFileSync(_napFile, 'utf8')) : { peers: [] };
+        var _napExisting = _napData.peers.findIndex(function(p) { return p.nknAddress === _napAddr; });
+        if (_napExisting >= 0) {
+          _napData.peers[_napExisting].agentName = _napName;
+          _napData.peers[_napExisting].libp2pPeerId = _napPeerId || _napData.peers[_napExisting].libp2pPeerId;
+          _napData.peers[_napExisting].lastContact = Date.now();
+        } else {
+          _napData.peers.push({ nknAddress: _napAddr, agentName: _napName, libp2pPeerId: _napPeerId, addedAt: Date.now(), lastContact: Date.now() });
+        }
+        writeFileSync(_napFile, JSON.stringify(_napData, null, 2));
+        writeResp(id, { ok: true, output: 'Added peer: ' + _napName + ' (' + _napAddr.slice(0, 30) + '...)' });
+        break;
+      }
+
       default:
         writeResp(id, { ok: false, output: 'Unknown daemon command: ' + action });
     }
@@ -8218,9 +8478,15 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               "ipfs_add",
               "ipfs_pin",
               "ipfs_ls",
-              "cohere_publish_insight"
+              "cohere_publish_insight",
+              "nkn_status",
+              "nkn_peers",
+              "nkn_inbox",
+              "nkn_send",
+              "nkn_add_peer",
+              "register_sponsor_inference"
             ],
-            description: "The nexus action. MUST call 'connect' first (spawns daemon). Then: join_room, send_message, discover_peers, expose, status, cohere_stats, cohere_enable, cohere_disable, cohere_allow_model, cohere_deny_model, cohere_list_models, ipfs_add, etc."
+            description: "The nexus action. MUST call 'connect' first (spawns daemon). Then: join_room, send_message, discover_peers, expose, status, nkn_status (NKN backup comms), nkn_peers (address book), nkn_inbox (read messages), nkn_send (DM via NKN with HMAC verification), nkn_add_peer (add to address book), cohere_stats, ipfs_add, etc."
           },
           room_id: {
             type: "string",

package/package.json

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