open-agents-ai 0.103.19 → 0.103.21

package/README.md

@@ -919,6 +919,7 @@ The TUI features an animated multilingual phrase carousel, live metrics bar with
 | `/models` | List all available models |
 | `/endpoint <url>` | Connect to a remote vLLM or OpenAI-compatible API |
 | `/endpoint <url> --auth <key>` | Set endpoint with Bearer auth |
+| `/endpoint <peerId> --auth <key>` | Connect to a libp2p peer via nexus P2P network |
 | **Task Control** | |
 | `/pause` | Pause after current turn finishes (gentle halt) |
 | `/stop` | Kill current inference immediately, save state |
@@ -952,7 +953,11 @@ The TUI features an animated multilingual phrase carousel, live metrics bar with
 | `/secrets set <name> <value>` | Register a secret in the vault |
 | `/secrets list` | List registered secrets (values hidden) |
 | `/secrets import-env` | Auto-import secrets from environment variables |
-| `/expose` | Expose local inference via cloudflared tunnel |
+| `/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 |
 | **Metrics & Updates** | |
 | `/cost` | Show token cost breakdown for the current session |
 | `/score` | Show inference capability scorecard (memory, compute, speed, model compatibility) |
@@ -1498,6 +1503,40 @@ Use `/endpoint` in the TUI or pass via CLI:
 
 The agent auto-detects the provider, normalizes the URL (strips `/v1/chat/completions` if pasted), tests connectivity, and saves the configuration. You can paste full endpoint URLs — they'll be cleaned up automatically.
 
+### P2P Inference via libp2p
+
+Expose your local Ollama models to the decentralized nexus network, or consume another peer's models — no port forwarding, DNS, or cloud accounts needed:
+
+```bash
+# Provider: expose local models via libp2p (default transport)
+/expose ollama
+
+# Output shows a copy-pasteable command:
+#   /endpoint 12D3KooWSwaCi1J... --auth 5aJ68QuP...
+
+# Consumer: connect to a remote peer
+/endpoint 12D3KooWSwaCi1JgXp2f2tQNFZFyMPZVcDe8oyTG672n6ELxSgBt --auth 5aJ68QuPxyz
+
+# Fallback: expose via cloudflared tunnel instead
+/expose ollama --tunnel
+
+# Grant full Ollama API access to consumers (pull, delete, etc.)
+/expose ollama --full
+```
+
+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.
+
+### 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:
+
+```
+[cascade] Failover → https://api.groq.com/openai: 2 consecutive failures: fetch failed
+[cascade] Primary recovered: http://localhost:11434
+```
+
+No configuration needed — the cascade is built from your endpoint usage history. Works across local Ollama, cloud providers, and P2P peers.
+
 ## Evaluation Suite
 
 46 evaluation tasks test the agent's autonomous capabilities across coding, web research, SDLC analysis, tool creation, multi-file reasoning, memory systems, and context engineering:

package/dist/index.js

@@ -27395,7 +27395,34 @@ async function collectSystemMetricsAsync() {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-var HOP_BY_HOP_HEADERS, CF_HEADERS_PREFIX, DEFAULT_TARGETS, STATE_FILE_NAME, ExposeGateway, ExposeP2PGateway;
+function readP2PExposeState(stateDir) {
+  try {
+    const path = join35(stateDir, P2P_STATE_FILE_NAME);
+    if (!existsSync27(path))
+      return null;
+    const raw = readFileSync19(path, "utf8");
+    const data = JSON.parse(raw);
+    if (!data.peerId || !data.authKey)
+      return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeP2PExposeState(stateDir, state) {
+  try {
+    mkdirSync9(stateDir, { recursive: true });
+    writeFileSync9(join35(stateDir, P2P_STATE_FILE_NAME), JSON.stringify(state, null, 2));
+  } catch {
+  }
+}
+function removeP2PExposeState(stateDir) {
+  try {
+    unlinkSync3(join35(stateDir, P2P_STATE_FILE_NAME));
+  } catch {
+  }
+}
+var HOP_BY_HOP_HEADERS, CF_HEADERS_PREFIX, DEFAULT_TARGETS, STATE_FILE_NAME, ExposeGateway, P2P_STATE_FILE_NAME, ExposeP2PGateway;
 var init_expose = __esm({
   "packages/cli/dist/tui/expose.js"() {
     "use strict";
@@ -28047,7 +28074,8 @@ ${this.formatConnectionInfo()}`);
         return lines.join("\n");
       }
     };
-    ExposeP2PGateway = class extends EventEmitter3 {
+    P2P_STATE_FILE_NAME = "expose-p2p-state.json";
+    ExposeP2PGateway = class _ExposeP2PGateway extends EventEmitter3 {
       _nexusTool;
       // NexusTool instance
       _kind;
@@ -28156,6 +28184,16 @@ ${this.formatConnectionInfo()}`);
         this._stats.status = "active";
         this._stats.startedAt = Date.now();
         this.emitStats();
+        if (this._stateDir && this._peerId) {
+          writeP2PExposeState(this._stateDir, {
+            peerId: this._peerId,
+            authKey: this._authKey,
+            kind: this._kind,
+            targetUrl: this._targetUrl,
+            margin: this._margin,
+            startedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
         this.startMeteringPoll(nexusDir);
         return this._peerId ?? "connected (peer ID pending)";
       }
@@ -28164,6 +28202,54 @@ ${this.formatConnectionInfo()}`);
         this._stats.status = "standby";
         this._stats.activeConnections = 0;
         this.emitStats();
+        if (this._stateDir)
+          removeP2PExposeState(this._stateDir);
+      }
+      /**
+       * Check for and reconnect to a surviving P2P expose from a previous session.
+       * Verifies the nexus daemon is still running and the peer ID is valid,
+       * then resumes metering poll without re-registering capabilities
+       * (the daemon keeps them registered across OA restarts).
+       */
+      static async checkAndReconnect(stateDir, nexusTool, options) {
+        const state = readP2PExposeState(stateDir);
+        if (!state)
+          return null;
+        const nexusDir = nexusTool.getNexusDir();
+        const statusPath = join35(nexusDir, "status.json");
+        try {
+          if (!existsSync27(statusPath)) {
+            removeP2PExposeState(stateDir);
+            return null;
+          }
+          const status = JSON.parse(readFileSync19(statusPath, "utf8"));
+          if (!status.connected || !status.peerId) {
+            removeP2PExposeState(stateDir);
+            return null;
+          }
+          if (status.peerId !== state.peerId) {
+            removeP2PExposeState(stateDir);
+            return null;
+          }
+        } catch {
+          removeP2PExposeState(stateDir);
+          return null;
+        }
+        const gateway = new _ExposeP2PGateway({
+          kind: state.kind,
+          targetUrl: state.targetUrl,
+          authKey: state.authKey,
+          stateDir,
+          margin: state.margin,
+          ...options
+        }, nexusTool);
+        gateway._peerId = state.peerId;
+        gateway._stats.status = "active";
+        gateway._stats.startedAt = new Date(state.startedAt).getTime();
+        gateway.emitStats();
+        gateway.startMeteringPoll(nexusDir);
+        options.onInfo?.(`P2P expose reconnected: ${state.peerId}`);
+        return gateway;
       }
       /** Poll the daemon's metering.jsonl and status.json for stats */
       startMeteringPoll(nexusDir) {
@@ -32979,10 +33065,20 @@ async function handleSlashCommand(input, ctx) {
         renderWarning("Expose gateway not available in this context.");
         return "handled";
       }
-      if (arg === "stop" || arg === "off") {
+      if (arg?.startsWith("stop") || arg === "off") {
+        const stopParts = (arg ?? "").split(/\s+/);
+        let stopWhich;
+        if (stopParts.includes("--tunnel"))
+          stopWhich = "tunnel";
+        else if (stopParts.includes("--libp2p"))
+          stopWhich = "libp2p";
         if (ctx.isExposeActive?.()) {
-          await ctx.exposeStop?.();
-          renderInfo("Expose gateway stopped.");
+          await ctx.exposeStop?.(stopWhich);
+          if (stopWhich) {
+            renderInfo(`Expose ${stopWhich} gateway stopped.`);
+          } else {
+            renderInfo("All expose gateways stopped.");
+          }
         } else {
           renderWarning("No active expose gateway.");
         }
@@ -33009,7 +33105,9 @@ async function handleSlashCommand(input, ctx) {
           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 the gateway");
+          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)");
@@ -33017,9 +33115,6 @@ async function handleSlashCommand(input, ctx) {
         }
         return "handled";
       }
-      if (ctx.isExposeActive?.()) {
-        await ctx.exposeStop?.();
-      }
       const exposeParts = arg.split(/\s+/);
       const kindOrUrl = exposeParts[0];
       let exposeAuthKey;
@@ -44437,11 +44532,15 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   }
   try {
     const endpointHistory = loadUsageHistory("endpoint", repoRoot);
+    const primaryIsNexus = config.backendType === "nexus";
     const fallbackEndpoints = [];
     for (const entry of endpointHistory) {
       if (entry.value === config.backendUrl)
         continue;
       const bt = entry.meta?.backendType ?? "ollama";
+      const entryIsNexus = bt === "nexus";
+      if (primaryIsNexus !== entryIsNexus)
+        continue;
       const ep = {
         url: entry.value,
         backendType: bt,
@@ -45104,7 +45203,8 @@ async function startInteractive(config, repoPath) {
   autoUpdateTimer.unref();
   const voiceEngine = new VoiceEngine();
   let voiceSession = null;
-  let exposeGateway = null;
+  let tunnelGateway = null;
+  let p2pGateway = null;
   let peerMesh = null;
   let inferenceRouter = null;
   const secretVault = new SecretVault(join50(repoRoot, ".oa", "vault.enc"));
@@ -45456,7 +45556,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
         onError: (msg) => writeContent(() => renderWarning(msg))
       });
       if (reconnected) {
-        exposeGateway = reconnected;
+        tunnelGateway = reconnected;
         reconnected.on("stats", (stats) => {
           statusBar.setExposeStatus({
             status: stats.status,
@@ -45471,6 +45571,28 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       }
     } catch {
     }
+    try {
+      const oaDir = join50(repoRoot, ".oa");
+      const reconnectedP2P = await ExposeP2PGateway.checkAndReconnect(oaDir, new NexusTool(repoRoot), {
+        onInfo: (msg) => writeContent(() => renderInfo(msg)),
+        onError: (msg) => writeContent(() => renderWarning(msg))
+      });
+      if (reconnectedP2P) {
+        p2pGateway = reconnectedP2P;
+        reconnectedP2P.on("stats", (stats) => {
+          statusBar.setExposeStatus({
+            status: stats.status,
+            totalRequests: stats.totalRequests,
+            activeConnections: stats.activeConnections,
+            modelUsage: stats.modelUsage
+          });
+        });
+        writeContent(() => {
+          renderInfo(`Reconnected to existing P2P expose: ${reconnectedP2P.peerId}`);
+        });
+      }
+    } catch {
+    }
     try {
       const isPeer = currentConfig.backendUrl.startsWith("peer://");
       const isRemote = !currentConfig.backendUrl.includes("127.0.0.1") && !currentConfig.backendUrl.includes("localhost") && !isPeer;
@@ -46123,14 +46245,18 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       }
       const effectiveTransport = transport ?? "libp2p";
       if (effectiveTransport === "libp2p") {
+        if (p2pGateway?.isActive) {
+          await p2pGateway.stop();
+          p2pGateway = null;
+        }
         const nexusTool = new NexusTool(repoRoot);
-        const p2pGateway = new ExposeP2PGateway({
+        const newP2P = new ExposeP2PGateway({
           kind,
           targetUrl,
           authKey,
           stateDir: join50(repoRoot, ".oa")
         }, nexusTool);
-        p2pGateway.on("stats", (stats) => {
+        newP2P.on("stats", (stats) => {
           statusBar.setExposeStatus({
             status: stats.status,
             totalRequests: stats.totalRequests,
@@ -46139,10 +46265,10 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           });
         });
         try {
-          const peerId = await p2pGateway.start();
-          exposeGateway = p2pGateway;
+          const peerId = await newP2P.start();
+          p2pGateway = newP2P;
           writeContent(() => {
-            process.stdout.write("\n" + p2pGateway.formatConnectionInfo() + "\n\n");
+            process.stdout.write("\n" + newP2P.formatConnectionInfo() + "\n\n");
           });
           return peerId;
         } catch (err) {
@@ -46156,8 +46282,12 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           }
         }
       }
-      const tunnelGateway = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join50(repoRoot, ".oa") });
-      tunnelGateway.on("stats", (stats) => {
+      if (tunnelGateway?.isActive) {
+        await tunnelGateway.stop();
+        tunnelGateway = null;
+      }
+      const newTunnel = new ExposeGateway({ kind, targetUrl, authKey, fullAccess, stateDir: join50(repoRoot, ".oa") });
+      newTunnel.on("stats", (stats) => {
         statusBar.setExposeStatus({
           status: stats.status,
           totalRequests: stats.totalRequests,
@@ -46166,41 +46296,67 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         });
       });
       try {
-        const url = await tunnelGateway.start();
-        exposeGateway = tunnelGateway;
+        const url = await newTunnel.start();
+        tunnelGateway = newTunnel;
         writeContent(() => {
-          process.stdout.write("\n" + tunnelGateway.formatConnectionInfo() + "\n\n");
+          process.stdout.write("\n" + newTunnel.formatConnectionInfo() + "\n\n");
         });
         return url;
       } catch (err) {
-        exposeGateway = null;
         throw err;
       }
     },
-    async exposeStop() {
-      if (exposeGateway) {
-        await exposeGateway.stop();
+    async exposeStop(which) {
+      if (!which || which === "tunnel") {
+        if (tunnelGateway) {
+          await tunnelGateway.stop();
+          tunnelGateway = null;
+        }
+      }
+      if (!which || which === "libp2p") {
+        if (p2pGateway) {
+          await p2pGateway.stop();
+          p2pGateway = null;
+        }
+      }
+      if (!tunnelGateway?.isActive && !p2pGateway?.isActive) {
         statusBar.clearExposeStatus();
-        exposeGateway = null;
       }
     },
     isExposeActive() {
-      return exposeGateway?.isActive ?? false;
+      return (tunnelGateway?.isActive ?? false) || (p2pGateway?.isActive ?? false);
     },
     getExposeInfo() {
-      if (!exposeGateway)
+      const infos = [];
+      if (tunnelGateway?.isActive) {
+        infos.push({
+          tunnelUrl: tunnelGateway.tunnelUrl,
+          authKey: tunnelGateway.authKey,
+          stats: tunnelGateway.formatStats(),
+          transport: "tunnel"
+        });
+      }
+      if (p2pGateway?.isActive) {
+        infos.push({
+          tunnelUrl: p2pGateway.peerId,
+          authKey: p2pGateway.authKey,
+          stats: p2pGateway.formatStats(),
+          transport: "libp2p"
+        });
+      }
+      if (infos.length === 0)
         return null;
-      if (exposeGateway instanceof ExposeP2PGateway) {
+      if (infos.length === 2) {
         return {
-          tunnelUrl: exposeGateway.peerId,
-          authKey: exposeGateway.authKey,
-          stats: exposeGateway.formatStats()
+          tunnelUrl: infos[0].tunnelUrl,
+          authKey: infos[0].authKey,
+          stats: infos[0].stats + "\n\n" + infos[1].stats
         };
       }
       return {
-        tunnelUrl: exposeGateway.tunnelUrl,
-        authKey: exposeGateway.authKey,
-        stats: exposeGateway.formatStats()
+        tunnelUrl: infos[0].tunnelUrl,
+        authKey: infos[0].authKey,
+        stats: infos[0].stats
       };
     },
     // ── Nexus daemon connect ──────────────────────────────────────────────

package/package.json

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