open-agents-ai 0.103.46 → 0.103.48

package/dist/index.js

@@ -28537,7 +28537,7 @@ ${this.formatConnectionInfo()}`);
       }
     };
     P2P_STATE_FILE_NAME = "expose-p2p-state.json";
-    ExposeP2PGateway = class extends EventEmitter3 {
+    ExposeP2PGateway = class _ExposeP2PGateway extends EventEmitter3 {
       _nexusTool;
       // NexusTool instance
       _kind;
@@ -28669,6 +28669,7 @@ ${this.formatConnectionInfo()}`);
             margin: this._margin,
             passthrough: this._passthrough || void 0,
             loadbalance: this._loadbalance || void 0,
+            endpointAuth: this._endpointAuth,
             startedAt: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
@@ -28685,20 +28686,66 @@ ${this.formatConnectionInfo()}`);
       }
       /**
        * Check for and reconnect to a surviving P2P expose from a previous session.
-       *
-       * IMPORTANT: We no longer blindly reconnect to surviving daemons because:
-       * 1. The daemon script may be outdated (OA was updated since daemon spawned)
-       * 2. The registered capabilities may be stale (e.g., local Ollama from a previous expose)
-       * 3. Only a fresh start() → doConnect() → expose can guarantee correct state
-       *
-       * Instead, we clean up the stale state so the next /expose command starts fresh.
+       * The daemon survives OA restarts, but we MUST re-verify it on reconnect:
+       *   1. doConnect() checks script hash — kills + respawns if daemon code is stale
+       *   2. Re-sends the expose command to clear old capabilities and register fresh ones
+       * This guarantees the correct models are exposed (Chutes vs Ollama) even after OA restart.
        */
-      static async checkAndReconnect(_stateDir, _nexusTool, _options) {
-        const state = readP2PExposeState(_stateDir);
-        if (state) {
-          removeP2PExposeState(_stateDir);
+      static async checkAndReconnect(stateDir, nexusTool, options, currentConfig) {
+        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;
+          }
+        } catch {
+          removeP2PExposeState(stateDir);
+          return null;
+        }
+        let effectiveState = { ...state };
+        if (currentConfig) {
+          const currentUrl = currentConfig.backendUrl;
+          const isCurrentLocal = currentUrl.includes("127.0.0.1") || currentUrl.includes("localhost");
+          const isCurrentPeer = currentUrl.startsWith("peer://");
+          if (state.passthrough) {
+            const normalizedUrl = currentUrl.replace(/\/+$/, "").replace(/\/chat\/completions$/, "").replace(/\/completions$/, "").replace(/\/models(\/.*)?$/, "").replace(/\/v1$/, "").replace(/\/+$/, "");
+            effectiveState.targetUrl = normalizedUrl;
+            effectiveState.endpointAuth = currentConfig.apiKey;
+          } else if (!isCurrentLocal && !isCurrentPeer && state.kind === "ollama") {
+            removeP2PExposeState(stateDir);
+            options.onInfo?.("P2P expose skipped: endpoint changed (use /expose forward for remote backends)");
+            return null;
+          }
+        }
+        const gateway = new _ExposeP2PGateway({
+          kind: effectiveState.kind,
+          targetUrl: effectiveState.targetUrl,
+          authKey: effectiveState.authKey,
+          stateDir,
+          margin: effectiveState.margin,
+          passthrough: effectiveState.passthrough,
+          loadbalance: effectiveState.loadbalance,
+          endpointAuth: effectiveState.endpointAuth,
+          ...options
+        }, nexusTool);
+        try {
+          await gateway.start();
+          options.onInfo?.(`P2P expose reconnected: ${gateway._peerId ?? state.peerId}`);
+          return gateway;
+        } catch (err) {
+          removeP2PExposeState(stateDir);
+          options.onError?.(`P2P expose reconnect failed: ${err instanceof Error ? err.message : String(err)}`);
+          return null;
         }
-        return null;
       }
       /** Poll the daemon's metering.jsonl and status.json for stats */
       startMeteringPoll(nexusDir) {
@@ -46392,7 +46439,7 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       const reconnectedP2P = await ExposeP2PGateway.checkAndReconnect(oaDir, new NexusTool(repoRoot), {
         onInfo: (msg) => writeContent(() => renderInfo(msg)),
         onError: (msg) => writeContent(() => renderWarning(msg))
-      });
+      }, { backendUrl: currentConfig.backendUrl, apiKey: currentConfig.apiKey });
       if (reconnectedP2P) {
         p2pGateway = reconnectedP2P;
         reconnectedP2P.on("stats", (stats) => {

package/package.json

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