open-agents-ai 0.186.14 → 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);
@@ -7328,32 +7441,29 @@ async function handleCmd(cmd) {
           writeResp(id, { ok: false, output: 'Required: to (NKN address) and message' });
           break;
         }
-        // Lazy NKN init
+        // Lazy NKN init \u2014 uses open-agents-nexus API (deriveNknSeed, NknFallback)
         if (!nexus.nkn || !nexus.nkn.isConnected) {
           try {
-            // Load or generate NKN seed from global identity
             var _nsSeedFile = join(nexusDir, 'nkn-seed.hex');
             var _nsSeed = undefined;
             if (existsSync(_nsSeedFile)) {
               _nsSeed = readFileSync(_nsSeedFile, 'utf8').trim();
             } else {
-              // Derive NKN seed from agent name + identity key (deterministic)
+              // Use open-agents-nexus deriveNknSeed() for deterministic address
               var _nsKeyData = existsSync(keyPath) ? readFileSync(keyPath) : Buffer.from(agentName);
-              _nsSeed = createHash('sha256').update(_nsKeyData).update('nkn-seed-v1').digest('hex');
+              _nsSeed = deriveNknSeed(_nsKeyData);
               writeFileSync(_nsSeedFile, _nsSeed, { mode: 0o600 });
             }
-            // Connect NKN via nexus client if available
             if (nexus.nkn && typeof nexus.nkn.connect === 'function') {
               await nexus.nkn.connect(_nsSeed);
             } else {
-              // Direct NKN init if nexus client doesn't expose nkn
+              // 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);
               });
-              // Store address
               var _nsIdFile = join(nexusDir, 'nkn-identity.json');
               writeFileSync(_nsIdFile, JSON.stringify({
                 address: _nknMC.addr,
@@ -7363,28 +7473,14 @@ async function handleCmd(cmd) {
                 createdAt: new Date().toISOString(),
               }, null, 2), { mode: 0o600 });
               dlog('NKN connected: ' + _nknMC.addr);
-              // Receive handler \u2014 store in inbox
+              // 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 = { sender: src, raw: _body, receivedAt: Date.now(), verified: false };
-                // Verify HMAC if present
-                try {
-                  var _parsed = JSON.parse(_body);
-                  if (_parsed._hmac && _parsed._agentName && _parsed.content) {
-                    // Verify: HMAC(agentName + content + timestamp, shared_secret)
-                    var _sharedSecret = createHash('sha256').update(src).update(_nknMC.addr).update('oa-nkn-v1').digest('hex');
-                    var _expectedHmac = createHmac('sha256', _sharedSecret).update(_parsed._agentName + _parsed.content + String(_parsed.timestamp || 0)).digest('hex').slice(0, 16);
-                    _entry.verified = (_parsed._hmac === _expectedHmac);
-                    _entry.agentName = _parsed._agentName;
-                    _entry.content = _parsed.content;
-                    _entry.timestamp = _parsed.timestamp;
-                  }
-                } catch { /* raw text message \u2014 not verified */ }
+                var _entry = parseNknEnvelope(src, _nknMC.addr, _body);
                 try { writeFileSync(join(_niDir2, Date.now() + '.json'), JSON.stringify(_entry, null, 2)); } catch {}
               });
-              // Stash the client for reuse
               nexus._nknDirect = _nknMC;
             }
           } catch (nknErr) {
@@ -7392,20 +7488,11 @@ async function handleCmd(cmd) {
             break;
           }
         }
-        // Build verified message with HMAC
+        // 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 _nsTimestamp = Date.now();
-        var _nsSharedSecret = createHash('sha256').update(_nsMyAddr).update(_nsTo).update('oa-nkn-v1').digest('hex');
-        var _nsHmac = createHmac('sha256', _nsSharedSecret).update(agentName + _nsMsg + String(_nsTimestamp)).digest('hex').slice(0, 16);
-        var _nsEnvelope = JSON.stringify({
-          _agentName: agentName,
-          content: _nsMsg,
-          timestamp: _nsTimestamp,
-          libp2pPeerId: nexus.peerId || null,
-          _hmac: _nsHmac,
-        });
+        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
@@ -8396,7 +8483,8 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               "nkn_peers",
               "nkn_inbox",
               "nkn_send",
-              "nkn_add_peer"
+              "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, 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."
           },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.186.14",
+  "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",