open-agents-ai 0.15.6 → 0.15.8

package/dist/index.js

@@ -8188,7 +8188,18 @@ Integrate this guidance into your current approach. Continue working on the task
             maxTokens: this.options.maxTokens,
             timeoutMs: this.options.requestTimeoutMs
           };
-          const response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
+          let response;
+          try {
+            response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
+          } catch (reqErr) {
+            const recovered = await this.retryOnTransient(reqErr, chatRequest, turn);
+            if (!recovered) {
+              this.emit({ type: "error", content: `Backend error: ${reqErr instanceof Error ? reqErr.message : String(reqErr)}`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+              messages.push({ role: "user", content: "[System: backend request failed, retrying on next turn. The previous request was lost.]" });
+              continue;
+            }
+            response = recovered;
+          }
           totalTokens += response.usage?.totalTokens ?? 0;
           promptTokens += response.usage?.promptTokens ?? 0;
           completionTokens += response.usage?.completionTokens ?? 0;
@@ -8405,7 +8416,18 @@ Integrate this guidance into your current approach. Continue working on the task
             }
             const compactedMsgs = this.compactMessages(messages);
             const chatRequest = { messages: compactedMsgs, tools: toolDefs, temperature: this.options.temperature, maxTokens: this.options.maxTokens, timeoutMs: this.options.requestTimeoutMs };
-            const response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
+            let response;
+            try {
+              response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
+            } catch (reqErr) {
+              const recovered = await this.retryOnTransient(reqErr, chatRequest, turn);
+              if (!recovered) {
+                this.emit({ type: "error", content: `Backend error: ${reqErr instanceof Error ? reqErr.message : String(reqErr)}`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                messages.push({ role: "user", content: "[System: backend request failed, retrying on next turn. The previous request was lost.]" });
+                continue;
+              }
+              response = recovered;
+            }
             totalTokens += response.usage?.totalTokens ?? 0;
             promptTokens += response.usage?.promptTokens ?? 0;
             completionTokens += response.usage?.completionTokens ?? 0;
@@ -8809,6 +8831,58 @@ ${newerSummary}` : newerSummary;
         }));
       }
       // -------------------------------------------------------------------------
+      // Transient error recovery — retry on 502, fetch failed, timeouts
+      // -------------------------------------------------------------------------
+      /** Detect whether an error is transient (worth retrying) */
+      isTransientError(err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/Backend HTTP (502|503|504)/i.test(msg))
+          return true;
+        if (/fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE|socket hang up/i.test(msg))
+          return true;
+        if (/received HTML error page/i.test(msg))
+          return true;
+        if (/model is loading|server busy|overloaded/i.test(msg))
+          return true;
+        return false;
+      }
+      /**
+       * Retry a failed model request up to 3 times with exponential backoff.
+       * Returns the response on success, or null if all retries failed.
+       */
+      async retryOnTransient(initialErr, chatRequest, turn) {
+        if (!this.isTransientError(initialErr))
+          return null;
+        const maxRetries = 3;
+        const baseDelayMs = 3e3;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+          if (this.aborted)
+            return null;
+          const delay = baseDelayMs * Math.pow(2, attempt - 1);
+          this.emit({
+            type: "compaction",
+            content: `Backend error \u2014 retrying in ${(delay / 1e3).toFixed(0)}s (attempt ${attempt}/${maxRetries})`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          await new Promise((r) => setTimeout(r, delay));
+          if (this.aborted)
+            return null;
+          try {
+            const response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
+            this.emit({
+              type: "compaction",
+              content: `Backend recovered on attempt ${attempt}`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            return response;
+          } catch (retryErr) {
+            if (!this.isTransientError(retryErr))
+              return null;
+          }
+        }
+        return null;
+      }
+      // -------------------------------------------------------------------------
       // Streaming support — parallel path that emits token events
       // -------------------------------------------------------------------------
       /** Check whether the backend supports SSE streaming */
@@ -10809,6 +10883,106 @@ async function runSetupWizard(config) {
     rl.close();
   }
 }
+async function promptForCustomEndpoint(config, rl) {
+  process.stdout.write(`
+  ${c2.cyan("\u25CF")} Enter an OpenAI-compatible inference endpoint.
+`);
+  process.stdout.write(`    ${c2.dim("Examples:")}
+`);
+  process.stdout.write(`    ${c2.dim("  https://chutes.ai/v1")}
+`);
+  process.stdout.write(`    ${c2.dim("  http://10.0.0.5:11434")}
+`);
+  process.stdout.write(`    ${c2.dim("  https://api.together.xyz/v1")}
+
+`);
+  const endpoint = await ask(rl, `  ${c2.bold("Endpoint URL:")} `);
+  if (!endpoint) {
+    process.stdout.write(`  ${c2.dim("No endpoint entered.")}
+`);
+    const startAnyway = await ask(rl, `
+  ${c2.bold("Start anyway without a backend?")} (y/n) `);
+    if (startAnyway.toLowerCase() === "y" || startAnyway.toLowerCase() === "yes") {
+      return config.model;
+    }
+    return config.model;
+  }
+  const cleanUrl = endpoint.replace(/\/+$/, "");
+  const needsKey = await ask(rl, `
+  ${c2.bold("Does this endpoint require an API key?")} (y/n) `);
+  let apiKey = "";
+  if (needsKey.toLowerCase() === "y" || needsKey.toLowerCase() === "yes") {
+    apiKey = await ask(rl, `  ${c2.bold("API key:")} `);
+  }
+  process.stdout.write(`
+  ${c2.cyan("\u25CF")} Enter the model name for this endpoint.
+`);
+  process.stdout.write(`    ${c2.dim("Examples: qwen3.5:122b, meta-llama/Llama-3.3-70B, etc.")}
+
+`);
+  const modelName = await ask(rl, `  ${c2.bold("Model name")} (Enter for ${c2.dim(config.model)}): `);
+  const chosenModel = modelName || config.model;
+  process.stdout.write(`
+  ${c2.cyan("\u25CF")} Testing endpoint ${c2.bold(cleanUrl)}...
+`);
+  let testOk = false;
+  try {
+    const testUrl = cleanUrl.endsWith("/v1") ? `${cleanUrl}/models` : cleanUrl.includes("/v1/") ? `${cleanUrl.replace(/\/v1\/.*/, "/v1/models")}` : `${cleanUrl}/v1/models`;
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey)
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    const resp = await fetch(testUrl, { headers, signal: AbortSignal.timeout(1e4) });
+    if (resp.ok) {
+      process.stdout.write(`  ${c2.green("\u2714")} Endpoint reachable.
+`);
+      testOk = true;
+    } else {
+      try {
+        const ollamaResp = await fetch(`${cleanUrl}/api/tags`, { signal: AbortSignal.timeout(1e4) });
+        if (ollamaResp.ok) {
+          process.stdout.write(`  ${c2.green("\u2714")} Ollama endpoint detected.
+`);
+          testOk = true;
+        }
+      } catch {
+      }
+      if (!testOk) {
+        process.stdout.write(`  ${c2.yellow("\u26A0")} Endpoint returned HTTP ${resp.status}
+`);
+      }
+    }
+  } catch (err) {
+    process.stdout.write(`  ${c2.yellow("\u26A0")} Could not reach endpoint: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+  if (!testOk) {
+    const startAnyway = await ask(rl, `
+  ${c2.bold("Endpoint unreachable. Start anyway?")} (y/n) `);
+    if (startAnyway.toLowerCase() !== "y" && startAnyway.toLowerCase() !== "yes") {
+      process.stdout.write(`  ${c2.dim("You can configure the endpoint later with /endpoint")}
+
+`);
+      return config.model;
+    }
+  }
+  setConfigValue("backendUrl", cleanUrl);
+  setConfigValue("model", chosenModel);
+  if (apiKey) {
+    setConfigValue("apiKey", apiKey);
+  }
+  const backendType = cleanUrl.includes("/v1") ? "vllm" : "ollama";
+  setConfigValue("backendType", backendType);
+  process.stdout.write(`
+  ${c2.green("\u2714")} Configured: ${c2.bold(chosenModel)} at ${c2.bold(cleanUrl)}
+`);
+  if (apiKey)
+    process.stdout.write(`  ${c2.green("\u2714")} API key saved.
+`);
+  process.stdout.write(`  ${c2.green("\u2714")} Backend type: ${c2.bold(backendType)}
+
+`);
+  return chosenModel;
+}
 async function doSetup(config, rl) {
   process.stdout.write(`
   ${c2.bold(c2.cyan("open-agents"))}
@@ -10832,16 +11006,42 @@ async function doSetup(config, rl) {
   }
   process.stdout.write("\n");
   let models = [];
+  let usingCustomEndpoint = false;
   try {
     models = await fetchOllamaModels(config.backendUrl);
   } catch {
-    renderError(`Cannot reach Ollama at ${config.backendUrl}`);
-    renderInfo("Start Ollama with: ollama serve");
-    renderInfo("Or use /endpoint to configure a remote backend after startup.");
-    const answer = await ask(rl, `
-  ${c2.bold("Continue without Ollama?")} (y/n) `);
-    if (answer.toLowerCase() !== "y")
-      return null;
+    process.stdout.write(`  ${c2.yellow("\u26A0")} Cannot reach Ollama at ${c2.bold(config.backendUrl)}
+
+`);
+    const useWithout = await ask(rl, `  ${c2.bold("Use without Ollama?")} (y/n) `);
+    if (useWithout.toLowerCase() === "y" || useWithout.toLowerCase() === "yes") {
+      const endpointResult = await promptForCustomEndpoint(config, rl);
+      if (endpointResult) {
+        return endpointResult;
+      }
+      usingCustomEndpoint = true;
+    } else {
+      process.stdout.write(`
+  ${c2.cyan("\u25CF")} Install Ollama: ${c2.bold(c2.cyan("https://ollama.com"))}
+`);
+      process.stdout.write(`    ${c2.dim("Linux:")}  curl -fsSL https://ollama.com/install.sh | sh
+`);
+      process.stdout.write(`    ${c2.dim("macOS:")}  brew install ollama
+`);
+      process.stdout.write(`    ${c2.dim("Then:")}   ollama serve
+
+`);
+      const startAnyway = await ask(rl, `  ${c2.bold("Start anyway?")} (y/n) `);
+      if (startAnyway.toLowerCase() !== "y" && startAnyway.toLowerCase() !== "yes") {
+        process.stdout.write(`
+  ${c2.dim("You can always configure an endpoint later with /endpoint")}
+
+`);
+      }
+      return config.model;
+    }
+  }
+  if (usingCustomEndpoint) {
     return config.model;
   }
   const currentModel = findModel(models, config.model);
@@ -15222,10 +15422,8 @@ async function startInteractive(config, repoPath) {
     const needsSetup = isFirstRun() || !await isModelAvailable(config);
     if (needsSetup && config.backendType === "ollama") {
       const setupModel = await runSetupWizard(config);
-      if (setupModel === null) {
-        process.exit(0);
-      }
-      config = { ...config, model: setupModel };
+      const freshConfig = loadConfig();
+      config = { ...config, ...freshConfig, model: setupModel ?? freshConfig.model };
     }
   }
   if (config.backendType === "ollama" && !config.model.startsWith("open-agents-")) {
@@ -15244,16 +15442,18 @@ async function startInteractive(config, repoPath) {
   if (!isResumed) {
     try {
       const healthUrl = config.backendType === "ollama" ? `${config.backendUrl}/api/tags` : `${config.backendUrl}/v1/models`;
-      const resp = await fetch(healthUrl, { signal: AbortSignal.timeout(1e4) });
+      const headers = {};
+      if (config.apiKey)
+        headers["Authorization"] = `Bearer ${config.apiKey}`;
+      const resp = await fetch(healthUrl, { headers, signal: AbortSignal.timeout(1e4) });
       if (!resp.ok)
         throw new Error(`HTTP ${resp.status}`);
     } catch {
-      renderError(`Cannot reach ${config.backendType} at ${config.backendUrl}`);
+      renderWarning(`Cannot reach ${config.backendType} at ${config.backendUrl}`);
       if (config.backendType === "ollama") {
         renderInfo("Start Ollama with: ollama serve");
       }
-      renderInfo("Use /endpoint to configure a different backend.");
-      process.exit(1);
+      renderInfo("Use /endpoint to configure a different backend. Starting anyway...");
     }
   }
   const carousel = new Carousel();
@@ -15757,10 +15957,8 @@ async function runWithTUI(task, config, repoPath) {
   const needsSetup = isFirstRun() || !await isModelAvailable(config);
   if (needsSetup && config.backendType === "ollama") {
     const setupModel = await runSetupWizard(config);
-    if (setupModel === null) {
-      process.exit(0);
-    }
-    config = { ...config, model: setupModel };
+    const freshConfig = loadConfig();
+    config = { ...config, ...freshConfig, model: setupModel ?? freshConfig.model };
   }
   if (config.backendType === "ollama" && !config.model.startsWith("open-agents-")) {
     try {
@@ -15773,15 +15971,18 @@ async function runWithTUI(task, config, repoPath) {
   }
   try {
     const healthUrl = config.backendType === "ollama" ? `${config.backendUrl}/api/tags` : `${config.backendUrl}/v1/models`;
-    const resp = await fetch(healthUrl, { signal: AbortSignal.timeout(1e4) });
+    const headers = {};
+    if (config.apiKey)
+      headers["Authorization"] = `Bearer ${config.apiKey}`;
+    const resp = await fetch(healthUrl, { headers, signal: AbortSignal.timeout(1e4) });
     if (!resp.ok)
       throw new Error(`HTTP ${resp.status}`);
   } catch {
-    renderError(`Cannot reach ${config.backendType} at ${config.backendUrl}`);
+    renderWarning(`Cannot reach ${config.backendType} at ${config.backendUrl}`);
     if (config.backendType === "ollama") {
       renderInfo("Start Ollama with: ollama serve");
     }
-    process.exit(1);
+    renderInfo("The agent will retry when you submit a task. Use /endpoint to reconfigure.");
   }
   renderCompactHeader(config.model);
   renderUserMessage(task);
@@ -15800,6 +16001,7 @@ var init_interactive = __esm({
     init_dist5();
     init_dist2();
     init_listen();
+    init_config();
     init_updater();
     init_commands();
     init_setup();

package/package.json

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