open-agents-ai 0.103.35 → 0.103.37

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

@@ -26371,10 +26371,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"],
@@ -27527,6 +27532,33 @@ function isProcessAlive(pid) {
     return false;
   }
 }
+function parseRateLimitHeaders(headers) {
+  const get = (name) => {
+    const v = headers[name] ?? headers[name.toLowerCase()];
+    return typeof v === "string" ? v : Array.isArray(v) ? v[0] : void 0;
+  };
+  const remaining = parseInt(get("x-ratelimit-remaining-tokens") ?? get("x-ratelimit-remaining") ?? "", 10);
+  const total = parseInt(get("x-ratelimit-limit-tokens") ?? get("x-ratelimit-limit") ?? "", 10);
+  const resetRaw = get("x-ratelimit-reset-tokens") ?? get("x-ratelimit-reset") ?? "";
+  let resetAt = 0;
+  if (resetRaw) {
+    const n = Number(resetRaw);
+    if (!isNaN(n)) {
+      resetAt = n < 1e12 ? n * 1e3 : n;
+    } else {
+      const d = new Date(resetRaw).getTime();
+      if (!isNaN(d))
+        resetAt = d;
+    }
+  }
+  if (isNaN(remaining) && isNaN(total))
+    return null;
+  return {
+    remaining: isNaN(remaining) ? 0 : remaining,
+    total: isNaN(total) ? 0 : total,
+    resetAt
+  };
+}
 async function collectSystemMetricsAsync() {
   const [l1, l5, l15] = loadavg();
   const cores = cpus().length;
@@ -27602,7 +27634,7 @@ function removeP2PExposeState(stateDir) {
   } catch {
   }
 }
-var HOP_BY_HOP_HEADERS, CF_HEADERS_PREFIX, DEFAULT_TARGETS, STATE_FILE_NAME, ExposeGateway, P2P_STATE_FILE_NAME, ExposeP2PGateway;
+var HOP_BY_HOP_HEADERS, CF_HEADERS_PREFIX, INTERNAL_CAPABILITIES, DEFAULT_TARGETS, STATE_FILE_NAME, ExposeGateway, P2P_STATE_FILE_NAME, ExposeP2PGateway;
 var init_expose = __esm({
   "packages/cli/dist/tui/expose.js"() {
     "use strict";
@@ -27618,6 +27650,7 @@ var init_expose = __esm({
       "upgrade"
     ]);
     CF_HEADERS_PREFIX = ["cf-", "cdn-"];
+    INTERNAL_CAPABILITIES = /* @__PURE__ */ new Set(["system_metrics", "__list_capabilities"]);
     DEFAULT_TARGETS = {
       ollama: "http://127.0.0.1:11434",
       vllm: "http://127.0.0.1:8000",
@@ -27648,7 +27681,10 @@ var init_expose = __esm({
         totalTokensOut: 0,
         startedAt: Date.now(),
         modelUsage: /* @__PURE__ */ new Map(),
-        users: /* @__PURE__ */ new Map()
+        users: /* @__PURE__ */ new Map(),
+        budgetTokensRemaining: 0,
+        budgetTokensTotal: 0,
+        budgetResetAt: 0
       };
       get tunnelUrl() {
         return this._tunnelUrl;
@@ -27995,6 +28031,13 @@ var init_expose = __esm({
               headers: forwardHeaders
             }, (proxyRes) => {
               cleanupHeartbeat();
+              const rlHeaders = proxyRes.headers;
+              const rl = parseRateLimitHeaders(rlHeaders);
+              if (rl && (rl.total > 0 || rl.remaining > 0)) {
+                this._stats.budgetTokensRemaining = rl.remaining;
+                this._stats.budgetTokensTotal = rl.total;
+                this._stats.budgetResetAt = rl.resetAt;
+              }
               proxyRes.on("error", () => {
                 finalizeRequest();
               });
@@ -28250,10 +28293,16 @@ ${this.formatConnectionInfo()}`);
         lines.push(`  ${c2.cyan("Errors".padEnd(18))} ${s.errors}`);
         lines.push(`  ${c2.cyan("Tokens in".padEnd(18))} ${fmtTokens(s.totalTokensIn)}`);
         lines.push(`  ${c2.cyan("Tokens out".padEnd(18))} ${fmtTokens(s.totalTokensOut)}`);
-        if (s.modelUsage.size > 0) {
+        if (s.budgetTokensTotal > 0) {
+          const pct = Math.round(s.budgetTokensRemaining / s.budgetTokensTotal * 100);
+          const budgetColor = pct > 50 ? c2.green : pct > 20 ? c2.yellow : c2.red;
+          lines.push(`  ${c2.cyan("Budget".padEnd(18))} ${budgetColor(fmtTokens(s.budgetTokensRemaining))}${c2.dim("/")}${fmtTokens(s.budgetTokensTotal)} ${c2.dim(`(${pct}% left)`)}`);
+        }
+        const visibleModels = Array.from(s.modelUsage.entries()).filter(([model]) => !INTERNAL_CAPABILITIES.has(model));
+        if (visibleModels.length > 0) {
           lines.push("");
           lines.push(`  ${c2.bold("Models")}`);
-          for (const [model, count] of s.modelUsage) {
+          for (const [model, count] of visibleModels) {
             let mIn = 0, mOut = 0;
             for (const user of s.users.values()) {
               const mm = user.models.get(model);
@@ -28277,17 +28326,23 @@ ${this.formatConnectionInfo()}`);
             lines.push(`  ${c2.bold(user.ip)}${activeTag}`);
             lines.push(`    ${c2.dim("Session:")} ${ageStr}  ${c2.dim("Last seen:")} ${lastStr}  ${c2.dim("Requests:")} ${user.requests}`);
             lines.push(`    ${c2.dim("Tokens:")} in:${fmtTokens(user.tokensIn)} out:${fmtTokens(user.tokensOut)}  ${c2.dim("Total:")} ${fmtTokens(user.tokensIn + user.tokensOut)}`);
-            if (user.models.size > 0) {
-              const modelParts = [];
-              for (const [m, mm] of user.models) {
-                modelParts.push(`${m} (${mm.requests} reqs, ${fmtTokens(mm.tokensIn + mm.tokensOut)} tokens)`);
+            const userModels = Array.from(user.models.entries()).filter(([m]) => !INTERNAL_CAPABILITIES.has(m));
+            if (userModels.length > 0) {
+              for (const [m, mm] of userModels) {
+                lines.push(`    ${c2.dim("\xB7")} ${c2.cyan(m)} ${c2.dim(`${mm.requests}req ${fmtTokens(mm.tokensIn + mm.tokensOut)}tok`)}`);
               }
-              lines.push(`    ${c2.dim("Models:")} ${modelParts.join(", ")}`);
             }
           }
         }
         return lines.join("\n");
       }
+      /** Update budget from rate limit headers */
+      updateBudget(remaining, total, resetAt) {
+        this._stats.budgetTokensRemaining = remaining;
+        this._stats.budgetTokensTotal = total;
+        this._stats.budgetResetAt = resetAt;
+        this.emitStats();
+      }
     };
     P2P_STATE_FILE_NAME = "expose-p2p-state.json";
     ExposeP2PGateway = class _ExposeP2PGateway extends EventEmitter3 {
@@ -28301,6 +28356,8 @@ ${this.formatConnectionInfo()}`);
       _exposedModels = 0;
       _stateDir;
       _margin;
+      _passthrough = false;
+      _loadbalance = false;
       _pollTimer = null;
       _stats = {
         status: "standby",
@@ -28311,7 +28368,10 @@ ${this.formatConnectionInfo()}`);
         totalTokensOut: 0,
         startedAt: Date.now(),
         modelUsage: /* @__PURE__ */ new Map(),
-        users: /* @__PURE__ */ new Map()
+        users: /* @__PURE__ */ new Map(),
+        budgetTokensRemaining: 0,
+        budgetTokensTotal: 0,
+        budgetResetAt: 0
       };
       get peerId() {
         return this._peerId;
@@ -28340,6 +28400,8 @@ ${this.formatConnectionInfo()}`);
         this._targetUrl = options.targetUrl ?? DEFAULT_TARGETS[options.kind];
         this._stateDir = options.stateDir ?? null;
         this._margin = options.margin ?? 0.5;
+        this._passthrough = options.passthrough ?? false;
+        this._loadbalance = options.loadbalance ?? false;
         this._onInfo = options.onInfo;
         this._onError = options.onError;
         if (options.authKey === void 0 || options.authKey === "") {
@@ -28406,6 +28468,8 @@ ${this.formatConnectionInfo()}`);
             kind: this._kind,
             targetUrl: this._targetUrl,
             margin: this._margin,
+            passthrough: this._passthrough || void 0,
+            loadbalance: this._loadbalance || void 0,
             startedAt: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
@@ -28456,6 +28520,8 @@ ${this.formatConnectionInfo()}`);
           authKey: state.authKey,
           stateDir,
           margin: state.margin,
+          passthrough: state.passthrough,
+          loadbalance: state.loadbalance,
           ...options
         }, nexusTool);
         gateway._peerId = state.peerId;
@@ -28575,8 +28641,9 @@ ${this.formatConnectionInfo()}`);
       formatConnectionInfo() {
         const endpointCmd = `/endpoint ${this._peerId ?? "<peer-id>"} --auth ${this._authKey}`;
         const lines = [];
-        lines.push(`  ${c2.green("\u25CF")} Expose gateway active ${c2.dim("(libp2p)")}`);
-        lines.push(`  ${c2.cyan("Backend".padEnd(12))} ${this._kind} (${this._targetUrl})`);
+        const modeLabel = this._passthrough ? "libp2p passthrough" : "libp2p";
+        lines.push(`  ${c2.green("\u25CF")} Expose gateway active ${c2.dim(`(${modeLabel})`)}`);
+        lines.push(`  ${c2.cyan("Backend".padEnd(12))} ${this._passthrough ? "passthrough" : this._kind} (${this._targetUrl})`);
         lines.push(`  ${c2.cyan("Transport".padEnd(12))} ${c2.bold("libp2p")} (DHT + mDNS + NATS relay)`);
         lines.push(`  ${c2.cyan("Peer ID".padEnd(12))} ${c2.bold(this._peerId ?? "connecting...")}`);
         lines.push(`  ${c2.cyan("Auth Key".padEnd(12))} ${c2.bold(this._authKey)}`);
@@ -28607,9 +28674,10 @@ ${this.formatConnectionInfo()}`);
         const lines = [];
         const uptimeSec = Math.floor((Date.now() - s.startedAt) / 1e3);
         const uptimeStr = uptimeSec < 60 ? `${uptimeSec}s` : uptimeSec < 3600 ? `${Math.floor(uptimeSec / 60)}m ${uptimeSec % 60}s` : `${Math.floor(uptimeSec / 3600)}h ${Math.floor(uptimeSec % 3600 / 60)}m`;
-        lines.push(`  ${c2.bold("Expose Gateway Stats")} ${c2.dim("(libp2p)")}`);
+        const modeTag = this._passthrough ? c2.dim("(libp2p passthrough)") : c2.dim("(libp2p)");
+        lines.push(`  ${c2.bold("Expose Gateway Stats")} ${modeTag}`);
         lines.push(`  ${c2.cyan("Status".padEnd(18))} ${s.status === "active" ? c2.green("active") : s.status === "error" ? c2.red("error") : c2.yellow("standby")}`);
-        lines.push(`  ${c2.cyan("Transport".padEnd(18))} libp2p`);
+        lines.push(`  ${c2.cyan("Transport".padEnd(18))} libp2p${this._passthrough ? " (passthrough)" : ""}`);
         lines.push(`  ${c2.cyan("Peer ID".padEnd(18))} ${this._peerId ?? "n/a"}`);
         lines.push(`  ${c2.cyan("Uptime".padEnd(18))} ${uptimeStr}`);
         lines.push(`  ${c2.cyan("Total requests".padEnd(18))} ${s.totalRequests}`);
@@ -28617,10 +28685,16 @@ ${this.formatConnectionInfo()}`);
         lines.push(`  ${c2.cyan("Errors".padEnd(18))} ${s.errors}`);
         lines.push(`  ${c2.cyan("Tokens in".padEnd(18))} ${fmtTokens(s.totalTokensIn)}`);
         lines.push(`  ${c2.cyan("Tokens out".padEnd(18))} ${fmtTokens(s.totalTokensOut)}`);
-        if (s.modelUsage.size > 0) {
+        if (s.budgetTokensTotal > 0) {
+          const pct = Math.round(s.budgetTokensRemaining / s.budgetTokensTotal * 100);
+          const budgetColor = pct > 50 ? c2.green : pct > 20 ? c2.yellow : c2.red;
+          lines.push(`  ${c2.cyan("Budget".padEnd(18))} ${budgetColor(fmtTokens(s.budgetTokensRemaining))}${c2.dim("/")}${fmtTokens(s.budgetTokensTotal)} ${c2.dim(`(${pct}% left)`)}`);
+        }
+        const visibleModels = Array.from(s.modelUsage.entries()).filter(([model]) => !INTERNAL_CAPABILITIES.has(model));
+        if (visibleModels.length > 0) {
           lines.push("");
           lines.push(`  ${c2.bold("Models")}`);
-          for (const [model, count] of s.modelUsage) {
+          for (const [model, count] of visibleModels) {
             let mIn = 0, mOut = 0;
             for (const user of s.users.values()) {
               const mm = user.models.get(model);
@@ -28643,17 +28717,29 @@ ${this.formatConnectionInfo()}`);
             lines.push(`  ${c2.bold(user.ip)}`);
             lines.push(`    ${c2.dim("Session:")} ${ageStr}  ${c2.dim("Last seen:")} ${lastStr}  ${c2.dim("Requests:")} ${user.requests}`);
             lines.push(`    ${c2.dim("Tokens:")} in:${fmtTokens(user.tokensIn)} out:${fmtTokens(user.tokensOut)}`);
-            if (user.models.size > 0) {
-              const modelParts = [];
-              for (const [m, mm] of user.models) {
-                modelParts.push(`${m} (${mm.requests} reqs, ${fmtTokens(mm.tokensIn + mm.tokensOut)} tokens)`);
+            const userModels = Array.from(user.models.entries()).filter(([m]) => !INTERNAL_CAPABILITIES.has(m));
+            if (userModels.length > 0) {
+              for (const [m, mm] of userModels) {
+                lines.push(`    ${c2.dim("\xB7")} ${c2.cyan(m)} ${c2.dim(`${mm.requests}req ${fmtTokens(mm.tokensIn + mm.tokensOut)}tok`)}`);
               }
-              lines.push(`    ${c2.dim("Models:")} ${modelParts.join(", ")}`);
             }
           }
         }
         return lines.join("\n");
       }
+      /** Update budget from rate limit headers */
+      updateBudget(remaining, total, resetAt) {
+        this._stats.budgetTokensRemaining = remaining;
+        this._stats.budgetTokensTotal = total;
+        this._stats.budgetResetAt = resetAt;
+        this.emitStats();
+      }
+      get isPassthrough() {
+        return this._passthrough;
+      }
+      get isLoadbalance() {
+        return this._loadbalance;
+      }
     };
   }
 });
@@ -33519,25 +33605,44 @@ async function handleSlashCommand(input, ctx) {
         }
         return "handled";
       }
+      if (arg === "config") {
+        await handleExposeConfig(ctx);
+        return "handled";
+      }
+      if (arg?.startsWith("passthrough") || arg?.startsWith("forward")) {
+        const ptParts = (arg ?? "").split(/\s+/);
+        const ptLoadbalance = ptParts.includes("--loadbalance");
+        try {
+          const tunnelUrl = await ctx.exposeStart("passthrough", void 0, "libp2p", false, true, ptLoadbalance);
+          if (tunnelUrl) {
+            const info = ctx.getExposeInfo?.();
+            if (info) {
+              process.stdout.write("\n" + info.stats + "\n\n");
+            }
+          } else {
+            renderError("Failed to start passthrough expose gateway.");
+          }
+        } catch (err) {
+          renderError(`Expose passthrough error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return "handled";
+      }
       if (!arg) {
         const info = ctx.getExposeInfo?.();
         if (info && ctx.isExposeActive?.()) {
           process.stdout.write("\n" + info.stats + "\n\n");
         } else {
           renderInfo("Usage: /expose <backend> [options]");
-          renderInfo("  /expose ollama           Expose local Ollama via libp2p (default)");
-          renderInfo("  /expose ollama --tunnel  Expose via cloudflared tunnel");
-          renderInfo("  /expose ollama --libp2p  Expose via libp2p (explicit)");
-          renderInfo("  /expose vllm             Expose local vLLM (8000)");
-          renderInfo("  /expose llvm             Expose local LLVM (8080)");
-          renderInfo("  /expose host:port        Expose custom address");
-          renderInfo("  /expose stop             Stop all gateways");
-          renderInfo("  /expose stop --tunnel    Stop tunnel only");
-          renderInfo("  /expose stop --libp2p    Stop libp2p only");
-          renderInfo("  /expose status           Show usage stats");
-          renderInfo("  --key <key>              Use specific auth key (tunnel mode)");
-          renderInfo("  --key                    Auto-generate auth key (tunnel mode)");
-          renderInfo("  --full                   Allow full Ollama API access (pull/delete/etc)");
+          renderInfo("  /expose ollama                      Expose local Ollama via libp2p");
+          renderInfo("  /expose ollama --tunnel             Expose via cloudflared tunnel");
+          renderInfo("  /expose vllm                        Expose local vLLM (8000)");
+          renderInfo("  /expose passthrough --libp2p        Forward /endpoint through libp2p");
+          renderInfo("  /expose forward --loadbalance       Forward with rate-limit distribution");
+          renderInfo("  /expose config                      Configure expose settings");
+          renderInfo("  /expose stop                        Stop all gateways");
+          renderInfo("  /expose status                      Show usage stats");
+          renderInfo("  --key <key>                         Use specific auth key (tunnel mode)");
+          renderInfo("  --full                              Full Ollama API access");
         }
         return "handled";
       }
@@ -34168,6 +34273,92 @@ function applyConfigChanges(ctx, changes) {
   if (changes.commandsMode !== void 0)
     ctx.setCommandsMode?.(changes.commandsMode);
 }
+async function handleExposeConfig(ctx) {
+  const info = ctx.getExposeInfo?.();
+  const isActive = ctx.isExposeActive?.() ?? false;
+  const items = [
+    { key: "hdr_status", label: "Status", kind: "header" },
+    { key: "status", label: isActive ? "Active" : "Inactive", detail: isActive ? "Gateway is running" : "No gateway active", kind: "info" }
+  ];
+  if (isActive && info) {
+    items.push({ key: "view_stats", label: "View Stats", detail: "Show current gateway statistics", kind: "action" });
+    items.push({ key: "stop_all", label: "Stop All Gateways", detail: "Shut down all expose transports", kind: "action" });
+  }
+  items.push({ key: "hdr_start", label: "Start Gateway", kind: "header" });
+  items.push({ key: "start_ollama", label: "Expose Ollama (libp2p)", detail: "Expose local Ollama via P2P network", kind: "action" });
+  items.push({ key: "start_ollama_tunnel", label: "Expose Ollama (tunnel)", detail: "Expose via cloudflared public tunnel", kind: "action" });
+  items.push({ key: "start_passthrough", label: "Passthrough /endpoint (libp2p)", detail: "Forward configured endpoint through P2P", kind: "action" });
+  items.push({ key: "start_passthrough_lb", label: "Passthrough + Load Balance", detail: "Forward with distributed rate-limit budget", kind: "action" });
+  items.push({ key: "start_vllm", label: "Expose vLLM (libp2p)", detail: "Expose local vLLM server (port 8000)", kind: "action" });
+  const skipKeys = items.filter((e) => e.kind === "header" || e.kind === "info").map((e) => e.key);
+  const result = await tuiSelect({
+    items,
+    title: "Expose Configuration",
+    rl: ctx.rl,
+    skipKeys
+  });
+  if (!result.confirmed || !result.key) {
+    renderInfo("Expose config cancelled.");
+    return;
+  }
+  switch (result.key) {
+    case "view_stats": {
+      const freshInfo = ctx.getExposeInfo?.();
+      if (freshInfo)
+        process.stdout.write("\n" + freshInfo.stats + "\n\n");
+      break;
+    }
+    case "stop_all":
+      await ctx.exposeStop?.();
+      renderInfo("All expose gateways stopped.");
+      break;
+    case "start_ollama": {
+      const url = await ctx.exposeStart?.("ollama", void 0, "libp2p");
+      if (url) {
+        const i = ctx.getExposeInfo?.();
+        if (i)
+          process.stdout.write("\n" + i.stats + "\n\n");
+      }
+      break;
+    }
+    case "start_ollama_tunnel": {
+      const url = await ctx.exposeStart?.("ollama", "", "tunnel");
+      if (url) {
+        const i = ctx.getExposeInfo?.();
+        if (i)
+          process.stdout.write("\n" + i.stats + "\n\n");
+      }
+      break;
+    }
+    case "start_passthrough": {
+      const url = await ctx.exposeStart?.("passthrough", void 0, "libp2p", false, true, false);
+      if (url) {
+        const i = ctx.getExposeInfo?.();
+        if (i)
+          process.stdout.write("\n" + i.stats + "\n\n");
+      }
+      break;
+    }
+    case "start_passthrough_lb": {
+      const url = await ctx.exposeStart?.("passthrough", void 0, "libp2p", false, true, true);
+      if (url) {
+        const i = ctx.getExposeInfo?.();
+        if (i)
+          process.stdout.write("\n" + i.stats + "\n\n");
+      }
+      break;
+    }
+    case "start_vllm": {
+      const url = await ctx.exposeStart?.("vllm", void 0, "libp2p");
+      if (url) {
+        const i = ctx.getExposeInfo?.();
+        if (i)
+          process.stdout.write("\n" + i.stats + "\n\n");
+      }
+      break;
+    }
+  }
+}
 async function showModelPicker(ctx, local = false) {
   try {
     const models = await fetchModels(ctx.config.backendUrl, ctx.config.apiKey);
@@ -44237,14 +44428,16 @@ var init_status_bar = __esm({
           }
         }
         if (this._expose) {
+          const INTERNAL_CAPS = /* @__PURE__ */ new Set(["system_metrics", "__list_capabilities"]);
           const statusEmoji = this._expose.status === "active" ? "\u{1F7E2}" : this._expose.status === "error" ? "\u{1F534}" : "\u{1F7E0}";
-          const models = Array.from(this._expose.modelUsage.keys());
+          const models = Array.from(this._expose.modelUsage.keys()).filter((m2) => !INTERNAL_CAPS.has(m2));
           const modelParams = models.map((mdl) => {
             const pm = mdl.match(/(\d+[bBmM])/);
             return pm ? pm[1] : mdl.split(":")[0]?.split("/").pop() ?? mdl;
           });
           const modelStr = modelParams.join(",");
-          const reqStr = this._expose.totalRequests > 0 ? ` ${this._expose.totalRequests}req` : "";
+          const visibleReqs = Array.from(this._expose.modelUsage.entries()).filter(([m2]) => !INTERNAL_CAPS.has(m2)).reduce((sum, [, n]) => sum + n, 0);
+          const reqStr = visibleReqs > 0 ? ` ${visibleReqs}req` : "";
           const connStr = this._expose.activeConnections > 0 ? ` ${this._expose.activeConnections}conn` : "";
           const exposeExpanded = statusEmoji + pastel2(183, (modelStr ? " " + modelStr : "") + reqStr + connStr);
           const exposeCompact = statusEmoji + (modelStr ? pastel2(183, " " + modelStr) : "");
@@ -46689,11 +46882,15 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
     getCallUrl() {
       return voiceSession?.tunnelUrl ?? null;
     },
-    async exposeStart(kindOrUrl, authKey, transport, fullAccess) {
-      const knownKinds = ["ollama", "vllm", "llvm"];
+    async exposeStart(kindOrUrl, authKey, transport, fullAccess, passthrough, loadbalance) {
+      const knownKinds = ["ollama", "vllm", "llvm", "passthrough"];
       let kind;
       let targetUrl;
-      if (knownKinds.includes(kindOrUrl)) {
+      if (kindOrUrl === "passthrough" || passthrough) {
+        kind = "custom";
+        targetUrl = config.backendUrl;
+        passthrough = true;
+      } else if (knownKinds.includes(kindOrUrl)) {
         kind = kindOrUrl;
       } else {
         kind = "custom";
@@ -46706,7 +46903,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           p2pGateway = null;
         }
         const nexusTool = new NexusTool(repoRoot);
-        let exposeSpinnerMsg = "Connecting to nexus P2P network...";
+        let exposeSpinnerMsg = passthrough ? `Connecting to nexus P2P network (passthrough \u2192 ${targetUrl})...` : "Connecting to nexus P2P network...";
         const exposeFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
         let exposeFrame = 0;
         const exposeSpinner = setInterval(() => {
@@ -46718,6 +46915,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           targetUrl,
           authKey,
           stateDir: join50(repoRoot, ".oa"),
+          passthrough: passthrough ?? false,
+          loadbalance: loadbalance ?? false,
           onInfo: (msg) => {
             exposeSpinnerMsg = msg;
           },

package/package.json

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