@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/executors/auggie.js

@@ -0,0 +1,437 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+import { BaseExecutor } from "./base.ts";
+import { buildErrorBody, errorResponse, sanitizeErrorMessage } from "../utils/error.js";
+import { auggieProvider } from "../config/providers/registry/auggie/index.ts";
+const AUGGIE_URL = "auggie://cli/stdio";
+const AUGGIE_MODEL_ALLOWLIST = new Set(auggieProvider.models.map((m) => m.id));
+const DEFAULT_AUGGIE_MODEL = auggieProvider.models[0]?.id ?? "claude-sonnet-4.6";
+function resolveAuggieModel(model) {
+  const requested = typeof model === "string" ? model.trim() : "";
+  if (!requested) return { ok: true, model: DEFAULT_AUGGIE_MODEL };
+  if (requested.startsWith("-")) {
+    return {
+      ok: false,
+      error: `Invalid Auggie model "${requested}": model must not start with "-".`
+    };
+  }
+  if (!AUGGIE_MODEL_ALLOWLIST.has(requested)) {
+    return {
+      ok: false,
+      error: `Unknown Auggie model "${requested}". Supported models: ${[
+        ...AUGGIE_MODEL_ALLOWLIST
+      ].join(", ")}.`
+    };
+  }
+  return { ok: true, model: requested };
+}
+function buildAuggieArgs(model) {
+  return ["--print", "--quiet", "--model", model, "--"];
+}
+function resolveAuggieBin() {
+  const envBin = (process.env.AUGGIE_BIN || process.env.CLI_AUGGIE_BIN || "").trim();
+  if (envBin) return envBin;
+  const isWin = process.platform === "win32";
+  if (isWin) {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    const winPath = path.join(localAppData, "auggie", "bin", "auggie.exe");
+    if (fs.existsSync(winPath)) return winPath;
+  }
+  const home = os.homedir();
+  for (const candidate of [
+    path.join(home, ".local", "share", "auggie", "bin", "auggie"),
+    path.join(home, ".auggie", "bin", "auggie")
+  ]) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return isWin ? "auggie.cmd" : "auggie";
+}
+function buildAuggiePrompt(messages) {
+  const lines = [];
+  for (const m of messages) {
+    const role = String(m.role || "user");
+    let text = "";
+    if (typeof m.content === "string") {
+      text = m.content;
+    } else if (Array.isArray(m.content)) {
+      for (const p of m.content) {
+        if (p && typeof p === "object" && p.type === "text") {
+          text += String(p.text || "");
+        }
+      }
+    }
+    if (!text.trim()) continue;
+    if (role === "system") {
+      lines.push(`[System]
+${text}`);
+    } else if (role === "assistant") {
+      lines.push(`[Assistant]
+${text}`);
+    } else {
+      lines.push(`[User]
+${text}`);
+    }
+  }
+  return lines.join("\n\n") || "(empty)";
+}
+function isEnoentLike(message) {
+  return message.includes("ENOENT") || message.includes("not found");
+}
+function checkAuggieCliVersion(timeoutMs = 5e3) {
+  const bin = resolveAuggieBin();
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    let child;
+    try {
+      child = spawn(bin, ["--version"], {
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      settle({ ok: false, error: isEnoentLike(message) ? cliNotFoundMessage(bin) : message });
+      return;
+    }
+    const timer = setTimeout(() => {
+      if (!child.killed) child.kill("SIGKILL");
+      settle({ ok: false, error: "Auggie CLI version check timed out" });
+    }, timeoutMs);
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      const message = err?.message || String(err);
+      settle({ ok: false, error: isEnoentLike(message) ? cliNotFoundMessage(bin) : message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0 && stdout.trim()) {
+        settle({ ok: true, version: stdout.trim().slice(0, 200) });
+      } else {
+        settle({ ok: false, error: `Auggie CLI exited with code ${code}` });
+      }
+    });
+  });
+}
+function cliNotFoundMessage(bin) {
+  return sanitizeErrorMessage(
+    `Auggie CLI not found: ${bin}. Install it and run "auggie login", or set AUGGIE_BIN to an absolute path.`
+  );
+}
+class AuggieExecutor extends BaseExecutor {
+  constructor() {
+    super("auggie", { id: "auggie", baseUrl: "" });
+  }
+  buildUrl() {
+    return AUGGIE_URL;
+  }
+  buildHeaders() {
+    return {};
+  }
+  transformRequest() {
+    return null;
+  }
+  /** No-op — auggie has no OmniRoute-managed credentials to refresh. */
+  async refreshCredentials(_credentials) {
+    return null;
+  }
+  async execute({ model, body, stream, signal, log }) {
+    const b = body ?? {};
+    const messages = Array.isArray(b.messages) ? b.messages : [];
+    const promptText = buildAuggiePrompt(messages);
+    const auggieBin = resolveAuggieBin();
+    const wantsStream = stream !== false;
+    const modelResolution = resolveAuggieModel(model);
+    if (!modelResolution.ok) {
+      const response2 = wantsStream ? buildAuggieSseError(modelResolution.error) : errorResponse(400, modelResolution.error);
+      return { response: response2, url: AUGGIE_URL, headers: {}, transformedBody: { error: true } };
+    }
+    const safeModel = modelResolution.model;
+    log?.info?.(
+      "AUGGIE",
+      `auggie --print \u2192 model=${safeModel}, bin=${auggieBin}, stream=${wantsStream}`
+    );
+    const response = wantsStream ? this.runStreaming(auggieBin, safeModel, promptText, signal, log) : await this.runNonStreaming(auggieBin, safeModel, promptText, signal, log);
+    return {
+      response,
+      url: AUGGIE_URL,
+      headers: {},
+      transformedBody: { model: safeModel, promptLength: promptText.length }
+    };
+  }
+  spawnAuggie(auggieBin, model, promptText) {
+    const child = spawn(auggieBin, buildAuggieArgs(model), {
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    child.stdin.on("error", () => {
+    });
+    try {
+      child.stdin.write(promptText);
+      child.stdin.end();
+    } catch {
+    }
+    return child;
+  }
+  runStreaming(auggieBin, model, promptText, signal, log) {
+    const responseId = `chatcmpl-auggie-${Date.now()}`;
+    const created = Math.floor(Date.now() / 1e3);
+    const sseStream = new ReadableStream({
+      start(controller) {
+        const enc = new TextEncoder();
+        const emit = (data) => controller.enqueue(enc.encode(data));
+        let closed = false;
+        let roleEmitted = false;
+        let finished = false;
+        const finish = () => {
+          if (finished) return;
+          finished = true;
+          if (!closed) {
+            closed = true;
+            try {
+              controller.close();
+            } catch {
+            }
+          }
+        };
+        const emitDelta = (delta) => {
+          if (!delta) return;
+          if (!roleEmitted) {
+            emit(
+              `data: ${JSON.stringify({
+                id: responseId,
+                object: "chat.completion.chunk",
+                created,
+                model,
+                choices: [
+                  { index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }
+                ]
+              })}
+
+`
+            );
+            roleEmitted = true;
+          }
+          emit(
+            `data: ${JSON.stringify({
+              id: responseId,
+              object: "chat.completion.chunk",
+              created,
+              model,
+              choices: [{ index: 0, delta: { content: delta }, finish_reason: null }]
+            })}
+
+`
+          );
+        };
+        const emitError = (message) => {
+          emit(`data: ${JSON.stringify(buildErrorBody(502, message))}
+
+`);
+          emit("data: [DONE]\n\n");
+          finish();
+        };
+        const emitStop = () => {
+          emit(
+            `data: ${JSON.stringify({
+              id: responseId,
+              object: "chat.completion.chunk",
+              created,
+              model,
+              choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+            })}
+
+`
+          );
+          emit("data: [DONE]\n\n");
+          finish();
+        };
+        let child;
+        try {
+          child = spawn(auggieBin, buildAuggieArgs(model), {
+            env: process.env,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          emitError(
+            isEnoentLike(message) ? cliNotFoundMessage(auggieBin) : sanitizeErrorMessage(message)
+          );
+          return;
+        }
+        child.stdin.on("error", () => {
+        });
+        try {
+          child.stdin.write(promptText);
+          child.stdin.end();
+        } catch {
+        }
+        if (signal) {
+          signal.addEventListener("abort", () => {
+            if (!child.killed) child.kill("SIGTERM");
+            finish();
+          });
+        }
+        child.on("error", (err) => {
+          const message = err?.message || String(err);
+          emitError(
+            isEnoentLike(message) ? cliNotFoundMessage(auggieBin) : sanitizeErrorMessage(message)
+          );
+        });
+        let stderrTail = "";
+        child.stdout?.on("data", (chunk) => {
+          emitDelta(chunk.toString("utf8"));
+        });
+        child.stderr?.on("data", (chunk) => {
+          stderrTail = (stderrTail + chunk.toString("utf8")).slice(-2e3);
+          log?.debug?.("AUGGIE", `stderr: ${chunk.toString("utf8").slice(0, 200)}`);
+        });
+        child.on("close", (code) => {
+          if (finished) return;
+          if (code !== 0) {
+            emitError(
+              sanitizeErrorMessage(
+                `Auggie CLI exited with code ${code}${stderrTail ? `: ${stderrTail}` : ""}`
+              )
+            );
+            return;
+          }
+          emitStop();
+        });
+      },
+      cancel() {
+      }
+    });
+    return new Response(sseStream, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  runNonStreaming(auggieBin, model, promptText, signal, log) {
+    return new Promise((resolve) => {
+      let child;
+      try {
+        child = this.spawnAuggie(auggieBin, model, promptText);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        resolve(
+          buildAuggieErrorResponse(
+            isEnoentLike(message) ? cliNotFoundMessage(auggieBin) : sanitizeErrorMessage(message)
+          )
+        );
+        return;
+      }
+      let stdout = "";
+      let stderrTail = "";
+      let settled = false;
+      const settle = (response) => {
+        if (settled) return;
+        settled = true;
+        resolve(response);
+      };
+      if (signal) {
+        signal.addEventListener("abort", () => {
+          if (!child.killed) child.kill("SIGTERM");
+          settle(buildAuggieErrorResponse(sanitizeErrorMessage("Auggie CLI request aborted")));
+        });
+      }
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString("utf8");
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderrTail = (stderrTail + chunk.toString("utf8")).slice(-2e3);
+        log?.debug?.("AUGGIE", `stderr: ${chunk.toString("utf8").slice(0, 200)}`);
+      });
+      child.on("error", (err) => {
+        const message = err?.message || String(err);
+        settle(
+          buildAuggieErrorResponse(
+            isEnoentLike(message) ? cliNotFoundMessage(auggieBin) : sanitizeErrorMessage(message)
+          )
+        );
+      });
+      child.on("close", (code) => {
+        if (code !== 0) {
+          settle(
+            buildAuggieErrorResponse(
+              sanitizeErrorMessage(
+                `Auggie CLI exited with code ${code}${stderrTail ? `: ${stderrTail}` : ""}`
+              )
+            )
+          );
+          return;
+        }
+        settle(buildChatCompletionResponse(model, promptText, stdout));
+      });
+    });
+  }
+}
+function buildChatCompletionResponse(model, promptText, content) {
+  const trimmed = content.trim();
+  const body = {
+    id: `chatcmpl-auggie-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [
+      {
+        index: 0,
+        message: { role: "assistant", content: trimmed },
+        finish_reason: "stop"
+      }
+    ],
+    usage: {
+      prompt_tokens: Math.ceil(promptText.length / 4),
+      completion_tokens: Math.ceil(trimmed.length / 4),
+      total_tokens: Math.ceil((promptText.length + trimmed.length) / 4),
+      estimated: true
+    }
+  };
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function buildAuggieErrorResponse(message) {
+  return errorResponse(502, message);
+}
+function buildAuggieSseError(message) {
+  const enc = new TextEncoder();
+  const sseStream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(enc.encode(`data: ${JSON.stringify(buildErrorBody(400, message))}
+
+`));
+      controller.enqueue(enc.encode("data: [DONE]\n\n"));
+      controller.close();
+    }
+  });
+  return new Response(sseStream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+export {
+  AuggieExecutor,
+  buildAuggiePrompt,
+  checkAuggieCliVersion,
+  resolveAuggieBin,
+  resolveAuggieModel
+};

package/open-sse/executors/azure-openai.js

@@ -0,0 +1,32 @@
+import { DefaultExecutor } from "./default.ts";
+import { stripTrailingSlashes } from "../utils/urlSanitize.ts";
+const DEFAULT_API_VERSION = "2024-12-01-preview";
+function normalizeAzureBaseUrl(rawBaseUrl) {
+  const normalized = stripTrailingSlashes((rawBaseUrl || "").trim());
+  if (!normalized) return "";
+  return normalized.replace(/\/openai$/i, "").replace(/\/openai\/deployments\/[^/]+\/chat\/completions[^/]*$/i, "");
+}
+class AzureOpenAIExecutor extends DefaultExecutor {
+  constructor() {
+    super("azure-openai");
+  }
+  buildUrl(model, stream, urlIndex = 0, credentials = null) {
+    void urlIndex;
+    const providerSpecificData = credentials?.providerSpecificData || {};
+    const baseUrl = normalizeAzureBaseUrl(providerSpecificData.baseUrl || this.config.baseUrl);
+    const apiVersion = typeof providerSpecificData.apiVersion === "string" && providerSpecificData.apiVersion.trim() ? providerSpecificData.apiVersion.trim() : DEFAULT_API_VERSION;
+    return `${baseUrl}/openai/deployments/${encodeURIComponent(model)}/chat/completions?api-version=${encodeURIComponent(apiVersion)}`;
+  }
+  buildHeaders(credentials, stream = true) {
+    const apiKey = credentials?.apiKey || credentials?.accessToken || "";
+    const headers = {
+      "Content-Type": "application/json",
+      "api-key": apiKey
+    };
+    headers.Accept = stream ? "text/event-stream" : "application/json";
+    return headers;
+  }
+}
+export {
+  AzureOpenAIExecutor
+};

package/open-sse/executors/azure.js

@@ -0,0 +1,57 @@
+import { DefaultExecutor } from "./default.js";
+
+export class AzureExecutor extends DefaultExecutor {
+  constructor() {
+    super("azure");
+  }
+
+  buildUrl(model, stream, urlIndex = 0, credentials = null) {
+    const azureEndpoint = credentials?.providerSpecificData?.azureEndpoint
+      || process.env.AZURE_ENDPOINT
+      || "https://api.openai.com";
+
+    const apiVersion = credentials?.providerSpecificData?.apiVersion
+      || process.env.AZURE_API_VERSION
+      || "2024-10-01-preview";
+
+    const deployment = credentials?.providerSpecificData?.deployment
+      || model
+      || process.env.AZURE_DEPLOYMENT
+      || "gpt-4";
+
+    const endpoint = azureEndpoint.replace(/\/$/, "");
+    return `${endpoint}/openai/deployments/${deployment}/chat/completions?api-version=${apiVersion}`;
+  }
+
+  buildHeaders(credentials, stream = true) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+
+    const apiKey = credentials?.apiKey
+      || credentials?.accessToken
+      || process.env.OPENAI_API_KEY;
+
+    if (apiKey) {
+      headers["api-key"] = apiKey;
+    }
+
+    const organization = credentials?.providerSpecificData?.organization
+      || process.env.AZURE_ORGANIZATION;
+
+    if (organization) {
+      headers["OpenAI-Organization"] = organization;
+    }
+
+    if (stream) {
+      headers["Accept"] = "text/event-stream";
+    }
+
+    return headers;
+  }
+
+  transformRequest(model, body, stream, credentials) {
+    return body;
+  }
+}

package/open-sse/executors/base.js

@@ -0,0 +1,181 @@
+import { HTTP_STATUS, RETRY_CONFIG, DEFAULT_RETRY_CONFIG, resolveRetryEntry, FETCH_CONNECT_TIMEOUT_MS } from "../config/runtimeConfig.js";
+import { shouldRefreshCredentials } from "../services/oauthCredentialManager.js";
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { dbg } from "../utils/debugLog.js";
+
+/**
+ * BaseExecutor - Base class for provider executors
+ */
+export class BaseExecutor {
+  constructor(provider, config) {
+    this.provider = provider;
+    this.config = config;
+    this.noAuth = config?.noAuth || false;
+  }
+
+  getProvider() {
+    return this.provider;
+  }
+
+  getBaseUrls() {
+    return this.config.baseUrls || (this.config.baseUrl ? [this.config.baseUrl] : []);
+  }
+
+  getFallbackCount() {
+    return this.getBaseUrls().length || 1;
+  }
+
+  buildUrl(model, stream, urlIndex = 0, credentials = null) {
+    if (this.provider?.startsWith?.("openai-compatible-")) {
+      const baseUrl = credentials?.providerSpecificData?.baseUrl || "https://api.openai.com/v1";
+      const normalized = baseUrl.replace(/\/$/, "");
+      const path = this.provider.includes("responses") ? "/responses" : "/chat/completions";
+      return `${normalized}${path}`;
+    }
+    if (this.provider?.startsWith?.("anthropic-compatible-")) {
+      const baseUrl = credentials?.providerSpecificData?.baseUrl || "https://api.anthropic.com/v1";
+      const normalized = baseUrl.replace(/\/$/, "");
+      return `${normalized}/messages`;
+    }
+    const baseUrls = this.getBaseUrls();
+    return baseUrls[urlIndex] || baseUrls[0] || this.config.baseUrl;
+  }
+
+  buildHeaders(credentials, stream = true) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+
+    if (this.provider?.startsWith?.("anthropic-compatible-")) {
+      // Anthropic-compatible providers use x-api-key header
+      if (credentials.apiKey) {
+        headers["x-api-key"] = credentials.apiKey;
+      } else if (credentials.accessToken) {
+        headers["Authorization"] = `Bearer ${credentials.accessToken}`;
+      }
+      if (!headers["anthropic-version"]) {
+        headers["anthropic-version"] = "2023-06-01";
+      }
+    } else {
+      // Standard Bearer token auth for other providers
+      if (credentials.accessToken) {
+        headers["Authorization"] = `Bearer ${credentials.accessToken}`;
+      } else if (credentials.apiKey) {
+        headers["Authorization"] = `Bearer ${credentials.apiKey}`;
+      }
+    }
+
+    if (stream) {
+      headers["Accept"] = "text/event-stream";
+    }
+
+    return headers;
+  }
+
+  // Override in subclass for provider-specific transformations
+  transformRequest(model, body, stream, credentials) {
+    return body;
+  }
+
+  shouldRetry(status, urlIndex) {
+    return status === HTTP_STATUS.RATE_LIMITED && urlIndex + 1 < this.getFallbackCount();
+  }
+
+  // Override in subclass for provider-specific refresh
+  async refreshCredentials(credentials, log, proxyOptions = null) {
+    return null;
+  }
+
+  needsRefresh(credentials) {
+    return shouldRefreshCredentials(this.provider, credentials);
+  }
+
+  parseError(response, bodyText) {
+    return { status: response.status, message: bodyText || `HTTP ${response.status}` };
+  }
+
+  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
+    const fallbackCount = this.getFallbackCount();
+    let lastError = null;
+    let lastStatus = 0;
+    const retryAttemptsByUrl = {};
+
+    // Merge default retry config with provider-specific config
+    const retryConfig = { ...DEFAULT_RETRY_CONFIG, ...this.config.retry };
+
+    // Schedule retry via retryConfig[statusKey]. Returns true when caller should `urlIndex--; continue`
+    const tryRetry = async (urlIndex, statusKey, reason) => {
+      // Don't retry internally on the same URL for 429/403 (account exhaustion)
+      // Allow fallback to next URL or account rotation instead
+      if (statusKey === HTTP_STATUS.RATE_LIMITED || statusKey === HTTP_STATUS.FORBIDDEN) return false;
+
+      const { attempts, delayMs } = resolveRetryEntry(retryConfig[statusKey]);
+      if (attempts <= 0 || retryAttemptsByUrl[urlIndex] >= attempts) return false;
+      retryAttemptsByUrl[urlIndex]++;
+      log?.debug?.("RETRY", `${reason} retry ${retryAttemptsByUrl[urlIndex]}/${attempts} after ${delayMs / 1000}s`);
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+      return true;
+    };
+
+    for (let urlIndex = 0; urlIndex < fallbackCount; urlIndex++) {
+      const url = this.buildUrl(model, stream, urlIndex, credentials);
+      const transformedBody = this.transformRequest(model, body, stream, credentials);
+      const headers = this.buildHeaders(credentials, stream);
+
+      if (!retryAttemptsByUrl[urlIndex]) retryAttemptsByUrl[urlIndex] = 0;
+
+      // Abort if upstream doesn't return response headers within connection timeout
+      const connectCtrl = new AbortController();
+      const timeoutMs = this.config?.timeoutMs || FETCH_CONNECT_TIMEOUT_MS;
+      const connectTimer = setTimeout(() => connectCtrl.abort(new Error("fetch connect timeout")), timeoutMs);
+      const mergedSignal = signal ? AbortSignal.any([signal, connectCtrl.signal]) : connectCtrl.signal;
+
+      try {
+        const bodyStr = JSON.stringify(transformedBody);
+        const fetchT0 = Date.now();
+        dbg("FETCH", `${this.provider.toUpperCase()} → ${url} | body=${bodyStr.length}B | connectTimeout=${timeoutMs}ms`);
+        const response = await proxyAwareFetch(url, {
+          method: "POST",
+          headers,
+          body: bodyStr,
+          signal: mergedSignal
+        }, proxyOptions);
+        clearTimeout(connectTimer);
+        const ct = response.headers?.get?.("content-type") || "";
+        const cl = response.headers?.get?.("content-length") || "?";
+        dbg("FETCH", `${this.provider.toUpperCase()} ← ${response.status} | ttft=${Date.now() - fetchT0}ms | ct=${ct} | cl=${cl}`);
+
+        if (await tryRetry(urlIndex, response.status, `status ${response.status}`)) { urlIndex--; continue; }
+
+        if (this.shouldRetry(response.status, urlIndex)) {
+          log?.debug?.("RETRY", `${response.status} on ${url}, trying fallback ${urlIndex + 1}`);
+          lastStatus = response.status;
+          continue;
+        }
+
+        return { response, url, headers, transformedBody };
+      } catch (error) {
+        clearTimeout(connectTimer);
+        lastError = error;
+        const isConnectTimeout = connectCtrl.signal.aborted && error.name === "AbortError";
+        dbg("FETCH", `${this.provider.toUpperCase()} ✖ ${error.name}: ${error.message}${isConnectTimeout ? " (connect timeout)" : ""}`);
+        // Connect timeout is internal — convert to retryable network error, don't propagate AbortError
+        if (error.name === "AbortError" && !isConnectTimeout) throw error;
+
+        // Map network/fetch exceptions to 502 retry config
+        if (await tryRetry(urlIndex, HTTP_STATUS.BAD_GATEWAY, `network "${error.message}"`)) { urlIndex--; continue; }
+
+        if (urlIndex + 1 < fallbackCount) {
+          log?.debug?.("RETRY", `Error on ${url}, trying fallback ${urlIndex + 1}`);
+          continue;
+        }
+        throw error;
+      }
+    }
+
+    throw lastError || new Error(`All ${fallbackCount} URLs failed with status ${lastStatus}`);
+  }
+}
+
+export default BaseExecutor;