open-agents-ai 0.103.36 → 0.103.38

package/README.md

@@ -72,7 +72,8 @@ The agent uses tools autonomously in a loop — reading errors, fixing code, and
 - **Task templates** — specialized system prompts and tool recommendations for code, document, analysis, plan tasks
 - **Inference capability scoring** — canirun.ai-style hardware assessment at first launch: memory/compute/speed scores, per-model compatibility matrix, recommended model selection
 - **Auto-install everything** — first-run wizard auto-installs Ollama, curl, Python3, python3-venv with platform-aware package managers (apt, dnf, yum, pacman, apk, zypper, brew)
-- **P2P inference network** — `/p2p` mesh networking with secret-safe variable placeholders (`{{OA_VAR_*}}`), trust tiers (LOCAL/TEE/VERIFIED/PUBLIC), WebSocket peer mesh, and inference routing with automatic secret redaction/injection
+- **P2P inference network** — `/expose` local models or forward any `/endpoint` (Chutes, Groq, OpenRouter, etc.) through the libp2p P2P mesh. Passthrough mode (`/expose passthrough`) relays upstream API requests; `--loadbalance` distributes rate-limited token budgets across peers. `/expose config` provides an arrow-key menu for all settings. Gateway stats show budget remaining from `x-ratelimit-*` headers. Background daemon persists across OA restarts
+- **P2P mesh networking** — `/p2p` with secret-safe variable placeholders (`{{OA_VAR_*}}`), trust tiers (LOCAL/TEE/VERIFIED/PUBLIC), WebSocket peer mesh, and inference routing with automatic secret redaction/injection
 - **Secret vault** — `/secrets` manages API keys and credentials with AES-256-GCM encrypted persistence; secrets are automatically redacted before sending to untrusted inference peers and re-injected on response
 - **Auto-expanding context** — detects RAM/VRAM and creates an optimized model variant on first run
 - **Mid-task steering** — type while the agent works to add context without interrupting
@@ -277,7 +278,7 @@ On startup and `/model` switch, Open Agents detects your RAM/VRAM and creates an
 | `aiwg_workflow` | Execute AIWG commands and workflows |
 | **Nexus P2P & x402 Payments** | |
 | `nexus` | Decentralized agent networking — connect, rooms, DMs, peer discovery, invoke capabilities, metering, trust/blocking, IPFS storage |
-| `nexus:expose` | Expose local Ollama models as metered inference capabilities with OpenRouter-based pricing |
+| `nexus:expose` | Expose local models or forward upstream endpoints as metered inference capabilities with pricing, passthrough, and load balancing |
 | `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 |
@@ -956,8 +957,12 @@ The TUI features an animated multilingual phrase carousel, live metrics bar with
 | `/expose ollama` | Expose local inference via libp2p (default) |
 | `/expose ollama --tunnel` | Expose via cloudflared tunnel |
 | `/expose ollama --full` | Allow full Ollama API access (pull/delete) |
-| `/expose stop` | Stop the expose gateway |
-| `/expose status` | Show expose usage stats |
+| `/expose passthrough` | Forward configured `/endpoint` through libp2p P2P |
+| `/expose forward --loadbalance` | Passthrough with distributed rate-limit budget |
+| `/expose config` | Interactive expose configuration menu (arrow-key nav) |
+| `/expose stop` | Stop all expose gateways |
+| `/expose stop --libp2p` | Stop libp2p gateway only |
+| `/expose status` | Show expose usage stats + budget |
 | **Metrics & Updates** | |
 | `/cost` | Show token cost breakdown for the current session |
 | `/score` | Show inference capability scorecard (memory, compute, speed, model compatibility) |
@@ -1526,6 +1531,86 @@ Expose your local Ollama models to the decentralized nexus network, or consume a
 
 Transport: DHT + mDNS + NATS relay + circuit relay. Auth key is auto-generated and required for all requests. System metrics (CPU/GPU/memory) are available to consumers via the `system_metrics` capability. Without `--full`, destructive Ollama API endpoints (`/api/pull`, `/api/delete`, `/api/create`) are blocked.
 
+#### Passthrough & Forward Mode
+
+Forward any configured `/endpoint` (Chutes, Groq, OpenRouter, Together, vLLM, etc.) through the libp2p P2P network. Your node becomes a relay — peers connect to you via libp2p and you forward their requests to your upstream API:
+
+```bash
+# Set your upstream endpoint first
+/endpoint https://llm.chutes.ai --auth cpk_your_key_here
+
+# Expose it through P2P — peers discover and invoke via libp2p
+/expose passthrough
+# or equivalently:
+/expose forward
+
+# With load balancing: distributes daily token budget across peers
+/expose passthrough --loadbalance
+```
+
+**How it works:**
+- Your node registers inference capabilities on the P2P mesh using your upstream endpoint's models
+- Remote peers discover and invoke these capabilities via libp2p streams (DHT/mDNS/NATS)
+- Requests are forwarded to your upstream API, responses streamed back to the peer
+- The libp2p daemon persists in the background — it survives OA restarts and remains discoverable even when the TUI is closed
+- When you reopen OA, it reconnects to the existing daemon and resumes stats tracking
+
+**Rate limit distribution (`--loadbalance`):**
+- Captures `x-ratelimit-remaining-tokens` and `x-ratelimit-limit-tokens` headers from upstream API responses
+- Displays remaining token budget in the gateway stats under "Budget"
+- Distributes the total daily token budget across connected peers proportionally
+- Prevents any single peer from exhausting the shared budget
+
+#### Budget & Rate Limit Monitoring
+
+When exposing an upstream endpoint that returns rate-limit headers (most cloud providers do), the gateway stats automatically track your remaining budget:
+
+```
+  Expose Gateway Stats (libp2p passthrough)
+  Status             active
+  Transport          libp2p (passthrough)
+  Peer ID            12D3KooWSzC75QX...
+  Uptime             2h 15m
+  Total requests     847
+  Tokens in          125.4K
+  Tokens out         892.1K
+  Budget             1.2M/10M (12% left)
+
+  Models
+  qwen3.5-4b                    412 reqs  in:52.3K out:401.2K
+  qwen3.5-9b                    435 reqs  in:73.1K out:490.9K
+
+  Active Peers (3)
+  12D3KooWSwaCi1Jg...
+    Session: 1h 45m  Last seen: now  Requests: 523
+    Tokens: in:82.1K out:612.4K
+    · qwen3.5-4b 312req 401.2Ktok
+    · qwen3.5-9b 211req 293.3Ktok
+  12D3KooWKnCgxx7D...
+    Session: 45m  Last seen: 2m ago  Requests: 324
+    Tokens: in:43.3K out:279.7K
+    · qwen3.5-9b 224req 197.6Ktok
+```
+
+Internal capabilities (`system_metrics`, `__list_capabilities`) are hidden from all displays — both the full stats view and the compact status bar one-liner.
+
+#### `/expose config` — Interactive Configuration
+
+Arrow-key navigable menu for all expose settings:
+
+```bash
+/expose config
+```
+
+Shows options to:
+- View current stats
+- Stop all gateways
+- Start Ollama (libp2p or tunnel)
+- Start passthrough (with or without load balancing)
+- Start vLLM
+
+Uses the same arrow-key navigation pattern as `/model` and `/endpoint` selection.
+
 ### Endpoint Cascade Failover
 
 When you've used multiple endpoints, the agent automatically builds a failover cascade. If the primary endpoint fails with transient errors (502, connection refused, timeout), it transparently switches to the next endpoint that has the same model — then periodically probes the primary to return when it recovers:

package/dist/index.js

@@ -12607,30 +12607,74 @@ async function handleCmd(cmd) {
           dlog('expose: auth key configured (' + exposeAuthKey.length + ' chars)');
         }
 
-        // Query Ollama for available models
+        // Passthrough mode: forward from a remote /endpoint (Chutes, Groq, etc.)
+        var isPassthrough = args.passthrough === 'true';
+        var endpointAuth = args.endpoint_auth || '';
+        if (isPassthrough) {
+          dlog('expose: PASSTHROUGH mode \u2014 forwarding from upstream endpoint');
+        }
+
+        // Query models from the backend
         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 || '',
-            }));
+
+        if (isPassthrough) {
+          // Passthrough: query /v1/models from the upstream endpoint (OpenAI-compatible)
+          try {
+            var modelsHeaders = { 'Content-Type': 'application/json' };
+            if (endpointAuth) modelsHeaders['Authorization'] = 'Bearer ' + endpointAuth;
+            var modelsUrl = ollamaUrl.replace(/\\/+$/, '') + '/v1/models';
+            dlog('expose: passthrough querying models from ' + modelsUrl);
+            const modelsResp = await fetch(modelsUrl, { headers: modelsHeaders });
+            if (modelsResp.ok) {
+              const modelsData = await modelsResp.json();
+              var modelList = modelsData.data || modelsData.models || [];
+              models = modelList.map(function(m) {
+                return {
+                  name: m.id || m.name || 'unknown',
+                  size: 0,
+                  parameterSize: '',
+                  family: m.owned_by || '',
+                  quantization: '',
+                };
+              });
+            } else {
+              var errText = '';
+              try { errText = await modelsResp.text(); } catch {}
+              writeResp(id, { ok: false, output: 'Upstream /v1/models returned ' + modelsResp.status + ': ' + errText.slice(0, 200) });
+              return;
+            }
+          } catch (e) {
+            writeResp(id, { ok: false, output: 'Cannot reach upstream endpoint at ' + ollamaUrl + ': ' + e.message });
+            return;
+          }
+        } else {
+          // Local Ollama: query /api/tags
+          try {
+            const tagsResp = await fetch(ollamaUrl + '/api/tags');
+            if (tagsResp.ok) {
+              const tagsData = await tagsResp.json();
+              models = (tagsData.models || []).map(function(m) {
+                return {
+                  name: m.name,
+                  size: m.size || 0,
+                  parameterSize: m.details ? m.details.parameter_size || '' : '',
+                  family: m.details ? m.details.family || '' : '',
+                  quantization: m.details ? m.details.quantization_level || '' : '',
+                };
+              });
+            }
+          } catch (e) {
+            writeResp(id, { ok: false, output: 'Cannot reach Ollama at ' + ollamaUrl + ': ' + e.message });
+            return;
           }
-        } 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.' });
+          writeResp(id, { ok: false, output: isPassthrough ? 'No models found on upstream endpoint.' : 'No models found on Ollama. Pull a model first.' });
           return;
         }
+        dlog('expose: found ' + models.length + ' models' + (isPassthrough ? ' (passthrough)' : ''));
 
         // Fetch market rates from OpenRouter (free, no auth)
         let marketRates = {};
@@ -12782,10 +12826,12 @@ async function handleCmd(cmd) {
                   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));
+                  var chatHeaders = { 'Content-Type': 'application/json' };
+                  if (isPassthrough && endpointAuth) chatHeaders['Authorization'] = 'Bearer ' + endpointAuth;
+                  dlog('expose: calling /v1/chat/completions with ' + chatBody.messages.length + ' messages, tools=' + (chatBody.tools ? chatBody.tools.length : 0) + (isPassthrough ? ' (passthrough)' : ''));
                   genResp = await fetch(ollamaUrl + '/v1/chat/completions', {
                     method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
+                    headers: chatHeaders,
                     body: JSON.stringify(chatBody),
                   });
                   genData = await genResp.json();
@@ -12816,8 +12862,36 @@ async function handleCmd(cmd) {
                     usage: { input_tokens: inputTokens, output_tokens: outputTokens },
                     pricing: entry.pricing,
                   };
+                } else if (isPassthrough) {
+                  // Passthrough flat prompt \u2014 convert to /v1/chat/completions (upstream has no /api/generate)
+                  var flatPrompt = parsedReq && parsedReq.prompt ? parsedReq.prompt : (prompt || 'Hello');
+                  var ptHeaders = { 'Content-Type': 'application/json' };
+                  if (endpointAuth) ptHeaders['Authorization'] = 'Bearer ' + endpointAuth;
+                  genResp = await fetch(ollamaUrl + '/v1/chat/completions', {
+                    method: 'POST',
+                    headers: ptHeaders,
+                    body: JSON.stringify({
+                      model: model.name,
+                      messages: [{ role: 'user', content: flatPrompt }],
+                      stream: false,
+                    }),
+                  });
+                  genData = await genResp.json();
+                  var ptChoices = genData.choices || [];
+                  var ptMsg = (ptChoices[0] || {}).message || {};
+                  output = (ptMsg.content || '').replace(/<think>[\\s\\S]*?<\\/think>/g, '').trim();
+                  inputTokens = (genData.usage || {}).prompt_tokens || 0;
+                  outputTokens = (genData.usage || {}).completion_tokens || 0;
+
+                  responsePayload = {
+                    model: model.name,
+                    response: output,
+                    choices: ptChoices,
+                    usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                    pricing: entry.pricing,
+                  };
                 } else {
-                  // Flat prompt \u2014 use /api/generate (original behavior)
+                  // Flat prompt \u2014 use /api/generate (local Ollama)
                   var flatPrompt = parsedReq && parsedReq.prompt ? parsedReq.prompt : (prompt || 'Hello');
                   genResp = await fetch(ollamaUrl + '/api/generate', {
                     method: 'POST',
@@ -26371,10 +26445,15 @@ function renderSlashHelp() {
     ["/nexus", "Show nexus P2P network status (or connect/disconnect/rooms)"],
     ["/nexus connect", "Connect to the agent mesh network"],
     ["/nexus wallet", "Show wallet address and x402 payment status"],
-    ["/expose <backend>", "Share local inference via cloudflared tunnel"],
-    ["/expose <backend> --key", "Share with auto-generated auth key"],
-    ["/expose status", "Show gateway stats (requests, models, errors)"],
-    ["/expose stop", "Stop the expose gateway"],
+    ["/expose <backend>", "Expose local inference via libp2p (default)"],
+    ["/expose <backend> --tunnel", "Expose via cloudflared tunnel"],
+    ["/expose passthrough", "Forward configured /endpoint through libp2p P2P"],
+    ["/expose forward --loadbalance", "Passthrough with distributed rate-limit budget"],
+    ["/expose config", "Interactive expose configuration menu"],
+    ["/expose status", "Show gateway stats (requests, models, budget)"],
+    ["/expose stop", "Stop all expose gateways"],
+    ["/expose stop --tunnel", "Stop tunnel gateway only"],
+    ["/expose stop --libp2p", "Stop libp2p gateway only"],
     ["/p2p start", "Join the P2P agent mesh network"],
     ["/p2p status", "Show mesh peers and rooms"],
     ["/p2p stop", "Leave the mesh network"],
@@ -28353,6 +28432,7 @@ ${this.formatConnectionInfo()}`);
       _margin;
       _passthrough = false;
       _loadbalance = false;
+      _endpointAuth;
       _pollTimer = null;
       _stats = {
         status: "standby",
@@ -28397,6 +28477,7 @@ ${this.formatConnectionInfo()}`);
         this._margin = options.margin ?? 0.5;
         this._passthrough = options.passthrough ?? false;
         this._loadbalance = options.loadbalance ?? false;
+        this._endpointAuth = options.endpointAuth;
         this._onInfo = options.onInfo;
         this._onError = options.onError;
         if (options.authKey === void 0 || options.authKey === "") {
@@ -28416,21 +28497,23 @@ ${this.formatConnectionInfo()}`);
           throw new Error(`Nexus daemon connect failed: ${connectResult.error}`);
         }
         await new Promise((r) => setTimeout(r, 500));
-        this._onInfo?.("Registering inference capabilities...");
-        let exposeResult = await this._nexusTool.execute({
+        this._onInfo?.(this._passthrough ? `Registering passthrough capabilities (\u2192 ${this._targetUrl})...` : "Registering inference capabilities...");
+        const exposeArgs = {
           action: "expose",
           ollama_url: this._targetUrl,
           margin: String(this._margin),
           auth_key: this._authKey
-        });
+        };
+        if (this._passthrough) {
+          exposeArgs.passthrough = "true";
+          if (this._endpointAuth) {
+            exposeArgs.endpoint_auth = this._endpointAuth;
+          }
+        }
+        let exposeResult = await this._nexusTool.execute(exposeArgs);
         if (!exposeResult.success && exposeResult.error?.includes("not running")) {
           await new Promise((r) => setTimeout(r, 1500));
-          exposeResult = await this._nexusTool.execute({
-            action: "expose",
-            ollama_url: this._targetUrl,
-            margin: String(this._margin),
-            auth_key: this._authKey
-          });
+          exposeResult = await this._nexusTool.execute(exposeArgs);
         }
         if (!exposeResult.success) {
           throw new Error(`Expose failed: ${exposeResult.error}`);
@@ -46912,6 +46995,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           stateDir: join50(repoRoot, ".oa"),
           passthrough: passthrough ?? false,
           loadbalance: loadbalance ?? false,
+          endpointAuth: passthrough ? config.apiKey : void 0,
           onInfo: (msg) => {
             exposeSpinnerMsg = msg;
           },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.36",
+  "version": "0.103.38",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",