open-agents-ai 0.184.7 → 0.184.8

package/dist/index.js

@@ -5571,6 +5571,123 @@ async function handleCmd(cmd) {
         writeResp(id, { ok: true, output: 'Message sent (id: ' + msgId + ')' });
         break;
       }
+      // \u2500\u2500 Sponsor announcement via NATS \u2500\u2500
+      case 'sponsor_announce': {
+        // Publish sponsor metadata to NATS so other OA instances can discover it
+        if (!_natsConn || !_natsCodec) {
+          writeResp(id, { ok: false, output: 'NATS not connected \u2014 cannot announce sponsorship' });
+          return;
+        }
+        var sponsorData = {
+          type: 'sponsor.announce',
+          peerId: globalThis._daemonPeerId || 'unknown',
+          name: args.name || 'Anonymous Sponsor',
+          models: args.models || [],
+          tunnelUrl: args.tunnel_url || null,
+          authKey: args.auth_key || '',
+          limits: {
+            maxRequestsPerMinute: parseInt(args.rpm || '60', 10),
+            maxTokensPerDay: parseInt(args.tpd || '100000', 10),
+          },
+          banner: args.banner || null,
+          message: args.message || '',
+          linkUrl: args.link_url || '',
+          linkText: args.link_text || '',
+          status: 'active',
+          timestamp: Date.now(),
+        };
+        _natsConn.publish('nexus.sponsors.announce', _natsCodec.encode(JSON.stringify(sponsorData)));
+        dlog('sponsor_announce: published to nexus.sponsors.announce');
+        // Also join the sponsors room and send as room message for persistence
+        if (!rooms.has('sponsors')) {
+          try {
+            var spRoom = await nexus.joinRoom('sponsors');
+            rooms.set('sponsors', spRoom);
+            dlog('sponsor_announce: auto-joined sponsors room');
+          } catch (roomErr) {
+            dlog('sponsor_announce: room join failed: ' + (roomErr.message || roomErr));
+          }
+        }
+        if (rooms.has('sponsors')) {
+          try {
+            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)' });
+        break;
+      }
+      case 'sponsor_discover': {
+        // Subscribe to nexus.sponsors.announce for a short window and collect announcements
+        if (!_natsConn || !_natsCodec) {
+          writeResp(id, { ok: false, output: 'NATS not connected', sponsors: [] });
+          return;
+        }
+        var foundSponsors = [];
+        var discoverTimeout = parseInt(args.timeout_ms || '5000', 10);
+
+        // Also check sponsors room inbox for cached messages
+        var sponsorInbox = join(inboxDir, 'sponsors');
+        try {
+          if (existsSync(sponsorInbox)) {
+            var inboxFiles = readdirSync(sponsorInbox).filter(f => f.endsWith('.json')).sort().reverse().slice(0, 20);
+            for (var fi = 0; fi < inboxFiles.length; fi++) {
+              try {
+                var msg = JSON.parse(readFileSync(join(sponsorInbox, inboxFiles[fi]), 'utf8'));
+                var content = msg.content || '';
+                try {
+                  var parsed = JSON.parse(content);
+                  if (parsed.type === 'sponsor.announce' && parsed.status === 'active') {
+                    // Only include if not too stale (< 10 minutes)
+                    if (Date.now() - (parsed.timestamp || 0) < 600000) {
+                      foundSponsors.push(parsed);
+                    }
+                  }
+                } catch {}
+              } catch {}
+            }
+          }
+        } catch {}
+
+        // Join sponsors room to receive future announcements
+        if (!rooms.has('sponsors')) {
+          try {
+            var spRoom2 = await nexus.joinRoom('sponsors');
+            rooms.set('sponsors', spRoom2);
+          } catch {}
+        }
+
+        // Subscribe to NATS for live announcements (short window)
+        try {
+          var sub = _natsConn.subscribe('nexus.sponsors.announce');
+          var subDone = false;
+          setTimeout(() => { subDone = true; sub.unsubscribe(); }, discoverTimeout);
+          for await (var natMsg of sub) {
+            if (subDone) break;
+            try {
+              var sp = JSON.parse(_natsCodec.decode(natMsg.data));
+              if (sp.type === 'sponsor.announce' && sp.status === 'active') {
+                foundSponsors.push(sp);
+              }
+            } catch {}
+          }
+        } catch (subErr) {
+          dlog('sponsor_discover: NATS sub error: ' + (subErr.message || subErr));
+        }
+
+        // Deduplicate by peerId
+        var seen = {};
+        var unique = [];
+        for (var si = 0; si < foundSponsors.length; si++) {
+          var key = foundSponsors[si].peerId || foundSponsors[si].tunnelUrl || ('sp-' + si);
+          if (!seen[key]) {
+            seen[key] = true;
+            unique.push(foundSponsors[si]);
+          }
+        }
+
+        writeResp(id, { ok: true, output: unique.length + ' sponsor(s) found', sponsors: unique });
+        break;
+      }
       case 'discover_peers': {
         const node = nexus.network?.node;
         const peers = node?.getPeers?.() || [];
@@ -8173,6 +8290,12 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             case "expose":
               result = await this.sendDaemonCmd("expose", args, 6e4);
               break;
+            case "sponsor_announce":
+              result = await this.sendDaemonCmd("sponsor_announce", args, 1e4);
+              break;
+            case "sponsor_discover":
+              result = await this.sendDaemonCmd("sponsor_discover", args, 1e4);
+              break;
             case "pricing_menu":
               result = await this.sendDaemonCmd("pricing_menu", args);
               break;
@@ -47236,6 +47359,28 @@ async function handleSlashCommand(input, ctx) {
               renderError(`P2P start failed: ${err instanceof Error ? err.message : String(err)}`);
             }
           }
+          try {
+            const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+            const nexus = new NexusTool2(projectDir);
+            const tunnelGw = ctx.getExposeGateway?.();
+            const enabledEps = config.endpoints.filter((e) => e.enabled);
+            const allModels = enabledEps.flatMap((e) => e.models || []);
+            await nexus.execute({
+              action: "sponsor_announce",
+              name: config.header.message || "OA Sponsor",
+              models: allModels.join(","),
+              tunnel_url: tunnelGw?.tunnelUrl || "",
+              auth_key: tunnelGw?.authKey || "",
+              rpm: String(config.rateLimits.maxRequestsPerMinute),
+              tpd: String(config.rateLimits.maxTokensPerDay),
+              banner: config.banner.preset,
+              message: config.header.message,
+              link_url: config.header.linkUrl,
+              link_text: config.header.linkText
+            });
+            renderInfo("Announced on nexus P2P mesh \u2014 other users can discover you via /endpoint sponsor");
+          } catch {
+          }
         }
       });
       if (result) {
@@ -49006,39 +49151,74 @@ async function handleEndpoint(arg, ctx, local = false) {
 async function handleSponsoredEndpoint(ctx, local) {
   process.stdout.write(`
   ${c2.dim("Scanning for sponsored inference endpoints...")}
-
 `);
   const sponsors = [];
+  let nexusTool = null;
+  try {
+    const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+    nexusTool = new NexusTool2(ctx.repoRoot ?? process.cwd());
+  } catch {
+  }
+  if (nexusTool) {
+    process.stdout.write(`  ${c2.dim("Connecting to nexus P2P mesh...")}
+`);
+    try {
+      const statusResult = await nexusTool.execute({ action: "status" });
+      const isConnected = typeof statusResult === "string" && statusResult.includes("connected");
+      if (!isConnected) {
+        process.stdout.write(`  ${c2.dim("Starting nexus daemon...")}
+`);
+        await nexusTool.execute({ action: "connect" });
+        await new Promise((r) => setTimeout(r, 3e3));
+      }
+      process.stdout.write(`  ${c2.dim("Querying nexus sponsors room...")}
+`);
+      const discoverResult = await nexusTool.execute({
+        action: "sponsor_discover",
+        timeout_ms: "5000"
+      });
+      if (typeof discoverResult === "string") {
+        try {
+          const parsed = JSON.parse(discoverResult);
+          const nexusSponsors = parsed.sponsors || [];
+          for (const ns of nexusSponsors) {
+            sponsors.push({
+              name: ns.name || "Unknown Sponsor",
+              url: ns.tunnelUrl || "",
+              authKey: ns.authKey || "",
+              models: ns.models || [],
+              limits: {
+                rpm: ns.limits?.maxRequestsPerMinute || 60,
+                tpd: ns.limits?.maxTokensPerDay || 1e5
+              },
+              source: "nexus",
+              banner: { preset: ns.banner?.preset, message: ns.message }
+            });
+          }
+          if (nexusSponsors.length > 0) {
+            process.stdout.write(`  ${c2.green("\u25CF")} Found ${nexusSponsors.length} sponsor(s) on nexus mesh
+`);
+          }
+        } catch {
+        }
+      }
+    } catch (nexusErr) {
+      process.stdout.write(`  ${c2.dim("Nexus unavailable: " + (nexusErr instanceof Error ? nexusErr.message : String(nexusErr)).slice(0, 60))}
+`);
+    }
+  }
   const gateway = ctx.getExposeGateway?.();
   if (gateway && gateway.isActive) {
     const gwUrl = gateway.tunnelUrl || `http://127.0.0.1:${gateway._proxyPort || 11434}`;
-    sponsors.push({
-      name: "Local Gateway",
-      url: gwUrl,
-      authKey: gateway.authKey,
-      models: [],
-      limits: { rpm: 60, tpd: 1e5 },
-      source: "local"
-    });
-  }
-  const { loadSponsorConfig: loadSpCfg } = await Promise.resolve().then(() => (init_sponsor_wizard(), sponsor_wizard_exports));
-  const spCfg = loadSpCfg(ctx.repoRoot ?? process.cwd());
-  if (spCfg && spCfg.status === "active") {
-    const epUrls = new Set(sponsors.map((s) => s.url));
-    for (const ep of spCfg.endpoints.filter((e) => e.enabled)) {
-      if (!epUrls.has(ep.url)) {
-        sponsors.push({
-          name: ep.label,
-          url: ep.url,
-          authKey: "",
-          models: ep.models,
-          limits: {
-            rpm: spCfg.rateLimits.maxRequestsPerMinute,
-            tpd: spCfg.rateLimits.maxTokensPerDay
-          },
-          source: "local"
-        });
-      }
+    if (!sponsors.some((s) => s.url === gwUrl)) {
+      sponsors.push({
+        name: "Local Gateway",
+        url: gwUrl,
+        authKey: gateway.authKey,
+        models: [],
+        limits: { rpm: 60, tpd: 1e5 },
+        source: "local"
+      });
     }
   }
   const sponsorDir2 = join58(ctx.repoRoot ?? process.cwd(), ".oa", "sponsor");
@@ -49047,30 +49227,19 @@ async function handleSponsoredEndpoint(ctx, local) {
     if (existsSync42(knownFile)) {
       const saved = JSON.parse(readFileSync31(knownFile, "utf8"));
       for (const s of saved) {
-        try {
-          const probe = await fetch(`${s.url}/api/tags`, {
-            headers: s.authKey ? { Authorization: `Bearer ${s.authKey}` } : {},
-            signal: AbortSignal.timeout(5e3)
-          });
-          if (probe.ok) {
-            const data = await probe.json();
-            s.models = (data.models || []).map((m) => m.name);
-            sponsors.push(s);
-          }
-        } catch {
+        if (!sponsors.some((sp) => sp.url === s.url)) {
+          sponsors.push({ ...s, source: "saved" });
         }
       }
     }
   } catch {
   }
+  process.stdout.write("\n");
   if (sponsors.length === 0) {
-    renderInfo("No sponsored endpoints found.");
-    renderInfo("");
-    renderInfo("To connect to a sponsor, use:");
-    renderInfo("  /endpoint <tunnel-url> --auth <key>");
+    renderInfo("No sponsored endpoints found on the nexus mesh.");
     renderInfo("");
-    renderInfo("Or add a known sponsor URL:");
-    renderInfo("  /endpoint sponsor add <url> --auth <key>");
+    renderInfo("Make sure the nexus is connected (/nexus) and sponsors are online.");
+    renderInfo("Or connect directly: /endpoint <tunnel-url> --auth <key>");
     return;
   }
   const items = [

package/package.json

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