open-agents-ai 0.103.66 → 0.103.68

package/dist/index.js

@@ -12126,6 +12126,11 @@ const rooms = new Map();
 let connected = false;
 const blockedPeers = [];
 
+// NATS invoke relay \u2014 for cross-NAT fallback when direct libp2p dial fails.
+// Both peers connect to wss://demo.nats.io:8443, so NATS request/reply bridges the gap.
+var _natsConn = null;
+var _natsCodec = null;
+
 function writeStatus(extra = {}) {
   const caps = typeof nexus.getRegisteredCapabilities === 'function'
     ? nexus.getRegisteredCapabilities() : [];
@@ -12285,8 +12290,37 @@ async function handleCmd(cmd) {
           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)) });
+          var qpcErrMsg = qpcErr.message || String(qpcErr);
+          dlog('query_peer_caps: ERROR ' + qpcErrMsg);
+          // NATS fallback for peer cap discovery across NAT
+          if (_natsConn && _natsCodec && qpcErrMsg.includes('multiaddrs failed')) {
+            dlog('query_peer_caps: trying NATS relay fallback');
+            try {
+              var _qpcNatsSubject = 'nexus.invoke.' + String(qpcPeerId);
+              var _qpcNatsPayload = JSON.stringify({
+                capability: '__list_capabilities',
+                input: qpcInput,
+                from: nexus.peerId || '',
+              });
+              var _qpcNatsResp = await _natsConn.request(
+                _qpcNatsSubject,
+                _natsCodec.encode(_qpcNatsPayload),
+                { timeout: 15000 }
+              );
+              var _qpcNatsResult = JSON.parse(_natsCodec.decode(_qpcNatsResp.data));
+              if (_qpcNatsResult && _qpcNatsResult.error) {
+                writeResp(id, { ok: false, output: 'query_peer_caps (NATS): ' + _qpcNatsResult.error });
+              } else {
+                dlog('query_peer_caps: SUCCESS via NATS relay');
+                writeResp(id, { ok: true, output: typeof _qpcNatsResult === 'string' ? _qpcNatsResult : JSON.stringify(_qpcNatsResult, null, 2) });
+              }
+            } catch (_qpcNatsErr) {
+              dlog('query_peer_caps: NATS fallback also failed: ' + (_qpcNatsErr.message || _qpcNatsErr));
+              writeResp(id, { ok: false, output: 'query_peer_caps error (libp2p + NATS): ' + qpcErrMsg });
+            }
+          } else {
+            writeResp(id, { ok: false, output: 'query_peer_caps error: ' + qpcErrMsg });
+          }
         }
         break;
       }
@@ -12305,8 +12339,37 @@ async function handleCmd(cmd) {
           dlog('invoke_capability: SUCCESS');
           writeResp(id, { ok: true, output: JSON.stringify(result, null, 2) });
         } catch (invokeErr) {
-          dlog('invoke_capability: ERROR ' + (invokeErr.message || String(invokeErr)));
-          writeResp(id, { ok: false, output: 'Invoke error: ' + (invokeErr.message || String(invokeErr)) });
+          var invokeErrMsg = invokeErr.message || String(invokeErr);
+          dlog('invoke_capability: ERROR ' + invokeErrMsg);
+          // NATS fallback \u2014 if direct dial failed (NAT), retry via NATS relay
+          if (_natsConn && _natsCodec && invokeErrMsg.includes('multiaddrs failed')) {
+            dlog('invoke_capability: trying NATS relay fallback for ' + peerId.slice(0, 20));
+            try {
+              var _icNatsSubject = 'nexus.invoke.' + peerId;
+              var _icNatsPayload = JSON.stringify({
+                capability: capability,
+                input: typeof input === 'string' ? { prompt: input } : input,
+                from: nexus.peerId || '',
+              });
+              var _icNatsResp = await _natsConn.request(
+                _icNatsSubject,
+                _natsCodec.encode(_icNatsPayload),
+                { timeout: 240000 }
+              );
+              var _icNatsResult = JSON.parse(_natsCodec.decode(_icNatsResp.data));
+              if (_icNatsResult && _icNatsResult.error) {
+                writeResp(id, { ok: false, output: 'NATS relay error: ' + _icNatsResult.error });
+              } else {
+                dlog('invoke_capability: SUCCESS via NATS relay');
+                writeResp(id, { ok: true, output: typeof _icNatsResult === 'string' ? _icNatsResult : JSON.stringify(_icNatsResult, null, 2) });
+              }
+            } catch (_icNatsErr) {
+              dlog('invoke_capability: NATS fallback also failed: ' + (_icNatsErr.message || _icNatsErr));
+              writeResp(id, { ok: false, output: 'Invoke error (libp2p + NATS fallback failed): ' + invokeErrMsg });
+            }
+          } else {
+            writeResp(id, { ok: false, output: 'Invoke error: ' + invokeErrMsg });
+          }
         }
         break;
       }
@@ -12355,9 +12418,39 @@ async function handleCmd(cmd) {
             var riResult = await Promise.race([riInvokeP, riTimeoutP]);
             dlog('remote_infer: SUCCESS (explicit peer)');
           } catch (riErr) {
-            dlog('remote_infer: ERROR (explicit peer) ' + (riErr.message || String(riErr)));
-            writeResp(id, { ok: false, output: 'Remote inference failed: ' + (riErr.message || String(riErr)) });
-            return;
+            var riErrMsg = riErr.message || String(riErr);
+            dlog('remote_infer: ERROR (explicit peer) ' + riErrMsg);
+            // NATS fallback \u2014 if direct dial failed (NAT/firewall), retry via NATS relay
+            if (_natsConn && _natsCodec && riErrMsg.includes('multiaddrs failed')) {
+              dlog('remote_infer: trying NATS relay fallback for ' + riTargetPeer.slice(0, 20));
+              try {
+                var _riNatsSubject = 'nexus.invoke.' + riTargetPeer;
+                var _riNatsPayload = JSON.stringify({
+                  capability: riCapName,
+                  input: riData,
+                  from: nexus.peerId || '',
+                });
+                var _riNatsResp = await _natsConn.request(
+                  _riNatsSubject,
+                  _natsCodec.encode(_riNatsPayload),
+                  { timeout: 240000 }
+                );
+                var _riNatsResult = JSON.parse(_natsCodec.decode(_riNatsResp.data));
+                if (_riNatsResult && _riNatsResult.error) {
+                  writeResp(id, { ok: false, output: 'Remote inference failed (NATS relay): ' + _riNatsResult.error });
+                  return;
+                }
+                riResult = _riNatsResult;
+                dlog('remote_infer: SUCCESS via NATS relay');
+              } catch (_riNatsErr) {
+                dlog('remote_infer: NATS fallback also failed: ' + (_riNatsErr.message || _riNatsErr));
+                writeResp(id, { ok: false, output: 'Remote inference failed (libp2p + NATS): ' + riErrMsg });
+                return;
+              }
+            } else {
+              writeResp(id, { ok: false, output: 'Remote inference failed: ' + riErrMsg });
+              return;
+            }
           }
         } else {
           // Auto-discover: try speculative invoke on each 12D3KooW peer
@@ -12402,14 +12495,28 @@ async function handleCmd(cmd) {
         }
 
         // riResult and riTargetPeer are available from either path above
-        // Check if the invoke returned an error message instead of real data
+        // Check if the invoke returned an error message instead of real data.
+        // IMPORTANT: Only flag short non-JSON strings as errors. Valid inference
+        // responses are JSON with model/response/choices \u2014 the model's natural
+        // language output often contains words like "error" or "not found" which
+        // would cause false positives if we checked the entire JSON string.
         var riIsError = false;
         if (typeof riResult === 'string') {
-          var riLower = riResult.toLowerCase();
-          if (riLower.includes('unauthorized') || riLower.includes('forbidden') ||
-              riLower.includes('not found') || riLower.includes('error') ||
-              riLower.includes('payment') || riLower.includes('rejected')) {
-            riIsError = true;
+          // Try to parse as JSON \u2014 if it has model+response or choices, it's valid
+          var riParsedCheck = null;
+          try { riParsedCheck = JSON.parse(riResult); } catch {}
+          if (riParsedCheck && typeof riParsedCheck === 'object' &&
+              (riParsedCheck.model || riParsedCheck.choices || riParsedCheck.response !== undefined)) {
+            // Valid inference response \u2014 NOT an error
+            riIsError = false;
+          } else {
+            // Non-JSON or unstructured response \u2014 check for error keywords
+            var riLower = riResult.toLowerCase();
+            if (riLower.includes('unauthorized') || riLower.includes('forbidden') ||
+                riLower.includes('not found') || riLower.includes('error') ||
+                riLower.includes('payment') || riLower.includes('rejected')) {
+              riIsError = true;
+            }
           }
         }
         if (riIsError) {
@@ -12993,22 +13100,51 @@ async function handleCmd(cmd) {
         // Register system_metrics capability \u2014 returns CPU/GPU/memory utilization
         if (typeof nexus.registerCapability === 'function') {
           nexus.registerCapability('system_metrics', async (request, stream) => {
-            // Auth check for system_metrics too
+            // Collect input via stream data events (auth_key arrives in invoke.chunk, NOT invoke.open)
+            var smDataChunks = [];
+            var smInputDone = false;
+            stream.onData(function(msg) {
+              if (msg.type === 'invoke.chunk') {
+                smDataChunks.push(typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data));
+              }
+              if (msg.type === 'invoke.done' || msg.type === 'invoke.end') {
+                smInputDone = true;
+              }
+            });
+
+            // Accept invocation so consumer sends data
+            await stream.write({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: true });
+
+            // Wait briefly for data (auth key arrives in chunk)
+            var smWait = 0;
+            while (!smInputDone && smDataChunks.length === 0 && smWait < 2000) {
+              await new Promise(function(r) { setTimeout(r, 10); });
+              smWait += 10;
+            }
+
+            // Auth check \u2014 extract auth_key from chunk data
             if (exposeAuthKey) {
               var smAuthKey = '';
-              if (request.data && typeof request.data === 'object' && request.data.auth_key) {
-                smAuthKey = request.data.auth_key;
-              } else if (request.metadata && request.metadata.auth_key) {
+              var smPayload = smDataChunks.join('');
+              try {
+                var smParsed = JSON.parse(smPayload);
+                if (smParsed && typeof smParsed === 'object' && smParsed.auth_key) {
+                  smAuthKey = smParsed.auth_key;
+                }
+              } catch {}
+              // Fallback: check invoke.open metadata (future-proofing)
+              if (!smAuthKey && request.metadata && request.metadata.auth_key) {
                 smAuthKey = request.metadata.auth_key;
               }
               if (smAuthKey !== exposeAuthKey) {
-                await stream.write({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: false });
+                dlog('system_metrics: auth REJECTED from ' + (request.from || 'unknown'));
+                await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'Unauthorized' });
                 await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
                 stream.close();
                 return;
               }
+              dlog('system_metrics: auth OK');
             }
-            await stream.write({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: true });
             try {
               var os = require('os');
               var loads = os.loadavg();
@@ -13359,6 +13495,97 @@ process.on('unhandledRejection', (reason) => {
       dlog('NATS subscribe failed: ' + (natsSubErr.message || natsSubErr));
     }
 
+    // NATS invoke relay \u2014 subscribe to nexus.invoke.<myPeerId> for cross-NAT invoke fallback.
+    // When a remote peer can't direct-dial us (all multiaddrs are private), they retry
+    // via NATS request/reply. We dispatch to the registered capability handler using a
+    // mock stream interface, then reply with the result.
+    try {
+      var _nc = nexus.nats && nexus.nats.nc ? nexus.nats.nc : null;
+      if (_nc) {
+        var _nws = await import('nats.ws');
+        _natsConn = _nc;
+        _natsCodec = _nws.StringCodec();
+        var _natsInvSubject = 'nexus.invoke.' + nexus.peerId;
+        var _natsInvSub = _nc.subscribe(_natsInvSubject);
+        dlog('NATS invoke relay listening on ' + _natsInvSubject);
+
+        (async function _natsInvokeLoop() {
+          for await (var _nm of _natsInvSub) {
+            try {
+              var _nReq = JSON.parse(_natsCodec.decode(_nm.data));
+              var _nCap = _nReq.capability || '';
+              var _nInput = _nReq.input || {};
+              var _nInputStr = typeof _nInput === 'string' ? _nInput : JSON.stringify(_nInput);
+              dlog('NATS relay invoke: cap=' + _nCap + ' from=' + (_nReq.from || 'unknown').slice(0, 20));
+
+              // Look up registered handler
+              var _nHandler = null;
+              if (nexus.capabilityHandlers && typeof nexus.capabilityHandlers.get === 'function') {
+                _nHandler = nexus.capabilityHandlers.get(_nCap);
+              }
+              if (!_nHandler) {
+                var _nCaps = typeof nexus.getRegisteredCapabilities === 'function'
+                  ? nexus.getRegisteredCapabilities() : [];
+                _nm.respond(_natsCodec.encode(JSON.stringify({
+                  error: 'Capability not found: ' + _nCap + '. Available: ' + _nCaps.join(', ')
+                })));
+                continue;
+              }
+
+              // Create mock stream handle that captures the handler's output
+              var _nResults = [];
+              var _nHandleDone = false;
+              var _nHandle = {
+                write: async function(msg) {
+                  if (msg && msg.type === 'invoke.event') _nResults.push(msg);
+                  if (msg && msg.type === 'invoke.done') _nHandleDone = true;
+                },
+                onData: function(cb) {
+                  // Deliver input data asynchronously after handler registers its listener
+                  setTimeout(function() {
+                    try {
+                      cb({ type: 'invoke.chunk', data: _nInputStr, seq: 0 });
+                      cb({ type: 'invoke.done' });
+                    } catch {}
+                  }, 5);
+                },
+                close: function() {},
+              };
+
+              var _nRequest = {
+                type: 'invoke.open',
+                requestId: 'nats-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8),
+                capability: _nCap,
+                from: _nReq.from || 'nats-peer',
+              };
+
+              await _nHandler(_nRequest, _nHandle);
+
+              // Extract result from captured invoke.event messages
+              var _nResult = null;
+              if (_nResults.length === 1) {
+                _nResult = _nResults[0].data;
+              } else if (_nResults.length > 1) {
+                _nResult = _nResults.map(function(r) { return r.data; });
+              }
+
+              _nm.respond(_natsCodec.encode(JSON.stringify(_nResult !== null && _nResult !== undefined ? _nResult : { ok: true })));
+              dlog('NATS relay invoke SUCCESS: ' + _nCap);
+            } catch (_nErr) {
+              dlog('NATS relay invoke error: ' + (_nErr.message || _nErr));
+              try {
+                _nm.respond(_natsCodec.encode(JSON.stringify({ error: String(_nErr.message || _nErr) })));
+              } catch {}
+            }
+          }
+        })().catch(function(e) { dlog('NATS invoke relay loop error: ' + (e.message || e)); });
+      } else {
+        dlog('NATS not connected \u2014 invoke relay disabled (cross-NAT invoke will not work)');
+      }
+    } catch (_nSetupErr) {
+      dlog('NATS invoke relay setup failed: ' + (_nSetupErr.message || _nSetupErr));
+    }
+
     writeStatus();
     console.log('Nexus daemon connected as ' + nexus.peerId);
   } catch (err) {

package/package.json

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