open-agents-ai 0.87.0 → 0.89.0

package/README.md

@@ -999,6 +999,7 @@ The steering sub-agent uses the same model and backend as the main agent with `m
 | `nexus:expose` | Expose local Ollama models as metered inference capabilities with OpenRouter-based pricing |
 | `nexus:wallet_create` | Generate secp256k1/EVM wallet (Base mainnet USDC) with AES-256-GCM encryption + x402-wallet.key |
 | `nexus:spend` | Sign EIP-3009 USDC TransferWithAuthorization — budget-checked, gasless for payer |
+| `nexus:remote_infer` | Route inference to a remote peer's model — auto-discovers peers, budget-checks, invokes, returns result |
 | `nexus:ledger_status` | Transaction history (earned/spent/pending USDC) |
 | `nexus:budget_set` | Configure spending limits — daily cap, per-invoke max, auto-approve threshold |
 
@@ -1077,6 +1078,13 @@ nexus(action='spend', target_address='0x...', amount_usdc='0.10')
 ```
 Signs an EIP-3009 `TransferWithAuthorization`. Budget-checked before signing. The recipient (or any facilitator) submits on-chain — no gas needed from the payer. Proof saved to `.oa/nexus/pending-transfer.json`.
 
+### Remote Inference — Tap Into the Mesh
+```
+nexus(action='remote_infer', model='qwen3.5:70b', prompt='Complex analysis task...')
+nexus(action='remote_infer', model='llama3.3:70b', prompt='...', target_peer='12D3KooW...')
+```
+Route a prompt to a remote peer's model on the P2P mesh. Auto-discovers peers that have the requested model exposed, budget-checks the estimated cost, invokes the inference capability, and returns the response. Use `target_peer` to route to a specific provider, or omit for automatic peer selection. Your 8B laptop can seamlessly tap into a 122B model running on the mesh.
+
 ### Ledger & Budget
 ```
 nexus(action='ledger_status')                          # Earned/spent/pending history
@@ -1093,6 +1101,7 @@ nexus(action='budget_set', auto_approve_below='0.01')  # Auto-approve micropayme
 4. Consumer's daemon auto-signs `payment_proof` → provider validates → invoke proceeds
 5. Metering hook writes payment events to `ledger.jsonl`
 6. **spend** → direct agent-to-agent USDC transfers (EIP-3009, gasless)
+7. **remote_infer** → auto-discover + invoke in one action (budget-checked, with ledger entry)
 
 ### Security Model
 - Private keys: AES-256-GCM encrypted in `wallet.enc` (scrypt-derived key)

package/dist/index.js

@@ -139,7 +139,7 @@ var init_config = __esm({
       verbose: false,
       dbPath: join(homedir(), ".open-agents", "memory.db")
     });
-    VALID_BACKEND_TYPES = /* @__PURE__ */ new Set(["ollama", "vllm", "fake"]);
+    VALID_BACKEND_TYPES = /* @__PURE__ */ new Set(["ollama", "vllm", "fake", "nexus"]);
   }
 });
 
@@ -11202,7 +11202,7 @@ ${truncated}`, durationMs: performance.now() - start };
 });
 
 // packages/execution/dist/tools/nexus.js
-import { readFile as readFile13, writeFile as writeFile12, mkdir as mkdir8, chmod, unlink, readdir as readdir3 } from "node:fs/promises";
+import { readFile as readFile13, writeFile as writeFile12, mkdir as mkdir8, chmod, unlink, readdir as readdir3, open as fsOpen } from "node:fs/promises";
 import { existsSync as existsSync21, readFileSync as readFileSync15 } from "node:fs";
 import { resolve as resolve26, join as join28 } from "node:path";
 import { randomBytes as randomBytes6, createCipheriv, createDecipheriv, scryptSync, createHash } from "node:crypto";
@@ -11405,6 +11405,101 @@ async function handleCmd(cmd) {
         }
         break;
       }
+      case 'remote_infer': {
+        var riModel = args.model;
+        var riPrompt = args.prompt || args.input || '';
+        var riMessages = args.messages || null;
+        var riTools = args.tools || null;
+        var riTargetPeer = args.target_peer || '';
+        if (!riModel) { writeResp(id, { ok: false, output: 'model is required' }); return; }
+        if (!riPrompt && !riMessages) { writeResp(id, { ok: false, output: 'prompt or messages is required' }); return; }
+
+        // Build invoke data \u2014 structured (messages+tools) or flat (prompt)
+        var riData;
+        if (riMessages) {
+          var riParsedMsgs = typeof riMessages === 'string' ? JSON.parse(riMessages) : riMessages;
+          riData = { messages: riParsedMsgs };
+          if (riTools) {
+            riData.tools = typeof riTools === 'string' ? JSON.parse(riTools) : riTools;
+          }
+          if (args.temperature !== undefined) riData.temperature = Number(args.temperature);
+          if (args.max_tokens) riData.max_tokens = Number(args.max_tokens);
+        } else {
+          riData = { prompt: riPrompt };
+        }
+
+        // Derive capability name from model
+        var riCapName = 'inference:' + riModel.replace(/[^a-zA-Z0-9._-]/g, '_');
+        dlog('remote_infer: model=' + riModel + ' cap=' + riCapName + ' prompt_len=' + riPrompt.length);
+
+        // If target_peer specified, invoke directly. Otherwise auto-discover.
+        if (riTargetPeer) {
+          // Direct invoke on specified peer
+          dlog('remote_infer: invoking ' + riCapName + ' on explicit peer ' + riTargetPeer.slice(0, 20));
+          try {
+            var RI_TIMEOUT = 120000;
+            var riInvokeP = nexus.invokeCapability(riTargetPeer, riCapName, riData, { stream: false, maxDurationMs: 90000 });
+            var riTimeoutP = new Promise(function(_, reject) { setTimeout(function() { reject(new Error('remote_infer timed out after ' + (RI_TIMEOUT / 1000) + 's')); }, RI_TIMEOUT); });
+            var riResult = await Promise.race([riInvokeP, riTimeoutP]);
+            dlog('remote_infer: SUCCESS (explicit peer)');
+          } catch (riErr) {
+            dlog('remote_infer: ERROR (explicit peer) ' + (riErr.message || String(riErr)));
+            writeResp(id, { ok: false, output: 'Remote inference failed: ' + (riErr.message || String(riErr)) });
+            return;
+          }
+        } else {
+          // Auto-discover: try speculative invoke on each 12D3KooW peer
+          // Skip Qm-prefixed bootstrap/relay nodes \u2014 they never host inference
+          var discStart = Date.now();
+          var riResult = null;
+          try {
+            var riNode = nexus.network ? nexus.network.node : null;
+            var riPeers = riNode && typeof riNode.getPeers === 'function' ? riNode.getPeers() : [];
+            var riCandidates = [];
+            for (var rfi = 0; rfi < riPeers.length; rfi++) {
+              var rpStr = riPeers[rfi].toString ? riPeers[rfi].toString() : String(riPeers[rfi]);
+              if (rpStr.startsWith('12D3KooW')) riCandidates.push(rpStr);
+            }
+            dlog('remote_infer: auto-discover across ' + riCandidates.length + ' peers (of ' + riPeers.length + ' total) for ' + riCapName);
+
+            for (var ri = 0; ri < riCandidates.length && !riResult; ri++) {
+              var rPid = riCandidates[ri];
+              dlog('remote_infer: trying peer ' + rPid.slice(0, 20) + '...');
+              try {
+                var PEER_INVOKE_TIMEOUT = 30000; // 30s per peer attempt
+                var specInvoke = nexus.invokeCapability(rPid, riCapName, riData, { stream: false, maxDurationMs: 25000 });
+                var specTimeout = new Promise(function(_, reject) {
+                  setTimeout(function() { reject(new Error('peer invoke timeout')); }, PEER_INVOKE_TIMEOUT);
+                });
+                riResult = await Promise.race([specInvoke, specTimeout]);
+                riTargetPeer = rPid;
+                dlog('remote_infer: SUCCESS via peer ' + rPid.slice(0, 20) + ' (' + (Date.now() - discStart) + 'ms)');
+              } catch (specErr) {
+                dlog('remote_infer: peer ' + rPid.slice(0, 20) + ' failed: ' + (specErr.message || specErr));
+              }
+            }
+          } catch (discErr) {
+            dlog('remote_infer: discovery error: ' + (discErr.message || discErr));
+          }
+          dlog('remote_infer: auto-discover took ' + (Date.now() - discStart) + 'ms');
+
+          if (!riResult) {
+            writeResp(id, { ok: false, output: 'No peer found with capability: ' + riCapName + '. Ensure a provider is running expose with model ' + riModel });
+            return;
+          }
+        }
+
+        // riResult and riTargetPeer are available from either path above
+        var riOutput = {
+          success: true,
+          model: riModel,
+          peer: riTargetPeer,
+          capability: riCapName,
+          result: riResult,
+        };
+        writeResp(id, { ok: true, output: JSON.stringify(riOutput, null, 2) });
+        break;
+      }
       case 'store_content': {
         const data = args.data;
         if (!data) { writeResp(id, { ok: false, output: 'data is required' }); return; }
@@ -11679,11 +11774,17 @@ async function handleCmd(cmd) {
               const logFile = join(invocationsDir, Date.now() + '-' + capName + '.json');
               try { writeFileSync(logFile, JSON.stringify(logEntry, null, 2)); } catch {}
 
-              // Collect input
+              // Collect input via stream data events
               let prompt = '';
+              var dataChunks = [];
+              var inputDone = false;
               stream.onData((msg) => {
                 if (msg.type === 'invoke.chunk') {
-                  prompt += (typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data));
+                  var chunk = typeof msg.data === 'string' ? msg.data : JSON.stringify(msg.data);
+                  dataChunks.push(chunk);
+                }
+                if (msg.type === 'invoke.done' || msg.type === 'invoke.end' || msg.type === 'invoke.close') {
+                  inputDone = true;
                 }
               });
 
@@ -11693,33 +11794,100 @@ async function handleCmd(cmd) {
                 requestId: request.requestId, accepted: true,
               });
 
-              // Forward to Ollama
+              // Wait for input data to arrive (invoke protocol sends data after accept)
+              var waitMs = 0;
+              while (!inputDone && dataChunks.length === 0 && waitMs < 5000) {
+                await new Promise(function(r) { setTimeout(r, 100); });
+                waitMs += 100;
+              }
+              prompt = dataChunks.join('');
+              dlog('expose: received ' + dataChunks.length + ' chunks, prompt_len=' + prompt.length + ' inputDone=' + inputDone);
+
+              // Forward to Ollama \u2014 supports both flat prompt and structured messages
               try {
-                const genResp = await fetch(ollamaUrl + '/api/generate', {
-                  method: 'POST',
-                  headers: { 'Content-Type': 'application/json' },
-                  body: JSON.stringify({
+                var parsedReq = null;
+                try { parsedReq = JSON.parse(prompt); } catch (pe) { dlog('expose: JSON parse error: ' + (pe.message || pe)); }
+
+                var genResp, genData, output, inputTokens, outputTokens, responsePayload;
+
+                if (parsedReq && parsedReq.messages && Array.isArray(parsedReq.messages)) {
+                  // Structured request \u2014 use /v1/chat/completions (supports tools + multi-turn)
+                  var chatBody = {
                     model: model.name,
-                    prompt: prompt || 'Hello',
+                    messages: parsedReq.messages,
                     stream: false,
-                  }),
-                });
-                const genData = await genResp.json();
-                const output = genData.response || '';
-                const inputTokens = genData.prompt_eval_count || 0;
-                const outputTokens = genData.eval_count || 0;
+                  };
+                  if (parsedReq.tools && parsedReq.tools.length > 0) {
+                    chatBody.tools = parsedReq.tools;
+                  }
+                  if (parsedReq.temperature !== undefined) chatBody.temperature = parsedReq.temperature;
+                  if (parsedReq.max_tokens) chatBody.max_tokens = parsedReq.max_tokens;
+
+                  dlog('expose: calling /v1/chat/completions with ' + chatBody.messages.length + ' messages, tools=' + (chatBody.tools ? chatBody.tools.length : 0));
+                  genResp = await fetch(ollamaUrl + '/v1/chat/completions', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(chatBody),
+                  });
+                  genData = await genResp.json();
+                  dlog('expose: ollama response keys=' + Object.keys(genData).join(',') + ' choices=' + (genData.choices ? genData.choices.length : 0));
+
+                  var chatChoices = genData.choices || [];
+                  var firstMsg = (chatChoices[0] || {}).message || {};
+                  // Strip <think>...</think> tags from content (thinking models)
+                  var rawContent = firstMsg.content || '';
+                  output = rawContent.replace(/<think>[\\s\\S]*?<\\/think>/g, '').trim();
+                  // Fallback: if content is empty but reasoning exists, use reasoning
+                  // (happens when max_tokens is too small for thinking models at temp=0)
+                  if (!output && firstMsg.reasoning) {
+                    output = firstMsg.reasoning;
+                  }
+                  // Update the choices to reflect final content
+                  if (chatChoices[0] && chatChoices[0].message) {
+                    chatChoices[0].message.content = output;
+                  }
+                  dlog('expose: rawContent_len=' + rawContent.length + ' output_len=' + output.length + ' reasoning=' + (firstMsg.reasoning ? firstMsg.reasoning.length : 0) + ' tool_calls=' + (firstMsg.tool_calls ? firstMsg.tool_calls.length : 0));
+                  inputTokens = (genData.usage || {}).prompt_tokens || 0;
+                  outputTokens = (genData.usage || {}).completion_tokens || 0;
+
+                  responsePayload = {
+                    model: model.name,
+                    response: output,
+                    choices: chatChoices,
+                    usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                    pricing: entry.pricing,
+                  };
+                } else {
+                  // Flat prompt \u2014 use /api/generate (original behavior)
+                  var flatPrompt = parsedReq && parsedReq.prompt ? parsedReq.prompt : (prompt || 'Hello');
+                  genResp = await fetch(ollamaUrl + '/api/generate', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                      model: model.name,
+                      prompt: flatPrompt,
+                      stream: false,
+                    }),
+                  });
+                  genData = await genResp.json();
+                  output = genData.response || '';
+                  inputTokens = genData.prompt_eval_count || 0;
+                  outputTokens = genData.eval_count || 0;
+
+                  responsePayload = {
+                    model: model.name,
+                    response: output,
+                    usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                    pricing: entry.pricing,
+                  };
+                }
 
                 // 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,
-                  }),
+                  data: JSON.stringify(responsePayload),
                 });
 
                 await stream.write({
@@ -11727,7 +11895,7 @@ async function handleCmd(cmd) {
                   requestId: request.requestId,
                   usage: {
                     inputBytes: prompt.length,
-                    outputBytes: output.length,
+                    outputBytes: (output || '').length,
                     tokens: inputTokens + outputTokens,
                   },
                 });
@@ -11932,7 +12100,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. 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. WALLET: wallet_create generates EVM wallet (secp256k1, Base mainnet USDC). wallet_status shows address, USDC balance, and ledger summary. PAYMENTS: ledger_status tracks earnings/spending. budget_status/budget_set configure spending limits. spend: sign EIP-3009 USDC transfer (target_address + amount_usdc). x402 native payment via daemon.";
+      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. WALLET: wallet_create generates EVM wallet (secp256k1, Base mainnet USDC). wallet_status shows address, USDC balance, and ledger summary. PAYMENTS: ledger_status tracks earnings/spending. budget_status/budget_set configure spending limits. spend: sign EIP-3009 USDC transfer (target_address + amount_usdc). x402 native payment via daemon. REMOTE INFERENCE: remote_infer routes a prompt to a remote peer's model on the mesh. Auto-discovers peers with the requested model capability, budget-checks, invokes, and returns the result. Use: nexus(action='remote_infer', model='qwen3.5:70b', prompt='...'). Optional: target_peer, temperature, max_tokens.";
       parameters = {
         type: "object",
         properties: {
@@ -11968,7 +12136,8 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
               "ledger_status",
               "budget_status",
               "budget_set",
-              "spend"
+              "spend",
+              "remote_infer"
             ],
             description: "The nexus action to perform"
           },
@@ -12043,6 +12212,22 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           amount_usdc: {
             type: "string",
             description: "For spend: USDC amount to transfer (e.g. '0.10')"
+          },
+          model: {
+            type: "string",
+            description: "For remote_infer: model to request (e.g. 'qwen3.5:70b', 'nemotron-3-nano:30b')"
+          },
+          prompt: {
+            type: "string",
+            description: "For remote_infer: the prompt text to send to the remote model"
+          },
+          temperature: {
+            type: "string",
+            description: "For remote_infer: sampling temperature (e.g. '0.7'). Default: 0.7"
+          },
+          max_tokens: {
+            type: "string",
+            description: "For remote_infer: maximum tokens to generate (e.g. '4096'). Default: 4096"
           }
         },
         required: ["action"],
@@ -12155,6 +12340,9 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             case "spend":
               result = await this.doSpend(args);
               break;
+            case "remote_infer":
+              result = await this.doRemoteInfer(args);
+              break;
             default:
               return { success: false, output: "", error: `Unknown nexus action: ${action}`, durationMs: Date.now() - start };
           }
@@ -12204,6 +12392,14 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         }
         return `Daemon did not respond within ${Math.round(timeoutMs / 1e3)}s. It may still be processing.`;
       }
+      /** Public interface for daemon commands — used by NexusAgenticBackend */
+      async sendCommand(action, args, timeoutMs) {
+        return this.sendDaemonCmd(action, args, timeoutMs);
+      }
+      /** Get the nexus data directory path */
+      getNexusDir() {
+        return this.nexusDir;
+      }
       // =========================================================================
       // Actions
       // =========================================================================
@@ -12551,8 +12747,9 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
             network: "base",
             chainId: 8453
           };
-          await writeFile12(walletPath, JSON.stringify(w2, null, 2));
-          await chmod(walletPath, 384);
+          const walletFh = await fsOpen(walletPath, "w", 384);
+          await walletFh.writeFile(JSON.stringify(w2, null, 2));
+          await walletFh.close();
           await this.ensureDefaultBudget();
           return `Wallet configured: ${userAddress} (user-managed, Base mainnet, no x402 key \u2014 spend/sign requires self-hosted wallet)`;
         }
@@ -12578,8 +12775,9 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         let enc = cipher.update(privKeyHex, "utf8", "hex");
         enc += cipher.final("hex");
         const x402KeyPath = join28(this.nexusDir, "x402-wallet.key");
-        await writeFile12(x402KeyPath, "0x" + privKeyHex);
-        await chmod(x402KeyPath, 384);
+        const x402Fh = await fsOpen(x402KeyPath, "w", 384);
+        await x402Fh.writeFile("0x" + privKeyHex);
+        await x402Fh.close();
         privKeyHex = "0".repeat(64);
         const w = {
           version: 2,
@@ -12592,8 +12790,9 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           network: "base",
           chainId: 8453
         };
-        await writeFile12(walletPath, JSON.stringify(w, null, 2));
-        await chmod(walletPath, 384);
+        const walletFh2 = await fsOpen(walletPath, "w", 384);
+        await walletFh2.writeFile(JSON.stringify(w, null, 2));
+        await walletFh2.close();
         await this.ensureDefaultBudget();
         return [
           `Wallet created (v2, secp256k1/EVM):`,
@@ -12748,7 +12947,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           // $0.50 — warn when low
           circuitBreakerUsdc: 1e5,
           // $0.10 — refuse payments below this balance
-          allowedCapabilities: ["inference:*", "transfer:direct"],
+          allowedCapabilities: ["inference:*", "transfer:direct", "remote_infer"],
           deniedPeers: []
         };
         await this.ensureDir();
@@ -12878,7 +13077,7 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
         const amountSmallest = Math.round(parseFloat(amountUsd) * 1e6);
         if (amountSmallest <= 0)
           throw new Error("amount must be positive");
-        const budgetResult = await this.checkBudget(amountSmallest, "transfer:direct", "");
+        const budgetResult = await this.checkBudget(amountSmallest, "transfer:direct", targetAddress);
         if (!budgetResult.allowed)
           return `BLOCKED by budget policy: ${budgetResult.reason}`;
         const walletPath = join28(this.nexusDir, "wallet.enc");
@@ -12972,6 +13171,109 @@ process.on('SIGINT', () => process.emit('SIGTERM'));
           privKeyHex = "0".repeat(64);
         }
       }
+      // ---------------------------------------------------------------------------
+      // Step 6: Remote Inference — Route inference to remote peers on the mesh
+      // ---------------------------------------------------------------------------
+      async doRemoteInfer(args) {
+        const model = args.model;
+        const prompt = args.prompt || args.input;
+        if (!model)
+          throw new Error("model is required (e.g., 'qwen3.5:70b', 'nemotron-3-nano:30b')");
+        if (!prompt)
+          throw new Error("prompt is required");
+        const estimatedTokens = Math.ceil(prompt.length / 4) + 1e3;
+        let estimatedCostSmallest = 0;
+        const pricingPath = join28(this.nexusDir, "pricing.json");
+        if (existsSync21(pricingPath)) {
+          try {
+            const pricing = JSON.parse(await readFile13(pricingPath, "utf8"));
+            const modelPricing = (pricing.models || []).find((m) => m.model === model || m.model.startsWith(model.split(":")[0]));
+            if (modelPricing?.pricing?.input_per_1m_tokens > 0) {
+              estimatedCostSmallest = Math.ceil(estimatedTokens / 1e6 * modelPricing.pricing.input_per_1m_tokens * 1e6);
+            }
+          } catch {
+          }
+        }
+        if (estimatedCostSmallest > 0) {
+          const budgetResult = await this.checkBudget(estimatedCostSmallest, "remote_infer", args.target_peer || "");
+          if (!budgetResult.allowed) {
+            return `BLOCKED by budget policy: ${budgetResult.reason}`;
+          }
+        }
+        const budget = await this.loadBudget();
+        if (budget && !budget.allowedCapabilities.some((c3) => c3 === "remote_infer" || c3 === "inference:*" || c3 === "*")) {
+          return "BLOCKED: remote_infer not in budget allowedCapabilities. Use budget_set to allow it.";
+        }
+        const daemonArgs = {
+          model,
+          target_peer: args.target_peer,
+          temperature: args.temperature,
+          max_tokens: args.max_tokens
+        };
+        if (args.messages) {
+          daemonArgs.messages = args.messages;
+          if (args.tools)
+            daemonArgs.tools = args.tools;
+        } else {
+          daemonArgs.prompt = prompt;
+        }
+        const result = await this.sendDaemonCmd("remote_infer", daemonArgs, 12e4);
+        let peerUsed = args.target_peer || "auto-selected";
+        try {
+          const parsed = JSON.parse(result);
+          if (parsed.peer)
+            peerUsed = parsed.peer;
+          if (estimatedCostSmallest > 0) {
+            await this.appendLedger({
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "spent",
+              amount: String(estimatedCostSmallest),
+              amountUsd: (estimatedCostSmallest / 1e6).toFixed(6),
+              peer: peerUsed,
+              capability: "remote_infer:" + model,
+              note: "remote inference"
+            });
+          }
+          const inferResult = parsed.result;
+          let responseText = "";
+          if (typeof inferResult === "string") {
+            responseText = inferResult;
+          } else if (inferResult) {
+            const events = Array.isArray(inferResult) ? inferResult : [inferResult];
+            for (const evt of events) {
+              if (evt.event === "result" && evt.data) {
+                try {
+                  const data = typeof evt.data === "string" ? JSON.parse(evt.data) : evt.data;
+                  responseText = data.response || data.content || JSON.stringify(data);
+                } catch {
+                  responseText = String(evt.data);
+                }
+              }
+            }
+            if (!responseText) {
+              responseText = JSON.stringify(inferResult, null, 2);
+            }
+          }
+          const lines = [
+            `Remote inference result (${model} via ${peerUsed.slice(0, 20)}...):`,
+            ``,
+            responseText,
+            ``,
+            `--- Metadata ---`,
+            `Model: ${parsed.model || model}`,
+            `Peer: ${peerUsed}`,
+            `Capability: ${parsed.capability || "inference:" + model}`
+          ];
+          if (estimatedCostSmallest > 0) {
+            lines.push(`Estimated cost: $${(estimatedCostSmallest / 1e6).toFixed(6)} USDC`);
+          } else {
+            lines.push(`Cost: FREE (provider margin = 0)`);
+          }
+          return lines.join("\n");
+        } catch {
+          return result;
+        }
+      }
       async doInferenceProof() {
         try {
           const psRaw = execSync21("ollama ps 2>/dev/null", { timeout: 1e4, encoding: "utf8" });
@@ -17924,6 +18226,218 @@ ${transcript}`
   }
 });
 
+// packages/orchestrator/dist/nexusBackend.js
+var NexusAgenticBackend;
+var init_nexusBackend = __esm({
+  "packages/orchestrator/dist/nexusBackend.js"() {
+    "use strict";
+    NexusAgenticBackend = class {
+      sendFn;
+      model;
+      targetPeer;
+      constructor(sendFn, model, targetPeer) {
+        this.sendFn = sendFn;
+        this.model = model;
+        this.targetPeer = targetPeer || "";
+      }
+      async chatCompletion(request) {
+        const daemonArgs = {
+          model: this.model,
+          messages: JSON.stringify(request.messages),
+          tools: JSON.stringify(request.tools),
+          temperature: String(request.temperature),
+          max_tokens: String(request.maxTokens)
+        };
+        if (this.targetPeer) {
+          daemonArgs.target_peer = this.targetPeer;
+        }
+        const rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
+        let parsed;
+        try {
+          parsed = JSON.parse(rawResult);
+        } catch {
+          throw new Error(`Invalid response from nexus daemon: ${rawResult.slice(0, 200)}`);
+        }
+        if (parsed.success === false) {
+          throw new Error(`Remote inference failed: ${parsed.output || rawResult}`);
+        }
+        const invokeResult = parsed.result;
+        let responseData = null;
+        if (typeof invokeResult === "string") {
+          try {
+            responseData = JSON.parse(invokeResult);
+          } catch {
+            responseData = { response: invokeResult };
+          }
+        } else if (invokeResult) {
+          const events = Array.isArray(invokeResult) ? invokeResult : [invokeResult];
+          for (const evt of events) {
+            if (evt.event === "result" && evt.data) {
+              const evtData = evt.data;
+              try {
+                responseData = typeof evtData === "string" ? JSON.parse(evtData) : evtData;
+              } catch {
+                responseData = { response: String(evtData) };
+              }
+            }
+          }
+        }
+        if (!responseData) {
+          throw new Error("No response data from remote inference");
+        }
+        const choices = responseData.choices;
+        if (choices && Array.isArray(choices)) {
+          return {
+            choices: choices.map((c3) => {
+              const msg = c3.message || {};
+              const toolCalls = msg.tool_calls || [];
+              return {
+                message: {
+                  content: typeof msg.content === "string" ? msg.content : msg.content ?? null,
+                  toolCalls: toolCalls.length > 0 ? toolCalls.map((tc) => {
+                    const fn = tc.function || {};
+                    let args;
+                    try {
+                      args = typeof fn.arguments === "string" ? JSON.parse(fn.arguments) : fn.arguments ?? {};
+                    } catch {
+                      args = { _raw: fn.arguments };
+                    }
+                    return {
+                      id: tc.id || crypto.randomUUID(),
+                      name: fn.name,
+                      arguments: args
+                    };
+                  }) : void 0
+                }
+              };
+            }),
+            usage: this.extractUsage(responseData)
+          };
+        }
+        const content = responseData.response || JSON.stringify(responseData);
+        return {
+          choices: [{
+            message: {
+              content,
+              toolCalls: void 0
+            }
+          }],
+          usage: this.extractUsage(responseData)
+        };
+      }
+      /**
+       * Simulated streaming: calls chatCompletion() for the full response,
+       * then yields it as word-level StreamChunk objects.
+       * Gives API compatibility with the streaming path in AgenticRunner.
+       */
+      async *chatCompletionStream(request) {
+        const response = await this.chatCompletion(request);
+        const choice = response.choices[0];
+        if (!choice)
+          return;
+        const msg = choice.message;
+        if (msg.content) {
+          const words = msg.content.split(/(\s+)/);
+          for (const word of words) {
+            if (word) {
+              yield { type: "content", content: word };
+            }
+          }
+        }
+        if (msg.toolCalls) {
+          for (let i = 0; i < msg.toolCalls.length; i++) {
+            const tc = msg.toolCalls[i];
+            yield {
+              type: "tool_call_delta",
+              toolCallIndex: i,
+              toolCallId: tc.id,
+              toolCallName: tc.name,
+              toolCallArgs: JSON.stringify(tc.arguments)
+            };
+          }
+        }
+        if (response.usage) {
+          yield {
+            type: "usage",
+            usage: {
+              promptTokens: response.usage.promptTokens ?? 0,
+              completionTokens: response.usage.completionTokens ?? 0,
+              totalTokens: response.usage.totalTokens
+            }
+          };
+        }
+        yield { type: "finish", finishReason: "stop" };
+      }
+      extractUsage(data) {
+        const usage = data.usage;
+        if (!usage)
+          return void 0;
+        const inputTokens = usage.input_tokens || usage.prompt_tokens || 0;
+        const outputTokens = usage.output_tokens || usage.completion_tokens || 0;
+        return {
+          totalTokens: inputTokens + outputTokens,
+          promptTokens: inputTokens,
+          completionTokens: outputTokens
+        };
+      }
+    };
+  }
+});
+
+// packages/orchestrator/dist/flowstatePrompt.js
+var FLOWSTATE_PROMPT;
+var init_flowstatePrompt = __esm({
+  "packages/orchestrator/dist/flowstatePrompt.js"() {
+    "use strict";
+    FLOWSTATE_PROMPT = `## FlowState Protocol (Active)
+
+You are operating in FlowState mode. Apply this protocol to every task:
+
+### Pre-Task (Engage)
+- Clear context of noise \u2014 compact if SNR is degraded
+- Set ridiculously specific sub-goals (not "fix things" but "change line 47 of auth.ts to check for null")
+- Begin immediately \u2014 first tool call in first response (response inhibition)
+- Identify the first concrete action before reasoning further
+
+### During Task (Struggle -> Release -> Flow)
+- Execute the highest-impact action first (goal-directedness)
+- Maintain tight feedback loops: execute, verify, learn (immediate feedback)
+- Calibrate task complexity: chunk if overwhelming, compress if trivial (challenge-skill balance)
+- Rotate approaches when stuck: different tools, different angles (oasis effect)
+- Minimize context pollution: archive large outputs, compact when needed (minimalism)
+- Never research when you can act; never read when you can execute
+- Track your own token allocation: maximize flow-tokens (core reasoning), minimize junk-tokens (unnecessary elaboration)
+
+### Between Tasks (Recovery)
+- Compact context aggressively (active recovery, not passive degradation)
+- Update persistent memory with learnings (consolidation)
+- Clear the todo list \u2014 identify next highest-impact action (power-down ritual)
+- Assess context quality and improve if degraded
+
+### Flowstate Checklist (verify before each major action)
+- [ ] Is the goal ridiculously clear? (specific file, line, change \u2014 not vague intent)
+- [ ] Is context clean? (no irrelevant history cluttering working memory)
+- [ ] Is the first action identified? (a specific tool call, not more research)
+- [ ] Is the feedback loop tight? (verification command defined before making changes)
+- [ ] Is recovery planned? (compaction strategy selected for after task)
+
+### The Diagnostic Compass (when stuck)
+| Symptom | Variable | Fix |
+|---|---|---|
+| Working on the wrong thing | Goal-Directedness | Re-target. Find the most direct path. |
+| Underleveraged | Leverage | Parallelize. Use sub-agents. Build reusable systems. |
+| Distracted, fractured, unable to sustain depth | Flow | Remove friction. Reduce cognitive load. Create immersion. |
+
+### Peak Performance Equation
+Peak Performance = Goal-Directedness x Leverage x Flow
+(These MULTIPLY \u2014 a zero in any one collapses the entire equation)
+
+### Mantra
+Flow follows focus. Focus follows clarity. Clarity follows constraint.
+Constrain your context. Clarify your target. Focus your tools. Flow will follow.`;
+  }
+});
+
 // packages/orchestrator/dist/costTracker.js
 var DEFAULT_PRICING, CostTracker;
 var init_costTracker = __esm({
@@ -18403,6 +18917,8 @@ var init_dist5 = __esm({
     init_mergeRunner();
     init_retryController();
     init_agenticRunner();
+    init_nexusBackend();
+    init_flowstatePrompt();
     init_costTracker();
     init_workEvaluator();
     init_sessionMetrics();
@@ -23256,6 +23772,7 @@ function renderSlashHelp() {
     ["/compact <strategy>", "Compact with strategy: aggressive, decisions, errors, summary, structured"],
     ["/bruteforce", "Toggle brute-force mode (auto re-engage on turn limit)"],
     ["/deep", "Toggle deep context \u2014 relaxes compaction so large models use 85% of context"],
+    ["/flow", "Toggle FlowState protocol \u2014 immediate action, tight loops, goal clarity"],
     ["/tools", "List agent-created custom tools"],
     ["/skills", "List available AIWG skills"],
     ["/skills <keyword>", "Filter skills by name or trigger"],
@@ -28968,6 +29485,18 @@ async function handleSlashCommand(input, ctx) {
       renderInfo(`Deep context mode: ${isOn ? "ON" : "OFF"}${hasLocal ? " (project-local)" : ""}` + (isOn ? " \u2014 compaction relaxed to 85% of context window. Large models will retain more working memory for complex reasoning." : " \u2014 compaction restored to default thresholds."));
       return "handled";
     }
+    case "flow":
+    case "flowstate": {
+      if (!ctx.flowToggle) {
+        renderWarning("FlowState not available");
+        return "handled";
+      }
+      const isFlowOn = ctx.flowToggle();
+      const flowSave = hasLocal ? ctx.saveLocalSettings.bind(ctx) : ctx.saveSettings.bind(ctx);
+      flowSave({ flow: isFlowOn });
+      renderInfo(`FlowState protocol: ${isFlowOn ? "ON" : "OFF"}${hasLocal ? " (project-local)" : ""}` + (isFlowOn ? " \u2014 agent will follow FlowState protocol: immediate action, tight feedback loops, goal clarity, challenge-skill calibration." : " \u2014 standard agent behavior restored."));
+      return "handled";
+    }
     case "emojis":
     case "emoji": {
       const current = ctx.getEmojis?.() ?? true;
@@ -39069,7 +39598,13 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
       if (!task) {
         return { success: false, output: "", error: "task is required" };
       }
-      const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+      let backend;
+      if (config.backendType === "nexus") {
+        const nexusTool = new NexusTool(repoRoot);
+        backend = new NexusAgenticBackend(nexusTool.sendCommand.bind(nexusTool), config.model);
+      } else {
+        backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+      }
       const subCtxWindow = ctxWindowSize ?? 0;
       const subTier = getModelTier(config.model);
       const subCompaction = subTier === "small" ? 12e3 : subTier === "medium" ? 24e3 : 4e4;
@@ -39206,7 +39741,7 @@ function formatDMNToolArgs(toolName, args) {
       return "";
   }
 }
-function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction, emotionEngine) {
+function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction, emotionEngine, flowEnabled) {
   const voiceStyleMap = {
     concise: 1,
     balanced: 3,
@@ -39220,7 +39755,17 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   if (taskType && modelTier !== "small") {
     dynamicContext += "\n\n" + buildTaskContext(taskType);
   }
-  const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+  if (flowEnabled) {
+    dynamicContext += "\n\n" + FLOWSTATE_PROMPT;
+  }
+  let backend;
+  if (config.backendType === "nexus") {
+    const nexusTool = new NexusTool(repoRoot);
+    const sendFn = nexusTool.sendCommand.bind(nexusTool);
+    backend = new NexusAgenticBackend(sendFn, config.model);
+  } else {
+    backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
+  }
   const compactionThreshold = modelTier === "small" ? 12e3 : modelTier === "medium" ? 24e3 : 4e4;
   const runner = new AgenticRunner(backend, {
     maxTurns: 60,
@@ -39611,6 +40156,7 @@ async function startInteractive(config, repoPath) {
   let bruteForceEnabled = savedSettings.bruteforce ?? true;
   let currentStyle = PRESET_NAMES.includes(savedSettings.style) ? savedSettings.style : "balanced";
   let deepContextEnabled = savedSettings.deepContext ?? false;
+  let flowEnabled = savedSettings.flow === true;
   if (savedSettings.emojis !== void 0)
     setEmojisEnabled(savedSettings.emojis);
   if (savedSettings.colors !== void 0)
@@ -40143,6 +40689,10 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       deepContextEnabled = !deepContextEnabled;
       return deepContextEnabled;
     },
+    flowToggle() {
+      flowEnabled = !flowEnabled;
+      return flowEnabled;
+    },
     setStyle(preset) {
       currentStyle = preset;
     },
@@ -41116,7 +41666,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
           }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary, meta) => {
             lastCompletedSummary = summary;
             lastTaskMeta = meta ?? null;
-          }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine);
+          }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine, flowEnabled);
           activeTask = task;
           showPrompt();
           await task.promise;
@@ -41333,7 +41883,7 @@ NEW TASK: ${fullInput}`;
       }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary, meta) => {
         lastCompletedSummary = summary;
         lastTaskMeta = meta ?? null;
-      }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine);
+      }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine, flowEnabled);
       activeTask = task;
       showPrompt();
       await task.promise;
@@ -42432,6 +42982,10 @@ async function evalCommand(opts, config) {
   const evalRepoRoot = opts.repoPath ?? createTempEvalRepo();
   let rawBackend;
   if (useLive) {
+    if (config.backendType === "nexus") {
+      printError("Nexus backend is not supported for eval. Use --backend ollama or --backend vllm.");
+      process.exit(1);
+    }
     rawBackend = createBackend({
       type: config.backendType,
       model: config.model,

package/package.json

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

@@ -288,12 +288,30 @@ Signs an EIP-3009 TransferWithAuthorization for USDC on Base. Budget-checked bef
 The signed proof is saved to `.oa/nexus/pending-transfer.json` — anyone can submit it on-chain
 via `USDC.transferWithAuthorization()`. No gas needed from the payer.
 
+### Remote Inference — `nexus(action='remote_infer', model='...', prompt='...')`
+
+Route a prompt to a remote peer's model on the P2P mesh. The action auto-discovers peers
+that have the requested model exposed, budget-checks the estimated cost, invokes the
+inference capability, and returns the response text.
+
+**Parameters**:
+- `model` (required) — model name the provider is running (e.g., `qwen3.5:70b`, `nemotron-3-nano:30b`)
+- `prompt` (required) — the text prompt to send
+- `target_peer` (optional) — specific peer ID; if omitted, auto-selects the first peer with the model
+- `temperature` (optional) — sampling temperature (default: 0.7)
+- `max_tokens` (optional) — max tokens to generate (default: 4096)
+
+**When to use**: When a task needs a larger/different model than what's available locally,
+or when you want to offload inference to a remote GPU. The provider must be connected to
+the mesh and have run `expose` to advertise their models.
+
 ### x402 Flow Summary
 1. wallet_create → generates wallet + x402-wallet.key (plaintext, 0600, for daemon)
 2. expose with margin > 0 → registers capabilities with USDC pricing
 3. Peers invoke_capability → daemon auto-handles payment_required/payment_proof
 4. Metering hook writes payment events to ledger.jsonl
 5. spend → sign direct USDC transfers (EIP-3009)
+6. remote_infer → auto-discover peer + invoke inference + budget check + ledger entry
 
 SECURITY: Wallet private keys are AES-256-GCM encrypted and NEVER accessible to you.
 x402-wallet.key is 0600-permissioned for daemon use only. All outbound messages are scanned