open-agents-ai 0.103.69 → 0.103.71

package/dist/index.js

@@ -12130,6 +12130,26 @@ const blockedPeers = [];
 // Both peers connect to wss://demo.nats.io:8443, so NATS request/reply bridges the gap.
 var _natsConn = null;
 var _natsCodec = null;
+var _tokensByRequest = {};
+
+// Check if an error is a connectivity/dial failure (should trigger NATS fallback)
+// vs an application-level error (auth rejected, capability not found \u2014 no point retrying via NATS)
+function isDialFailure(errMsg) {
+  var appErrors = ['unauthorized', 'capability not found', 'not registered', 'auth rejected'];
+  var lower = errMsg.toLowerCase();
+  for (var i = 0; i < appErrors.length; i++) {
+    if (lower.includes(appErrors[i])) return false;
+  }
+  // Any network/transport error should fall back to NATS
+  return lower.includes('multiaddrs failed') || lower.includes('econnrefused') ||
+    lower.includes('etimedout') || lower.includes('dial to peer') ||
+    lower.includes('no route') || lower.includes('circuit relay') ||
+    lower.includes('stream was reset') || lower.includes('timeout') ||
+    lower.includes('connection reset') || lower.includes('ehostunreach') ||
+    lower.includes('enetunreach') || lower.includes('peer not reachable') ||
+    lower.includes('dial error') || lower.includes('aborted') ||
+    lower.includes('connection refused');
+}
 
 function writeStatus(extra = {}) {
   const caps = typeof nexus.getRegisteredCapabilities === 'function'
@@ -12284,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 && 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 });
-          }
+          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;
       }
@@ -12331,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), 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 });
-          }
+          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;
       }
@@ -12409,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), 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;
+
+            // 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
@@ -12488,6 +12484,36 @@ async function handleCmd(cmd) {
           }
           dlog('remote_infer: auto-discover took ' + (Date.now() - discStart) + 'ms');
 
+          // If libp2p auto-discover failed, try NATS relay against discovered peers from cache
+          if (!riResult && _natsConn && _natsCodec) {
+            try {
+              var _dpFile = join(nexusDir, 'discovered-peers.json');
+              if (existsSync(_dpFile)) {
+                var _dpData = JSON.parse(readFileSync(_dpFile, 'utf8'));
+                var _dpPeers = Object.keys(_dpData).filter(function(p) { return p.startsWith('12D3KooW'); });
+                dlog('remote_infer: trying NATS relay on ' + _dpPeers.length + ' cached peers');
+                for (var _dpi = 0; _dpi < _dpPeers.length && !riResult; _dpi++) {
+                  var _dpPid = _dpPeers[_dpi];
+                  try {
+                    var _dpSubject = 'nexus.invoke.' + _dpPid;
+                    var _dpPayload = JSON.stringify({ capability: riCapName, input: riData, from: nexus.peerId || '' });
+                    var _dpResp = await _natsConn.request(_dpSubject, _natsCodec.encode(_dpPayload), { timeout: 180000 });
+                    var _dpResult = JSON.parse(_natsCodec.decode(_dpResp.data));
+                    if (_dpResult && !_dpResult.error) {
+                      riResult = _dpResult;
+                      riTargetPeer = _dpPid;
+                      dlog('remote_infer: SUCCESS via NATS relay peer ' + _dpPid.slice(0, 20));
+                    }
+                  } catch (_dpErr) {
+                    dlog('remote_infer: NATS peer ' + _dpPid.slice(0, 20) + ' failed: ' + (_dpErr.message || _dpErr));
+                  }
+                }
+              }
+            } catch (_dpCacheErr) {
+              dlog('remote_infer: NATS discovery cache error: ' + (_dpCacheErr.message || _dpCacheErr));
+            }
+          }
+
           if (!riResult) {
             writeResp(id, { ok: false, output: 'No peer found with capability: ' + riCapName + '. Ensure a provider is running expose with model ' + riModel });
             return;
@@ -13100,6 +13126,12 @@ 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) => {
+            // Stream safety wrapper \u2014 prevents unguarded writes after consumer disconnects
+            var smStreamClosed = false;
+            async function smWrite(msg) {
+              if (smStreamClosed) return;
+              try { await stream.write(msg); } catch { smStreamClosed = true; }
+            }
             // Collect input via stream data events (auth_key arrives in invoke.chunk, NOT invoke.open)
             var smDataChunks = [];
             var smInputDone = false;
@@ -13113,7 +13145,7 @@ async function handleCmd(cmd) {
             });
 
             // Accept invocation so consumer sends data
-            await stream.write({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: true });
+            await smWrite({ type: 'invoke.accept', version: 1, requestId: request.requestId, accepted: true });
 
             // Wait briefly for data (auth key arrives in chunk)
             var smWait = 0;
@@ -13138,9 +13170,9 @@ async function handleCmd(cmd) {
               }
               if (smAuthKey !== exposeAuthKey) {
                 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();
+                await smWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'Unauthorized' });
+                await smWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
+                try { stream.close(); } catch {}
                 return;
               }
               dlog('system_metrics: auth OK');
@@ -13175,13 +13207,13 @@ async function handleCmd(cmd) {
                 gpu: gpuInfo,
                 timestamp: new Date().toISOString(),
               };
-              await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'result', data: JSON.stringify(metricsPayload) });
-              await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: JSON.stringify(metricsPayload).length } });
+              await smWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'result', data: JSON.stringify(metricsPayload) });
+              await smWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: JSON.stringify(metricsPayload).length } });
             } catch (me) {
-              await stream.write({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'metrics error: ' + me.message });
-              await stream.write({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
+              await smWrite({ type: 'invoke.event', version: 1, requestId: request.requestId, seq: 0, event: 'error', data: 'metrics error: ' + me.message });
+              await smWrite({ type: 'invoke.done', version: 1, requestId: request.requestId, usage: { inputBytes: 0, outputBytes: 0 } });
             }
-            stream.close();
+            try { stream.close(); } catch {}
           });
           dlog('system_metrics capability registered');
         }
@@ -13380,7 +13412,6 @@ process.on('unhandledRejection', (reason) => {
     // The nexus library fires this hook AFTER handler returns, so it has the correct
     // peerId from connection context. We stash token data per requestId so the hook
     // can merge them into one complete record written to metering.jsonl.
-    var _tokensByRequest = {};
     try {
       if (nexus.metering && typeof nexus.metering.addHook === 'function') {
         nexus.metering.addHook(function(record) {
@@ -13532,25 +13563,39 @@ process.on('unhandledRejection', (reason) => {
                 continue;
               }
 
-              // Create mock stream handle that captures the handler's output
+              // Create mock stream handle that captures the handler's output.
+              // Uses retroactive delivery: if handler registers onData after data is
+              // already queued, deliver immediately. Eliminates timing race.
               var _nResults = [];
-              var _nHandleDone = false;
+              var _nDataCbs = [];
+              var _nDataDelivered = 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() {
+                  if (_nDataDelivered) {
+                    // Data already flushed \u2014 deliver retroactively
                     try {
                       cb({ type: 'invoke.chunk', data: _nInputStr, seq: 0 });
                       cb({ type: 'invoke.done' });
                     } catch {}
-                  }, 5);
+                  } else {
+                    _nDataCbs.push(cb);
+                  }
                 },
                 close: function() {},
               };
+              // Flush input data to any registered onData listeners after 50ms
+              setTimeout(function() {
+                _nDataDelivered = true;
+                for (var _di = 0; _di < _nDataCbs.length; _di++) {
+                  try {
+                    _nDataCbs[_di]({ type: 'invoke.chunk', data: _nInputStr, seq: 0 });
+                    _nDataCbs[_di]({ type: 'invoke.done' });
+                  } catch {}
+                }
+              }, 50);
 
               var _nRequest = {
                 type: 'invoke.open',
@@ -13803,7 +13848,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               result = await this.sendDaemonCmd("query_peer_caps", args, 2e4);
               break;
             case "invoke_capability":
-              result = await this.sendDaemonCmd("invoke_capability", args, 1e5);
+              result = await this.sendDaemonCmd("invoke_capability", args, 32e4);
               break;
             case "store_content":
               result = await this.sendDaemonCmd("store_content", args);
@@ -14899,7 +14944,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         } else {
           daemonArgs.prompt = prompt;
         }
-        const result = await this.sendDaemonCmd("remote_infer", daemonArgs, 12e4);
+        const result = await this.sendDaemonCmd("remote_infer", daemonArgs, 32e4);
         let peerUsed = args.target_peer || "auto-selected";
         try {
           const parsed = JSON.parse(result);
@@ -35530,12 +35575,6 @@ async function handleUpdate(subcommand, ctx) {
   process.stdout.write("\n");
   const checkSpinner = startInlineSpinner(`Checking for updates ${c2.dim(`(current: v${currentVersion})`)}`);
   const info = await checkForUpdate(currentVersion, true);
-  if (!info) {
-    checkSpinner.stop(`You're on the latest version (v${currentVersion}).`);
-    process.stdout.write("\n");
-    return;
-  }
-  checkSpinner.stop(`Update available: v${info.currentVersion} \u2192 v${c2.bold(c2.green(info.latestVersion))}`);
   const { exec: exec3, execSync: es2 } = await import("node:child_process");
   let needsSudo = false;
   try {
@@ -35548,21 +35587,6 @@ async function handleUpdate(subcommand, ctx) {
     }
   } catch {
   }
-  if (needsSudo) {
-    renderInfo("Global npm directory requires elevated permissions.");
-    renderInfo("You'll be asked for your password once \u2014 it covers all update steps.");
-    process.stdout.write("\n");
-    try {
-      es2("sudo -v", { stdio: "inherit", timeout: 6e4 });
-    } catch {
-      renderWarning("Could not acquire sudo credentials. Try: sudo npm i -g open-agents-ai");
-      return;
-    }
-  }
-  const sudoPrefix = needsSudo ? "sudo " : "";
-  const installSpinner = startInlineSpinner("Installing update");
-  const installCmd = `${sudoPrefix}npm install -g open-agents-ai@latest --prefer-online`;
-  let installOk = false;
   let installError = "";
   const runInstall2 = (cmd) => new Promise((resolve31) => {
     const child = exec3(cmd, { timeout: 18e4 }, (err, _stdout, stderr) => {
@@ -35572,35 +35596,84 @@ async function handleUpdate(subcommand, ctx) {
     });
     child.stdout?.resume();
   });
-  installOk = await runInstall2(installCmd);
-  if (!installOk && /ENOTEMPTY|errno -39/i.test(installError)) {
-    installSpinner.stop("Cleaning stale npm temp files...");
+  if (needsSudo) {
+    renderInfo("Global npm directory requires elevated permissions.");
+    renderInfo("You'll be asked for your password once \u2014 it covers all update steps.");
+    process.stdout.write("\n");
     try {
-      const prefix = es2("npm prefix -g", { encoding: "utf8", timeout: 5e3 }).trim();
-      const globalModules = prefix.endsWith("/lib") ? prefix + "/node_modules" : prefix + "/lib/node_modules";
-      es2(`${sudoPrefix}find "${globalModules}" -maxdepth 1 -name ".open-agents-ai-*" -type d -exec rm -rf {} + 2>/dev/null || true`, { timeout: 15e3 });
-      es2(`${sudoPrefix}rm -rf "${globalModules}/open-agents-ai" 2>/dev/null || true`, { timeout: 15e3 });
+      es2("sudo -v", { stdio: "inherit", timeout: 6e4 });
     } catch {
+      renderWarning("Could not acquire sudo credentials. Try: sudo npm i -g open-agents-ai");
+      return;
     }
-    const retrySpinner = startInlineSpinner("Retrying install");
-    installError = "";
+  }
+  const sudoPrefix = needsSudo ? "sudo " : "";
+  let primaryUpdated = false;
+  if (!info) {
+    checkSpinner.stop(`Primary package up to date (v${currentVersion}).`);
+  } else {
+    checkSpinner.stop(`Update available: v${info.currentVersion} \u2192 v${c2.bold(c2.green(info.latestVersion))}`);
+    const installSpinner = startInlineSpinner("Installing update");
+    const installCmd = `${sudoPrefix}npm install -g open-agents-ai@latest --prefer-online`;
+    let installOk = false;
     installOk = await runInstall2(installCmd);
+    if (!installOk && /ENOTEMPTY|errno -39/i.test(installError)) {
+      installSpinner.stop("Cleaning stale npm temp files...");
+      try {
+        const prefix = es2("npm prefix -g", { encoding: "utf8", timeout: 5e3 }).trim();
+        const globalModules = prefix.endsWith("/lib") ? prefix + "/node_modules" : prefix + "/lib/node_modules";
+        es2(`${sudoPrefix}find "${globalModules}" -maxdepth 1 -name ".open-agents-ai-*" -type d -exec rm -rf {} + 2>/dev/null || true`, { timeout: 15e3 });
+        es2(`${sudoPrefix}rm -rf "${globalModules}/open-agents-ai" 2>/dev/null || true`, { timeout: 15e3 });
+      } catch {
+      }
+      const retrySpinner = startInlineSpinner("Retrying install");
+      installError = "";
+      installOk = await runInstall2(installCmd);
+      if (!installOk) {
+        retrySpinner.stop("Retry failed.");
+      } else {
+        retrySpinner.stop(`Update installed (v${info.latestVersion}).`);
+      }
+    }
     if (!installOk) {
-      retrySpinner.stop("Retry failed.");
-    } else {
-      retrySpinner.stop(`Update installed (v${info.latestVersion}).`);
+      installSpinner.stop("Update install failed.");
+      const errPreview = installError.split("\n").filter((l) => l.trim()).slice(-3).join("\n    ");
+      if (errPreview)
+        renderWarning(`Error:
+    ${errPreview}`);
+      renderWarning(`Try manually: ${sudoPrefix}npm i -g open-agents-ai`);
+      return;
     }
+    installSpinner.stop(`Update installed (v${info.latestVersion}).`);
+    primaryUpdated = true;
   }
-  if (!installOk) {
-    installSpinner.stop("Update install failed.");
-    const errPreview = installError.split("\n").filter((l) => l.trim()).slice(-3).join("\n    ");
-    if (errPreview)
-      renderWarning(`Error:
-    ${errPreview}`);
-    renderWarning(`Try manually: ${sudoPrefix}npm i -g open-agents-ai`);
+  const depsSpinner = startInlineSpinner("Checking subordinate dependencies");
+  let depsUpdated = false;
+  try {
+    const prefix = es2("npm prefix -g", { encoding: "utf8", timeout: 5e3 }).trim();
+    const globalModules = prefix.endsWith("/lib") ? prefix + "/node_modules" : prefix + "/lib/node_modules";
+    const { existsSync: fe, readFileSync: rf } = await import("node:fs");
+    const { join: pj } = await import("node:path");
+    const pkgPath = pj(globalModules, "open-agents-ai", "package.json");
+    if (fe(pkgPath)) {
+      const pkg = JSON.parse(rf(pkgPath, "utf8"));
+      const allDeps = { ...pkg.dependencies || {}, ...pkg.optionalDependencies || {} };
+      const depNames = Object.keys(allDeps);
+      if (depNames.length > 0) {
+        const updateCmd = `${sudoPrefix}npm update --prefer-online --prefix "${pj(globalModules, "open-agents-ai")}" 2>/dev/null || true`;
+        const updateOk = await runInstall2(updateCmd);
+        if (updateOk)
+          depsUpdated = true;
+      }
+    }
+  } catch {
+  }
+  depsSpinner.stop(depsUpdated ? "Dependencies updated to latest." : "Dependencies checked.");
+  if (!primaryUpdated && !depsUpdated) {
+    renderInfo("Everything is up to date \u2014 no changes needed.");
+    process.stdout.write("\n");
     return;
   }
-  installSpinner.stop(`Update installed (v${info.latestVersion}).`);
   const rebuildSpinner = startInlineSpinner("Rebuilding native modules");
   const rebuildOk = await new Promise((resolve31) => {
     const child = exec3(`${sudoPrefix}npm rebuild -g open-agents-ai 2>/dev/null || true`, { timeout: 12e4 }, () => resolve31(true));

package/package.json

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