open-agents-ai 0.83.0 → 0.84.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,165 @@ 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;
+      }
+
       case 'ping': {
         writeResp(id, { ok: true, output: 'pong' });
         break;
@@ -11418,6 +11597,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 +11659,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. v1.5.0: register_capability (serve invocations), block_peer/unblock_peer (trust policy), metering_status (usage tracking), room_members (live member tracking). Also supports direct peer invoke (streaming inference), IPFS content storage, direct messages, peer discovery, x402 micropayments, and inference proofs.";
       parameters = {
         type: "object",
         properties: {
@@ -11468,7 +11682,14 @@ 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"
             ],
             description: "The nexus action to perform"
           },
@@ -11588,6 +11809,27 @@ 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;
             default:
               return { success: false, output: "", error: `Unknown nexus action: ${action}`, durationMs: Date.now() - start };
           }
@@ -11812,12 +12054,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.84.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. 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, register_capability, unregister_capability, list_capabilities, block_peer, unblock_peer, metering_status, room_members.
 - 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,29 @@ 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
+
 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 register_capability to serve invocations, inference_proof
+to benchmark, 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