open-agents-ai 0.84.0 → 0.86.0

package/dist/index.js

@@ -11239,6 +11239,8 @@ const cmdFile = join(nexusDir, 'cmd.json');
 const respFile = join(nexusDir, 'resp.json');
 const statusFile = join(nexusDir, 'status.json');
 const inboxDir = join(nexusDir, 'inbox');
+const logFile = join(nexusDir, 'daemon.log');
+function dlog(msg) { try { appendFileSync(logFile, new Date().toISOString() + ' ' + msg + '\\n'); } catch {} }
 const pidFile = join(nexusDir, 'daemon.pid');
 const invocationsDir = join(nexusDir, 'invocations');
 const meteringFile = join(nexusDir, 'metering.jsonl');
@@ -11292,6 +11294,7 @@ function writeResp(id, result) {
 
 async function handleCmd(cmd) {
   const { id, action, args } = cmd;
+  dlog('handleCmd: action=' + action + ' id=' + id);
   try {
     switch (action) {
       case 'join_room': {
@@ -11374,8 +11377,19 @@ async function handleCmd(cmd) {
         const capability = args.capability || 'text-generation';
         const input = args.input || {};
         if (!peerId) { writeResp(id, { ok: false, output: 'target_peer is required' }); return; }
-        const result = await nexus.invokeCapability(peerId, capability, typeof input === 'string' ? { prompt: input } : input, { stream: false, maxDurationMs: 60000 });
-        writeResp(id, { ok: true, output: JSON.stringify(result, null, 2) });
+        dlog('invoke_capability: peer=' + peerId.slice(0, 20) + ' cap=' + capability);
+        try {
+          // Wrap in a 90s timeout to prevent hangs from nexus library issues
+          const INVOKE_TIMEOUT = 90_000;
+          const invokePromise = nexus.invokeCapability(peerId, capability, typeof input === 'string' ? { prompt: input } : input, { stream: false, maxDurationMs: 60000 });
+          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]);
+          dlog('invoke_capability: SUCCESS');
+          writeResp(id, { ok: true, output: JSON.stringify(result, null, 2) });
+        } catch (invokeErr) {
+          dlog('invoke_capability: ERROR ' + (invokeErr.message || String(invokeErr)));
+          writeResp(id, { ok: false, output: 'Invoke error: ' + (invokeErr.message || String(invokeErr)) });
+        }
         break;
       }
       case 'store_content': {
@@ -11551,6 +11565,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;
@@ -11572,7 +11787,9 @@ setInterval(() => {
     const cmd = JSON.parse(raw);
     if (cmd.id === lastCmdId) return; // already processed
     lastCmdId = cmd.id;
-    handleCmd(cmd);
+    handleCmd(cmd).catch((err) => {
+      writeResp(cmd.id, { ok: false, output: 'Error: ' + (err.message || String(err)) });
+    });
   } catch {}
 }, 500);
 
@@ -11659,7 +11876,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 +11906,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 +11955,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"],
@@ -11789,10 +12016,10 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               result = await this.doSendDM(args);
               break;
             case "find_agent":
-              result = await this.sendDaemonCmd("find_agent", args);
+              result = await this.sendDaemonCmd("find_agent", args, 3e4);
               break;
             case "invoke_capability":
-              result = await this.sendDaemonCmd("invoke_capability", args);
+              result = await this.sendDaemonCmd("invoke_capability", args, 1e5);
               break;
             case "store_content":
               result = await this.sendDaemonCmd("store_content", args);
@@ -11830,6 +12057,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 +12086,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 +12097,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 +12110,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
@@ -40465,7 +40699,7 @@ ${result.text}`;
             const steerPrompt = [
               `The user typed a mid-task message while the agent is working. Your job:`,
               `1. Understand what the user wants changed/added/corrected`,
-              `2. Produce a brief spoken acknowledgment (1 sentence, conversational)`,
+              `2. Produce a brief, UNIQUE spoken acknowledgment that reflects WHAT they asked for`,
               `3. Expand their input into a clear, structured steering instruction for the main agent`,
               ``,
               `Current task goal: "${steerTaskGoal.slice(0, 500)}"`,
@@ -40476,11 +40710,30 @@ ${result.text}`;
               `User's mid-task message: "${input}"`,
               ``,
               `Call task_complete with:`,
-              `- acknowledgment: brief spoken response to the user (e.g. "Got it, I'll adjust the approach")`,
+              `- acknowledgment: a brief spoken response SPECIFIC to what the user said. Reference the actual change they want. DO NOT use generic phrases like "Got it" or "adjusting". Instead describe what you'll do differently. Examples of GOOD acknowledgments:`,
+              `  - "Switching to the new API endpoint now"`,
+              `  - "Right, I'll use TypeScript instead"`,
+              `  - "Understood, dropping the database mock"`,
+              `  - "On it, pulling in that dependency first"`,
+              `  - "Yep, let me rethink the caching layer"`,
+              `  - "Makes sense, I'll refactor that into a separate module"`,
               `- summary: expanded instruction for the main agent (e.g. "USER STEERING: The user wants X instead of Y. Adjust your approach to prioritize Z. Specifically, they are asking you to...")`
             ].join("\n");
             const result = await steerAgent.run(steerPrompt, "Steering sub-agent \u2014 interpret user input and produce instruction.");
-            let acknowledgment = "Got it, adjusting.";
+            const STEER_FALLBACKS = [
+              `Noted, changing course.`,
+              `On it, shifting approach.`,
+              `Understood, recalibrating.`,
+              `Right, let me rework that.`,
+              `Okay, taking a different angle.`,
+              `Heard you, pivoting now.`,
+              `Sure thing, rethinking this.`,
+              `Copy that, adapting.`,
+              `Makes sense, re-routing.`,
+              `Roger, new plan.`
+            ];
+            const fbIdx = Math.floor(Math.random() * STEER_FALLBACKS.length);
+            let acknowledgment = STEER_FALLBACKS[fbIdx];
             let steering = `USER STEERING: ${input}`;
             try {
               const parsed = JSON.parse(result.summary || "{}");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.84.0",
+  "version": "0.86.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.5.0"
+    "open-agents-nexus": "^1.5.6"
   }
 }

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