open-agents-ai 0.83.0 → 0.85.0

package/dist/index.js

@@ -11223,12 +11223,13 @@ var init_nexus = __esm({
 /**
  * nexus-daemon.mjs \u2014 Standalone nexus process with real TCP/UDP sockets.
  * Spawned by the open-agents nexus tool. Communicates via JSON files.
+ * v1.5.0: capability registration, peer blocking, metering, room members.
  *
  * Usage: node nexus-daemon.mjs <nexus-dir> <agent-name> [agent-type]
  */
 
-import { NexusClient } from 'open-agents-nexus';
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync } from 'node:fs';
+import { NexusClient, createFileAuditHook } from 'open-agents-nexus';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync, appendFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 const nexusDir = process.argv[2];
@@ -11239,8 +11240,11 @@ const respFile = join(nexusDir, 'resp.json');
 const statusFile = join(nexusDir, 'status.json');
 const inboxDir = join(nexusDir, 'inbox');
 const pidFile = join(nexusDir, 'daemon.pid');
+const invocationsDir = join(nexusDir, 'invocations');
+const meteringFile = join(nexusDir, 'metering.jsonl');
 
 mkdirSync(inboxDir, { recursive: true });
+mkdirSync(invocationsDir, { recursive: true });
 
 // Write PID so the agent can kill us
 writeFileSync(pidFile, String(process.pid));
@@ -11257,12 +11261,16 @@ const nexus = new NexusClient({
   natsServers: ['wss://demo.nats.io:8443'],
   enableCircuitRelay: true,
   usePublicBootstrap: true,
+  trustPolicy: { denylist: [], allowlist: [] },
 });
 
 const rooms = new Map();
 let connected = false;
+const blockedPeers = [];
 
 function writeStatus(extra = {}) {
+  const caps = typeof nexus.getRegisteredCapabilities === 'function'
+    ? nexus.getRegisteredCapabilities() : [];
   const data = {
     pid: process.pid,
     connected,
@@ -11270,6 +11278,8 @@ function writeStatus(extra = {}) {
     agentName,
     agentType,
     rooms: [...rooms.keys()],
+    capabilities: caps,
+    blockedPeers,
     connectedAt: connected ? new Date().toISOString() : null,
     ...extra,
   };
@@ -11289,6 +11299,7 @@ async function handleCmd(cmd) {
         if (rooms.has(roomId)) { writeResp(id, { ok: true, output: 'Already in room: ' + roomId }); return; }
         const room = await nexus.joinRoom(roomId);
         rooms.set(roomId, room);
+        // Per-room message listener (also captured by client-level event)
         room.on('message', (msg) => {
           const roomInbox = join(inboxDir, roomId);
           mkdirSync(roomInbox, { recursive: true });
@@ -11302,6 +11313,15 @@ async function handleCmd(cmd) {
           };
           try { writeFileSync(join(roomInbox, fname), JSON.stringify(entry, null, 2)); } catch {}
         });
+        // v1.5.0: Room member tracking
+        if (room.on) {
+          room.on('member:join', (member) => {
+            console.log('Member joined ' + roomId + ': ' + (member.agentName || member.peerId));
+          });
+          room.on('member:leave', (member) => {
+            console.log('Member left ' + roomId + ': ' + (member.agentName || member.peerId));
+          });
+        }
         writeStatus();
         writeResp(id, { ok: true, output: 'Joined room: ' + roomId });
         break;
@@ -11372,6 +11392,366 @@ async function handleCmd(cmd) {
         writeResp(id, { ok: true, output: JSON.stringify(data, null, 2) });
         break;
       }
+
+      // \u2500\u2500 v1.5.0: Capability Registration \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      case 'register_capability': {
+        const name = args.capability;
+        if (!name) { writeResp(id, { ok: false, output: 'capability name is required' }); return; }
+        if (typeof nexus.registerCapability !== 'function') {
+          writeResp(id, { ok: false, output: 'registerCapability not available (nexus version too old)' });
+          return;
+        }
+        nexus.registerCapability(name, async (request, stream) => {
+          // Log inbound invocation
+          const logEntry = {
+            ts: Date.now(),
+            from: request.from || 'unknown',
+            capability: request.capability || name,
+            requestId: request.requestId,
+          };
+          const logFile = join(invocationsDir, Date.now() + '-' + name + '.json');
+          try { writeFileSync(logFile, JSON.stringify(logEntry, null, 2)); } catch {}
+
+          // Collect input chunks
+          let inputData = '';
+          stream.onData((msg) => {
+            if (msg.type === 'invoke.chunk') {
+              inputData += (typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data));
+            }
+          });
+
+          // Accept the invocation
+          await stream.write({
+            type: 'invoke.accept', version: 1,
+            requestId: request.requestId, accepted: true,
+          });
+
+          // Send event with acknowledgment
+          await stream.write({
+            type: 'invoke.event', version: 1,
+            requestId: request.requestId, seq: 0,
+            event: 'ack', data: agentName + ' received invocation for ' + name,
+          });
+
+          // Complete
+          await stream.write({
+            type: 'invoke.done', version: 1,
+            requestId: request.requestId,
+            usage: { inputBytes: inputData.length, outputBytes: 0 },
+          });
+          stream.close();
+        });
+        writeStatus();
+        writeResp(id, { ok: true, output: 'Capability registered: ' + name + '. Now advertised via NATS.' });
+        break;
+      }
+      case 'unregister_capability': {
+        const name = args.capability;
+        if (!name) { writeResp(id, { ok: false, output: 'capability name is required' }); return; }
+        if (typeof nexus.unregisterCapability === 'function') {
+          nexus.unregisterCapability(name);
+        }
+        writeStatus();
+        writeResp(id, { ok: true, output: 'Capability unregistered: ' + name });
+        break;
+      }
+      case 'list_capabilities': {
+        const caps = typeof nexus.getRegisteredCapabilities === 'function'
+          ? nexus.getRegisteredCapabilities() : [];
+        writeResp(id, { ok: true, output: caps.length ? 'Capabilities: ' + caps.join(', ') : 'No capabilities registered.' });
+        break;
+      }
+
+      // \u2500\u2500 v1.5.0: Peer Blocking \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      case 'block_peer': {
+        const peerId = args.target_peer || args.peer_id;
+        if (!peerId) { writeResp(id, { ok: false, output: 'peer_id or target_peer is required' }); return; }
+        if (typeof nexus.blockPeer === 'function') {
+          nexus.blockPeer(peerId);
+        }
+        if (!blockedPeers.includes(peerId)) blockedPeers.push(peerId);
+        writeStatus();
+        writeResp(id, { ok: true, output: 'Blocked peer: ' + peerId.slice(0, 20) + '...' });
+        break;
+      }
+      case 'unblock_peer': {
+        const peerId = args.target_peer || args.peer_id;
+        if (!peerId) { writeResp(id, { ok: false, output: 'peer_id or target_peer is required' }); return; }
+        if (typeof nexus.unblockPeer === 'function') {
+          nexus.unblockPeer(peerId);
+        }
+        const idx = blockedPeers.indexOf(peerId);
+        if (idx >= 0) blockedPeers.splice(idx, 1);
+        writeStatus();
+        writeResp(id, { ok: true, output: 'Unblocked peer: ' + peerId.slice(0, 20) + '...' });
+        break;
+      }
+
+      // \u2500\u2500 v1.5.0: Metering \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      case 'metering_status': {
+        if (!nexus.metering) {
+          writeResp(id, { ok: true, output: 'Metering not available (nexus version too old).' });
+          return;
+        }
+        const filter = {};
+        if (args.peer_id) filter.peerId = args.peer_id;
+        if (args.capability) filter.service = args.capability;
+
+        // Try per-peer summary first
+        if (args.peer_id && typeof nexus.metering.getSummary === 'function') {
+          const summary = nexus.metering.getSummary(args.peer_id);
+          if (summary) {
+            writeResp(id, { ok: true, output: JSON.stringify(summary, null, 2) });
+            return;
+          }
+        }
+
+        // All summaries
+        if (typeof nexus.metering.getAllSummaries === 'function') {
+          const all = nexus.metering.getAllSummaries();
+          if (all && (all.size > 0 || Object.keys(all).length > 0)) {
+            const entries = all instanceof Map ? Object.fromEntries(all) : all;
+            writeResp(id, { ok: true, output: 'Metering summaries:\\n' + JSON.stringify(entries, null, 2) });
+            return;
+          }
+        }
+
+        // Fall back to raw records
+        if (typeof nexus.metering.getRecords === 'function') {
+          const records = nexus.metering.getRecords(filter);
+          writeResp(id, { ok: true, output: 'Records: ' + records.length + '\\n' + JSON.stringify(records.slice(-10), null, 2) });
+          return;
+        }
+
+        writeResp(id, { ok: true, output: 'No metering data yet.' });
+        break;
+      }
+
+      // \u2500\u2500 v1.5.0: Room Members \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      case 'room_members': {
+        const roomId = args.room_id;
+        if (!roomId) { writeResp(id, { ok: false, output: 'room_id is required' }); return; }
+        const room = rooms.get(roomId);
+        if (!room) { writeResp(id, { ok: false, output: 'Not in room: ' + roomId }); return; }
+
+        const members = room.members || [];
+        if (members.length === 0) {
+          writeResp(id, { ok: true, output: 'No members tracked in room: ' + roomId });
+          return;
+        }
+        const lines = ['Members in ' + roomId + ' (' + members.length + '):'];
+        for (const m of members) {
+          const name = m.agentName || 'unknown';
+          const type = m.agentType || '?';
+          const caps = m.capabilities?.join(', ') || 'none';
+          const status = m.status || 'active';
+          lines.push('  ' + m.peerId.slice(0, 16) + '... ' + name + ' (' + type + ') [' + status + '] caps: ' + caps);
+        }
+        writeResp(id, { ok: true, output: lines.join('\\n') });
+        break;
+      }
+
+      // \u2500\u2500 Metered Inference Exposure \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      case 'expose': {
+        // Query Ollama for available models
+        const ollamaUrl = args.ollama_url || process.env.OLLAMA_URL || 'http://localhost:11434';
+        let models = [];
+        try {
+          const tagsResp = await fetch(ollamaUrl + '/api/tags');
+          if (tagsResp.ok) {
+            const tagsData = await tagsResp.json();
+            models = (tagsData.models || []).map(m => ({
+              name: m.name,
+              size: m.size || 0,
+              parameterSize: m.details?.parameter_size || '',
+              family: m.details?.family || '',
+              quantization: m.details?.quantization_level || '',
+            }));
+          }
+        } catch (e) {
+          writeResp(id, { ok: false, output: 'Cannot reach Ollama at ' + ollamaUrl + ': ' + e.message });
+          return;
+        }
+
+        if (models.length === 0) {
+          writeResp(id, { ok: false, output: 'No models found on Ollama. Pull a model first.' });
+          return;
+        }
+
+        // Fetch market rates from OpenRouter (free, no auth)
+        let marketRates = {};
+        try {
+          const orResp = await fetch('https://openrouter.ai/api/v1/models');
+          if (orResp.ok) {
+            const orData = await orResp.json();
+            for (const m of (orData.data || [])) {
+              if (m.pricing) {
+                marketRates[m.id] = {
+                  input: parseFloat(m.pricing.prompt || '0') * 1_000_000,
+                  output: parseFloat(m.pricing.completion || '0') * 1_000_000,
+                };
+              }
+            }
+          }
+        } catch { /* offline \u2014 use zero rates */ }
+
+        // Build pricing menu \u2014 match local models to market rates
+        const margin = parseFloat(args.margin || '0.5'); // default 50% of market rate
+        const pricingMenu = [];
+
+        for (const model of models) {
+          // Try to match to OpenRouter model ID
+          const baseName = model.name.replace(/:latest$/, '').toLowerCase();
+          let matched = null;
+          for (const [orId, rates] of Object.entries(marketRates)) {
+            const orBase = orId.toLowerCase();
+            if (orBase.includes(baseName) || baseName.includes(orBase.split('/').pop())) {
+              matched = { orId, ...rates };
+              break;
+            }
+          }
+
+          const entry = {
+            model: model.name,
+            parameterSize: model.parameterSize,
+            family: model.family,
+            quantization: model.quantization,
+            pricing: {
+              input_per_1m_tokens: matched ? +(matched.input * margin).toFixed(4) : 0,
+              output_per_1m_tokens: matched ? +(matched.output * margin).toFixed(4) : 0,
+              currency: 'USD',
+              source: matched ? 'openrouter:' + matched.orId : 'self-hosted:free',
+              margin: margin,
+            },
+          };
+          pricingMenu.push(entry);
+
+          // Register as nexus capability
+          const capName = 'inference:' + model.name.replace(/[^a-zA-Z0-9._-]/g, '_');
+          if (typeof nexus.registerCapability === 'function') {
+            nexus.registerCapability(capName, async (request, stream) => {
+              const logEntry = {
+                ts: Date.now(),
+                from: request.from || 'unknown',
+                capability: capName,
+                model: model.name,
+                requestId: request.requestId,
+              };
+              const logFile = join(invocationsDir, Date.now() + '-' + capName + '.json');
+              try { writeFileSync(logFile, JSON.stringify(logEntry, null, 2)); } catch {}
+
+              // Collect input
+              let prompt = '';
+              stream.onData((msg) => {
+                if (msg.type === 'invoke.chunk') {
+                  prompt += (typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data));
+                }
+              });
+
+              // Accept
+              await stream.write({
+                type: 'invoke.accept', version: 1,
+                requestId: request.requestId, accepted: true,
+              });
+
+              // Forward to Ollama
+              try {
+                const genResp = await fetch(ollamaUrl + '/api/generate', {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify({
+                    model: model.name,
+                    prompt: prompt || 'Hello',
+                    stream: false,
+                  }),
+                });
+                const genData = await genResp.json();
+                const output = genData.response || '';
+                const inputTokens = genData.prompt_eval_count || 0;
+                const outputTokens = genData.eval_count || 0;
+
+                // Stream result back
+                await stream.write({
+                  type: 'invoke.event', version: 1,
+                  requestId: request.requestId, seq: 0,
+                  event: 'result',
+                  data: JSON.stringify({
+                    model: model.name,
+                    response: output,
+                    usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                    pricing: entry.pricing,
+                  }),
+                });
+
+                await stream.write({
+                  type: 'invoke.done', version: 1,
+                  requestId: request.requestId,
+                  usage: {
+                    inputBytes: prompt.length,
+                    outputBytes: output.length,
+                    tokens: inputTokens + outputTokens,
+                  },
+                });
+              } catch (e) {
+                await stream.write({
+                  type: 'invoke.event', version: 1,
+                  requestId: request.requestId, seq: 0,
+                  event: 'error', data: 'Inference failed: ' + e.message,
+                });
+                await stream.write({
+                  type: 'invoke.done', version: 1,
+                  requestId: request.requestId,
+                  usage: { inputBytes: 0, outputBytes: 0 },
+                });
+              }
+              stream.close();
+            });
+          }
+        }
+
+        // Write pricing menu to file
+        const pricingFile = join(nexusDir, 'pricing.json');
+        writeFileSync(pricingFile, JSON.stringify({ updated: new Date().toISOString(), models: pricingMenu }, null, 2));
+        writeStatus({ exposedModels: pricingMenu.length });
+
+        const lines = ['Exposed ' + pricingMenu.length + ' model(s) as nexus capabilities:'];
+        for (const p of pricingMenu) {
+          const cost = p.pricing.input_per_1m_tokens === 0
+            ? 'FREE (self-hosted)'
+            : '$' + p.pricing.input_per_1m_tokens + '/$' + p.pricing.output_per_1m_tokens + ' per 1M tokens';
+          lines.push('  inference:' + p.model + ' \u2014 ' + cost);
+        }
+        lines.push('');
+        lines.push('Pricing menu saved to ' + pricingFile);
+        lines.push('Market rates: ' + Object.keys(marketRates).length + ' models from OpenRouter');
+        writeResp(id, { ok: true, output: lines.join('\\n') });
+        break;
+      }
+
+      case 'pricing_menu': {
+        const pricingFile = join(nexusDir, 'pricing.json');
+        if (!existsSync(pricingFile)) {
+          writeResp(id, { ok: false, output: 'No pricing menu. Run expose first.' });
+          return;
+        }
+        try {
+          const menu = JSON.parse(readFileSync(pricingFile, 'utf8'));
+          const lines = ['Inference Pricing Menu (updated: ' + menu.updated + ')'];
+          lines.push('');
+          for (const m of (menu.models || [])) {
+            const cost = m.pricing.input_per_1m_tokens === 0
+              ? 'FREE'
+              : '$' + m.pricing.input_per_1m_tokens + ' in / $' + m.pricing.output_per_1m_tokens + ' out per 1M tokens';
+            lines.push('  ' + m.model + ' (' + m.parameterSize + ', ' + m.quantization + ')');
+            lines.push('    ' + cost + ' [' + m.pricing.source + ']');
+          }
+          writeResp(id, { ok: true, output: lines.join('\\n') });
+        } catch (e) {
+          writeResp(id, { ok: false, output: 'Failed to read pricing menu: ' + e.message });
+        }
+        break;
+      }
+
       case 'ping': {
         writeResp(id, { ok: true, output: 'pong' });
         break;
@@ -11418,6 +11798,41 @@ process.on('unhandledRejection', (reason) => {
       await node.start();
     }
     connected = true;
+
+    // v1.5.0: Setup metering audit hook
+    try {
+      if (nexus.metering && typeof nexus.metering.addHook === 'function') {
+        nexus.metering.addHook(createFileAuditHook(meteringFile));
+      }
+    } catch {}
+
+    // v1.5.0: Client-level events for global message/DM/invoke routing
+    try {
+      if (typeof nexus.on === 'function') {
+        nexus.on('message', ({ roomId, message }) => {
+          // Already handled by per-room listener, but log globally
+          console.log('[msg] ' + roomId + ' from ' + (message?.sender || '?').slice(0, 16));
+        });
+        nexus.on('dm', ({ from, content, format, messageId }) => {
+          // Log DMs to inbox/dm/
+          const dmDir = join(inboxDir, '_dm');
+          mkdirSync(dmDir, { recursive: true });
+          const entry = {
+            sender: from,
+            content: content || '',
+            format: format || 'text/plain',
+            timestamp: Date.now(),
+            id: messageId,
+          };
+          try { writeFileSync(join(dmDir, Date.now() + '.json'), JSON.stringify(entry, null, 2)); } catch {}
+          console.log('[dm] from ' + (from || '?').slice(0, 16));
+        });
+        nexus.on('invoke', ({ from, capability, requestId }) => {
+          console.log('[invoke] ' + capability + ' from ' + (from || '?').slice(0, 16) + ' req=' + requestId);
+        });
+      }
+    } catch {}
+
     writeStatus();
     console.log('Nexus daemon connected as ' + nexus.peerId);
   } catch (err) {
@@ -11445,7 +11860,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
     ];
     NexusTool = class {
       name = "nexus";
-      description = "Decentralized agent-to-agent communication via open-agents-nexus v1.4.0. Spawns a background Node.js process with real network sockets for libp2p + NATS P2P mesh. Simple flow: connect \u2192 join room \u2192 send messages. Auto-installs/updates nexus if needed. Also supports direct peer invoke (streaming inference), IPFS content storage, direct messages, peer discovery, x402 micropayments, and inference proofs. Onboarding: curl openagents.nexus/llms.txt for full instructions, /.well-known/agent.json for machine-readable manifest.";
+      description = "Decentralized agent-to-agent communication via open-agents-nexus v1.5.0. Spawns a background Node.js process with real network sockets for libp2p + NATS P2P mesh. Simple flow: connect \u2192 join room \u2192 send messages. Auto-installs/updates nexus if needed. EXPOSE: expose action queries Ollama models, fetches OpenRouter market rates, registers metered inference capabilities so peers can invoke your models. pricing_menu shows rates. v1.5.0: register_capability, block_peer/unblock_peer, metering_status, room_members. Also supports direct peer invoke, IPFS storage, DMs, discovery, x402, inference proofs.";
       parameters = {
         type: "object",
         properties: {
@@ -11468,7 +11883,16 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               "retrieve_content",
               "wallet_status",
               "wallet_create",
-              "inference_proof"
+              "inference_proof",
+              "register_capability",
+              "unregister_capability",
+              "list_capabilities",
+              "block_peer",
+              "unblock_peer",
+              "metering_status",
+              "room_members",
+              "expose",
+              "pricing_menu"
             ],
             description: "The nexus action to perform"
           },
@@ -11515,6 +11939,14 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           cid: {
             type: "string",
             description: "Content ID for retrieve_content"
+          },
+          ollama_url: {
+            type: "string",
+            description: "Ollama API URL for expose (default: http://localhost:11434)"
+          },
+          margin: {
+            type: "string",
+            description: "Price margin multiplier for expose (0.5 = 50% of market rate, 0 = free). Default: 0.5"
           }
         },
         required: ["action"],
@@ -11588,6 +12020,33 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             case "inference_proof":
               result = await this.doInferenceProof();
               break;
+            case "register_capability":
+              result = await this.sendDaemonCmd("register_capability", args);
+              break;
+            case "unregister_capability":
+              result = await this.sendDaemonCmd("unregister_capability", args);
+              break;
+            case "list_capabilities":
+              result = await this.sendDaemonCmd("list_capabilities", args);
+              break;
+            case "block_peer":
+              result = await this.sendDaemonCmd("block_peer", args);
+              break;
+            case "unblock_peer":
+              result = await this.sendDaemonCmd("unblock_peer", args);
+              break;
+            case "metering_status":
+              result = await this.sendDaemonCmd("metering_status", args);
+              break;
+            case "room_members":
+              result = await this.sendDaemonCmd("room_members", args);
+              break;
+            case "expose":
+              result = await this.sendDaemonCmd("expose", args, 3e4);
+              break;
+            case "pricing_menu":
+              result = await this.sendDaemonCmd("pricing_menu", args);
+              break;
             default:
               return { success: false, output: "", error: `Unknown nexus action: ${action}`, durationMs: Date.now() - start };
           }
@@ -11611,7 +12070,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           return null;
         }
       }
-      async sendDaemonCmd(action, args) {
+      async sendDaemonCmd(action, args, timeoutMs = 15e3) {
         const pid = this.getDaemonPid();
         if (!pid)
           throw new Error("Nexus daemon not running. Use action 'connect' first.");
@@ -11622,7 +12081,8 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           await unlink(respFile).catch(() => {
           });
         await writeFile12(cmdFile, JSON.stringify({ id: cmdId, action, args }, null, 2));
-        for (let i = 0; i < 30; i++) {
+        const polls = Math.ceil(timeoutMs / 500);
+        for (let i = 0; i < polls; i++) {
           await new Promise((r) => setTimeout(r, 500));
           if (!existsSync21(respFile))
             continue;
@@ -11634,7 +12094,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           } catch {
           }
         }
-        return "Daemon did not respond within 15s. It may still be processing.";
+        return `Daemon did not respond within ${Math.round(timeoutMs / 1e3)}s. It may still be processing.`;
       }
       // =========================================================================
       // Actions
@@ -11812,12 +12272,14 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         try {
           const status = JSON.parse(await readFile13(statusFile, "utf8"));
           const lines = [
-            `Nexus Status`,
+            `Nexus Status (v1.5.0)`,
             `  Connected: ${status.connected}`,
             `  Peer ID: ${status.peerId || "n/a"}`,
             `  Agent: ${status.agentName} (${status.agentType})`,
             `  Daemon PID: ${status.pid}`,
-            `  Rooms: ${status.rooms?.length || 0} [${(status.rooms || []).join(", ")}]`
+            `  Rooms: ${status.rooms?.length || 0} [${(status.rooms || []).join(", ")}]`,
+            `  Capabilities: ${(status.capabilities || []).length ? (status.capabilities || []).join(", ") : "none"}`,
+            `  Blocked peers: ${(status.blockedPeers || []).length || 0}`
           ];
           const walletPath = join28(this.nexusDir, "wallet.enc");
           if (existsSync21(walletPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.83.0",
+  "version": "0.85.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",
@@ -70,6 +70,6 @@
   },
   "optionalDependencies": {
     "moondream": "^0.2.0",
-    "open-agents-nexus": "^1.4.1"
+    "open-agents-nexus": "^1.5.0"
   }
 }

package/prompts/agentic/system-large.md

@@ -26,7 +26,7 @@ If a tool fails, try a different approach. If you're unsure, explore with your t
 - web_fetch: Fetch a web page and extract text content (for docs, MDN, w3schools.com, etc.)
 - memory_read: Read from persistent memory (learned patterns, solutions)
 - memory_write: Store a fact, pattern, or solution in persistent memory for future tasks
-- nexus: P2P agent networking (libp2p + NATS + IPFS). Connect to other agents, join rooms, send messages, discover peers, invoke capabilities, store content, manage wallet. Actions: connect, disconnect, status, join_room, leave_room, send_message, read_messages, discover_peers, list_rooms, send_dm, find_agent, invoke_capability, store_content, retrieve_content, wallet_status, wallet_create, inference_proof.
+- nexus: P2P agent networking (libp2p + NATS + IPFS). Connect to other agents, join rooms, send messages, discover peers, invoke capabilities, store content, manage wallet. Key actions: connect, join_room, send_message, discover_peers, invoke_capability, expose (metered inference), pricing_menu, register_capability, block_peer, metering_status, room_members. Full list: connect, disconnect, status, join_room, leave_room, send_message, read_messages, discover_peers, list_rooms, send_dm, find_agent, invoke_capability, store_content, retrieve_content, wallet_status, wallet_create, inference_proof, register_capability, unregister_capability, list_capabilities, block_peer, unblock_peer, metering_status, room_members, expose, pricing_menu.
 - task_complete: Signal task completion with a summary
 
 ## Parallel Execution & Sub-Agents
@@ -185,7 +185,7 @@ If you notice you're performing the SAME multi-step sequence for the 3rd time or
 - Test the tool mentally before creating — ensure the steps would work in order
 - Prefer 'project' scope unless the pattern genuinely applies to all projects
 
-## Nexus P2P Networking (v1.4.0) — Decentralized Agent Communication
+## Nexus P2P Networking (v1.5.0) — Decentralized Agent Communication
 
 You HAVE the nexus tool. It is one of your registered tools. USE IT when asked about connecting, messaging, or networking with other agents.
 
@@ -234,11 +234,42 @@ Use invoke_capability for real work (inference, tool calls) — NOT room message
   nexus(action='wallet_create')
   nexus(action='inference_proof')
 
+### v1.5.0: Serve Capabilities
+  nexus(action='register_capability', capability='text-generation')  — register handler for incoming invocations
+  nexus(action='unregister_capability', capability='text-generation')
+  nexus(action='list_capabilities')  — list registered capability names
+
+### v1.5.0: Trust & Blocking
+  nexus(action='block_peer', target_peer='12D3KooW...')   — blocks invoke + DM from peer
+  nexus(action='unblock_peer', target_peer='12D3KooW...')
+
+### v1.5.0: Usage Metering
+  nexus(action='metering_status')                          — all peer summaries
+  nexus(action='metering_status', peer_id='12D3KooW...')   — per-peer summary
+  nexus(action='metering_status', capability='chat')       — filter by service
+
+### v1.5.0: Room Members
+  nexus(action='room_members', room_id='general')          — live member list with capabilities
+
+### Metered Inference Exposure
+  nexus(action='expose')                    — expose ALL local Ollama models as nexus capabilities
+  nexus(action='expose', margin='0.5')      — set pricing at 50% of market rate (default)
+  nexus(action='expose', margin='0')        — expose for free (self-hosted, no cost)
+  nexus(action='expose', margin='1.0')      — match market rate
+  nexus(action='pricing_menu')              — show current pricing menu for exposed models
+
+expose queries local Ollama for models, fetches live market rates from OpenRouter
+(https://openrouter.ai/api/v1/models — free, no auth), registers each model as a
+nexus capability (inference:{model_name}), and writes pricing to .oa/nexus/pricing.json.
+Peers can invoke your models via invoke_capability and see metered usage.
+
 SECURITY: Wallet private keys are AES-256-GCM encrypted and NEVER accessible to you.
 All outbound messages are scanned for key material leaks.
 
 When the user asks about expanding capabilities or connecting with other agents, suggest
-enabling nexus networking. Use inference_proof to benchmark and advertise capabilities.
+enabling nexus networking. Use expose to share your models with the network, pricing_menu
+to check rates, register_capability to serve custom invocations, and room_members to
+discover who's online.
 
 ## Temporal Agency — Scheduling, Reminders & Long-Horizon Tasks
 

package/prompts/agentic/system-medium.md

@@ -17,7 +17,7 @@ NEVER say "I can't do that". ALWAYS attempt the task using your tools. If a tool
 - web_search: Search the web
 - web_fetch: Fetch a web page's text
 - memory_read / memory_write: Persistent memory across sessions
-- nexus: P2P agent networking (connect, join_room, send_message, discover_peers, invoke_capability, wallet, etc.)
+- nexus: P2P agent networking (connect, join_room, send_message, discover_peers, invoke_capability, register_capability, block_peer, metering_status, room_members, wallet, etc.)
 - task_complete: Signal completion with a summary
 - background_run / task_status / task_output / task_stop: Background tasks
 - batch_edit: Multiple edits across files in one call