open-agents-ai 0.103.70 → 0.103.72

package/dist/index.js

@@ -12304,43 +12304,34 @@ async function handleCmd(cmd) {
           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]);
+
+          // Race libp2p + NATS in parallel \u2014 fastest route wins
+          var qpcLibp2p = nexus.invokeCapability(String(qpcPeerId), '__list_capabilities', qpcInput, { stream: false, maxDurationMs: 10000 });
+          var qpcTimeout = new Promise(function(_, reject) { setTimeout(function() { reject(new Error('query_peer_caps timed out')); }, QPC_TIMEOUT); });
+          var qpcRace = [qpcLibp2p, qpcTimeout];
+
+          if (_natsConn && _natsCodec) {
+            var _qpcNatsP = (async function() {
+              var _s = 'nexus.invoke.' + String(qpcPeerId);
+              var _p = JSON.stringify({ capability: '__list_capabilities', input: qpcInput, from: nexus.peerId || '' });
+              var _r = await _natsConn.request(_s, _natsCodec.encode(_p), { timeout: 15000 });
+              var _res = JSON.parse(_natsCodec.decode(_r.data));
+              if (_res && _res.error) throw new Error('NATS: ' + _res.error);
+              dlog('query_peer_caps: NATS won the race');
+              return _res;
+            })();
+            qpcRace.push(_qpcNatsP);
+          }
+
+          var qpcResult = await Promise.any(qpcRace.map(function(p) {
+            return p.catch(function(e) { return Promise.reject(e); });
+          }));
           dlog('query_peer_caps: SUCCESS');
           writeResp(id, { ok: true, output: typeof qpcResult === 'string' ? qpcResult : JSON.stringify(qpcResult, null, 2) });
         } catch (qpcErr) {
-          var qpcErrMsg = qpcErr.message || String(qpcErr);
-          dlog('query_peer_caps: ERROR ' + qpcErrMsg);
-          // NATS fallback for peer cap discovery across NAT
-          if (_natsConn && _natsCodec && isDialFailure(qpcErrMsg)) {
-            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 });
-          }
+          var qpcErrMsg = qpcErr.errors ? qpcErr.errors.map(function(e) { return e.message || String(e); }).join('; ') : (qpcErr.message || String(qpcErr));
+          dlog('query_peer_caps: ALL paths failed: ' + qpcErrMsg);
+          writeResp(id, { ok: false, output: 'query_peer_caps error: ' + qpcErrMsg });
         }
         break;
       }
@@ -12351,45 +12342,36 @@ async function handleCmd(cmd) {
         if (!peerId) { writeResp(id, { ok: false, output: 'target_peer is required' }); return; }
         dlog('invoke_capability: peer=' + peerId.slice(0, 20) + ' cap=' + capability);
         try {
-          // Wrap in a 300s timeout \u2014 remote API inference (Chutes, etc.) can take 60-180s for large models
+          // Race libp2p + NATS in parallel \u2014 whichever route works first wins
           const INVOKE_TIMEOUT = 300_000;
-          const invokePromise = nexus.invokeCapability(peerId, capability, typeof input === 'string' ? { prompt: input } : input, { stream: false, maxDurationMs: 240000 });
-          const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('invoke_capability timed out after ' + (INVOKE_TIMEOUT / 1000) + 's (client-side timeout)')), INVOKE_TIMEOUT));
-          const result = await Promise.race([invokePromise, timeoutPromise]);
+          const invokeInput = typeof input === 'string' ? { prompt: input } : input;
+          const invokePromise = nexus.invokeCapability(peerId, capability, invokeInput, { stream: false, maxDurationMs: 240000 });
+          const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('invoke_capability timed out after ' + (INVOKE_TIMEOUT / 1000) + 's')), INVOKE_TIMEOUT));
+
+          var icRaceCandidates = [invokePromise, timeoutPromise];
+
+          if (_natsConn && _natsCodec) {
+            var _icNatsRaceP = (async function() {
+              var _s = 'nexus.invoke.' + peerId;
+              var _p = JSON.stringify({ capability: capability, input: invokeInput, from: nexus.peerId || '' });
+              var _r = await _natsConn.request(_s, _natsCodec.encode(_p), { timeout: 240000 });
+              var _res = JSON.parse(_natsCodec.decode(_r.data));
+              if (_res && _res.error) throw new Error('NATS: ' + _res.error);
+              dlog('invoke_capability: NATS won the race');
+              return _res;
+            })();
+            icRaceCandidates.push(_icNatsRaceP);
+          }
+
+          const result = await Promise.any(icRaceCandidates.map(function(p) {
+            return p.catch(function(e) { return Promise.reject(e); });
+          }));
           dlog('invoke_capability: SUCCESS');
-          writeResp(id, { ok: true, output: JSON.stringify(result, null, 2) });
+          writeResp(id, { ok: true, output: typeof result === 'string' ? result : JSON.stringify(result, null, 2) });
         } catch (invokeErr) {
-          var invokeErrMsg = invokeErr.message || String(invokeErr);
-          dlog('invoke_capability: ERROR ' + invokeErrMsg);
-          // NATS fallback \u2014 if direct dial failed (NAT/timeout/refused), retry via NATS relay
-          if (_natsConn && _natsCodec && isDialFailure(invokeErrMsg)) {
-            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 });
-          }
+          var invokeErrMsg = invokeErr.errors ? invokeErr.errors.map(function(e) { return e.message || String(e); }).join('; ') : (invokeErr.message || String(invokeErr));
+          dlog('invoke_capability: ALL paths failed: ' + invokeErrMsg);
+          writeResp(id, { ok: false, output: 'Invoke error: ' + invokeErrMsg });
         }
         break;
       }
@@ -12429,48 +12411,42 @@ async function handleCmd(cmd) {
 
         // If target_peer specified, invoke directly. Otherwise auto-discover.
         if (riTargetPeer) {
-          // Direct invoke on specified peer
-          dlog('remote_infer: invoking ' + riCapName + ' on explicit peer ' + riTargetPeer.slice(0, 20));
+          // Race libp2p direct dial and NATS relay IN PARALLEL.
+          // For cross-NAT peers, libp2p dial can take 10-60s to fail while NATS
+          // succeeds in <1s. Racing them eliminates the wait.
+          dlog('remote_infer: invoking ' + riCapName + ' on peer ' + riTargetPeer.slice(0, 20) + ' (libp2p' + (_natsConn ? ' + NATS parallel' : '') + ')');
           try {
-            var RI_TIMEOUT = 300000; // 5 min \u2014 remote APIs (Chutes, etc.) can be slow for large models
+            var RI_TIMEOUT = 300000;
             var riInvokeP = nexus.invokeCapability(riTargetPeer, riCapName, riData, { stream: false, maxDurationMs: 240000 });
             var riTimeoutP = new Promise(function(_, reject) { setTimeout(function() { reject(new Error('remote_infer timed out after ' + (RI_TIMEOUT / 1000) + 's')); }, RI_TIMEOUT); });
-            var riResult = await Promise.race([riInvokeP, riTimeoutP]);
-            dlog('remote_infer: SUCCESS (explicit peer)');
-          } catch (riErr) {
-            var riErrMsg = riErr.message || String(riErr);
-            dlog('remote_infer: ERROR (explicit peer) ' + riErrMsg);
-            // NATS fallback \u2014 if direct dial failed (NAT/firewall/timeout), retry via NATS relay
-            if (_natsConn && _natsCodec && isDialFailure(riErrMsg)) {
-              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;
+
+            // Build race candidates \u2014 libp2p + timeout always present
+            var riRaceCandidates = [riInvokeP, riTimeoutP];
+
+            // Add NATS as a parallel candidate if available
+            if (_natsConn && _natsCodec) {
+              var _riNatsRaceP = (async function() {
+                var _rSubject = 'nexus.invoke.' + riTargetPeer;
+                var _rPayload = JSON.stringify({ capability: riCapName, input: riData, from: nexus.peerId || '' });
+                var _rResp = await _natsConn.request(_rSubject, _natsCodec.encode(_rPayload), { timeout: 240000 });
+                var _rResult = JSON.parse(_natsCodec.decode(_rResp.data));
+                if (_rResult && _rResult.error) throw new Error('NATS: ' + _rResult.error);
+                dlog('remote_infer: NATS won the race');
+                return _rResult;
+              })();
+              riRaceCandidates.push(_riNatsRaceP);
             }
+
+            var riResult = await Promise.any(riRaceCandidates.map(function(p) {
+              return p.catch(function(e) { return Promise.reject(e); });
+            }));
+            dlog('remote_infer: SUCCESS (peer ' + riTargetPeer.slice(0, 20) + ')');
+          } catch (riErr) {
+            // Promise.any throws AggregateError when ALL candidates fail
+            var riErrMsg = riErr.errors ? riErr.errors.map(function(e) { return e.message || String(e); }).join('; ') : (riErr.message || String(riErr));
+            dlog('remote_infer: ALL paths failed: ' + riErrMsg);
+            writeResp(id, { ok: false, output: 'Remote inference failed: ' + riErrMsg });
+            return;
           }
         } else {
           // Auto-discover: try speculative invoke on each 12D3KooW peer

package/package.json

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