open-agents-ai 0.84.0 → 0.85.0

package/dist/index.js

@@ -11551,6 +11551,207 @@ async function handleCmd(cmd) {
         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;
@@ -11659,7 +11860,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
     ];
     NexusTool = class {
       name = "nexus";
-      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.";
+      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: {
@@ -11689,7 +11890,9 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               "block_peer",
               "unblock_peer",
               "metering_status",
-              "room_members"
+              "room_members",
+              "expose",
+              "pricing_menu"
             ],
             description: "The nexus action to perform"
           },
@@ -11736,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"],
@@ -11830,6 +12041,12 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             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 };
           }
@@ -11853,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.");
@@ -11864,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;
@@ -11876,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.84.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",

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, register_capability, unregister_capability, list_capabilities, block_peer, unblock_peer, metering_status, room_members.
+- 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
@@ -251,12 +251,25 @@ Use invoke_capability for real work (inference, tool calls) — NOT room message
 ### 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 register_capability to serve invocations, inference_proof
-to benchmark, and room_members to discover who's online.
+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