open-agents-ai 0.103.67 → 0.103.69

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
@@ -13402,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) {
@@ -47315,6 +47499,16 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
         });
       }
     }
+    try {
+      const autoNexus = new NexusTool(repoRoot);
+      autoNexus.execute({ action: "connect" }).then((r) => {
+        if (r.success && r.output.includes("Connected")) {
+          writeContent(() => renderInfo("Nexus P2P network connected."));
+        }
+      }).catch(() => {
+      });
+    } catch {
+    }
     try {
       const oaDir = join50(repoRoot, ".oa");
       const reconnected = await ExposeGateway.checkAndReconnect(oaDir, {

package/package.json

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