swayrouter 1.0.0

package/src/lib/grokBuildConfig.js

@@ -0,0 +1,243 @@
+export const GROK_MAIN_MODEL_SLOT = "swayrouter";
+export const GROK_BUILTIN_DEFAULT = "grok-build";
+export const GROK_SUBAGENT_TYPES = ["general-purpose", "explore", "plan"];
+
+const UNSET_SENTINEL = "__swayrouter_unset__";
+const MODELS_SECTION = "models";
+const SUBAGENT_MODELS_SECTION = "subagents.models";
+
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const tomlString = (value) => JSON.stringify(String(value));
+
+const sectionRegExp = (section) =>
+  new RegExp(
+    `^\\[${escapeRegExp(section)}\\][ \\t]*\\r?\\n((?:(?!\\[)[^\\r\\n]*\\r?\\n?)*)`,
+    "m",
+  );
+
+const modelSlot = (type) => `${GROK_MAIN_MODEL_SLOT}-${type}`;
+
+const previousDefaultRegExp = /^# swayrouter-prev-default = "([^"]*)"[ \t]*\r?\n?/m;
+const previousSubagentRegExp = (type) =>
+  new RegExp(
+    `^# swayrouter-prev-subagent-${escapeRegExp(type)} = "([^"]*)"[ \\t]*\\r?\\n?`,
+    "m",
+  );
+
+function getSectionField(toml, section, key) {
+  const match = toml.match(sectionRegExp(section));
+  if (!match) return null;
+  const field = match[1].match(
+    new RegExp(`^[ \\t]*${escapeRegExp(key)}[ \\t]*=[ \\t]*"([^"]*)"`, "m"),
+  );
+  return field ? field[1] : null;
+}
+
+function getSectionNumber(toml, section, key) {
+  const match = toml.match(sectionRegExp(section));
+  if (!match) return null;
+  const field = match[1].match(
+    new RegExp(`^[ \\t]*${escapeRegExp(key)}[ \\t]*=[ \\t]*([0-9]+(?:\\.[0-9]+)?)`, "m"),
+  );
+  if (!field) return null;
+  const value = Number(field[1]);
+  return Number.isFinite(value) ? value : null;
+}
+
+function setSectionField(toml, section, key, value) {
+  const match = toml.match(sectionRegExp(section));
+  const line = `${key} = ${tomlString(value)}`;
+  if (!match) {
+    const prefix = toml.length > 0 && !toml.endsWith("\n") ? `${toml}\n` : toml;
+    return `${prefix}\n[${section}]\n${line}\n`;
+  }
+
+  const body = match[1] || "";
+  const fieldRegExp = new RegExp(
+    `^[ \\t]*${escapeRegExp(key)}[ \\t]*=[ \\t]*"[^"]*"`,
+    "m",
+  );
+  const nextBody = fieldRegExp.test(body)
+    ? body.replace(fieldRegExp, line)
+    : `${line}\n${body}`;
+  return toml.replace(match[0], `[${section}]\n${nextBody}`);
+}
+
+function deleteSectionField(toml, section, key) {
+  const match = toml.match(sectionRegExp(section));
+  if (!match) return toml;
+  const fieldRegExp = new RegExp(
+    `^[ \\t]*${escapeRegExp(key)}[ \\t]*=[^\\r\\n]*\\r?\\n?`,
+    "m",
+  );
+  const nextBody = (match[1] || "").replace(fieldRegExp, "");
+  if (!nextBody.trim()) return toml.replace(match[0], "").replace(/\n{3,}/g, "\n\n");
+  return toml.replace(match[0], `[${section}]\n${nextBody}`);
+}
+
+function parseModelSection(toml, slot) {
+  const match = toml.match(sectionRegExp(`model.${slot}`));
+  if (!match) return null;
+  const body = match[1] || "";
+  const contextWindow = getSectionNumber(toml, `model.${slot}`, "context_window");
+  return {
+    model: getSectionField(toml, `model.${slot}`, "model"),
+    base_url: getSectionField(toml, `model.${slot}`, "base_url"),
+    name: getSectionField(toml, `model.${slot}`, "name"),
+    api_key: getSectionField(toml, `model.${slot}`, "api_key"),
+    api_backend: getSectionField(toml, `model.${slot}`, "api_backend"),
+    context_window: Number.isFinite(contextWindow) && contextWindow > 0 ? contextWindow : null,
+    raw: body,
+  };
+}
+
+function buildModelSection({ slot, model, baseUrl, apiKey, contextWindow, name }) {
+  const lines = [
+    `[model.${slot}]`,
+    `model = ${tomlString(model)}`,
+    `base_url = ${tomlString(baseUrl)}`,
+    `name = ${tomlString(name)}`,
+    `description = ${tomlString("Routed via Sway Router gateway")}`,
+    `api_backend = "chat_completions"`,
+  ];
+  if (apiKey) lines.push(`api_key = ${tomlString(apiKey)}`);
+  if (Number.isFinite(contextWindow) && contextWindow > 0) {
+    lines.push(`context_window = ${Math.floor(contextWindow)}`);
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+function upsertModelSection(toml, config) {
+  const regexp = sectionRegExp(`model.${config.slot}`);
+  const section = buildModelSection(config);
+  if (regexp.test(toml)) return toml.replace(regexp, section);
+  const prefix = toml.length > 0 && !toml.endsWith("\n") ? `${toml}\n` : toml;
+  return `${prefix}\n${section}`;
+}
+
+function removeModelSection(toml, slot) {
+  return toml.replace(sectionRegExp(`model.${slot}`), "").replace(/\n{3,}/g, "\n\n");
+}
+
+function insertMarker(toml, marker) {
+  const mainSection = sectionRegExp(`model.${GROK_MAIN_MODEL_SLOT}`);
+  if (mainSection.test(toml)) {
+    return toml.replace(mainSection, (section) => `${marker}${section}`);
+  }
+  const prefix = toml.length > 0 && !toml.endsWith("\n") ? `${toml}\n` : toml;
+  return `${prefix}${marker}`;
+}
+
+function rememberPreviousDefault(toml) {
+  if (previousDefaultRegExp.test(toml)) return toml;
+  const current = getSectionField(toml, MODELS_SECTION, "default");
+  if (!current || current === GROK_MAIN_MODEL_SLOT) return toml;
+  return insertMarker(toml, `# swayrouter-prev-default = ${tomlString(current)}\n`);
+}
+
+function restorePreviousDefault(toml) {
+  const previous = toml.match(previousDefaultRegExp)?.[1] || GROK_BUILTIN_DEFAULT;
+  let next = toml.replace(previousDefaultRegExp, "");
+  if (getSectionField(next, MODELS_SECTION, "default") === GROK_MAIN_MODEL_SLOT) {
+    next = setSectionField(next, MODELS_SECTION, "default", previous);
+  }
+  return next;
+}
+
+function rememberPreviousSubagent(toml, type) {
+  const regexp = previousSubagentRegExp(type);
+  if (regexp.test(toml)) return toml;
+  const current = getSectionField(toml, SUBAGENT_MODELS_SECTION, type);
+  const previous = current == null ? UNSET_SENTINEL : current;
+  return insertMarker(
+    toml,
+    `# swayrouter-prev-subagent-${type} = ${tomlString(previous)}\n`,
+  );
+}
+
+function restorePreviousSubagent(toml, type) {
+  const regexp = previousSubagentRegExp(type);
+  const previous = toml.match(regexp)?.[1] || UNSET_SENTINEL;
+  let next = toml.replace(regexp, "");
+  if (getSectionField(next, SUBAGENT_MODELS_SECTION, type) !== modelSlot(type)) {
+    return next;
+  }
+  if (previous === UNSET_SENTINEL) {
+    return deleteSectionField(next, SUBAGENT_MODELS_SECTION, type);
+  }
+  return setSectionField(next, SUBAGENT_MODELS_SECTION, type, previous);
+}
+
+export function parseGrokBuildConfig(toml) {
+  const subagentModels = {};
+  const subagentMappings = {};
+  for (const type of GROK_SUBAGENT_TYPES) {
+    const mapping = getSectionField(toml, SUBAGENT_MODELS_SECTION, type);
+    subagentMappings[type] = mapping;
+    subagentModels[type] = mapping === modelSlot(type)
+      ? parseModelSection(toml, mapping)
+      : null;
+  }
+
+  return {
+    model: parseModelSection(toml, GROK_MAIN_MODEL_SLOT),
+    default: getSectionField(toml, MODELS_SECTION, "default"),
+    subagentModels,
+    subagentMappings,
+  };
+}
+
+export function applyGrokBuildConfig(
+  toml,
+  { baseUrl, apiKey, model, contextWindow, subagentModels },
+) {
+  let next = rememberPreviousDefault(toml);
+  next = upsertModelSection(next, {
+    slot: GROK_MAIN_MODEL_SLOT,
+    model,
+    baseUrl,
+    apiKey,
+    contextWindow,
+    name: "Sway Router",
+  });
+  next = setSectionField(next, MODELS_SECTION, "default", GROK_MAIN_MODEL_SLOT);
+
+  if (subagentModels && typeof subagentModels === "object") {
+    for (const type of GROK_SUBAGENT_TYPES) {
+      const selected = subagentModels[type];
+      const slot = modelSlot(type);
+      if (selected?.model) {
+        next = rememberPreviousSubagent(next, type);
+        next = upsertModelSection(next, {
+          slot,
+          model: selected.model,
+          baseUrl,
+          apiKey,
+          contextWindow: selected.contextWindow,
+          name: `Sway Router ${type}`,
+        });
+        next = setSectionField(next, SUBAGENT_MODELS_SECTION, type, slot);
+      } else {
+        next = restorePreviousSubagent(next, type);
+        next = removeModelSection(next, slot);
+      }
+    }
+  }
+
+  return next;
+}
+
+export function resetGrokBuildConfig(toml) {
+  let next = toml;
+  for (const type of GROK_SUBAGENT_TYPES) {
+    next = restorePreviousSubagent(next, type);
+    next = removeModelSection(next, modelSlot(type));
+  }
+  next = removeModelSection(next, GROK_MAIN_MODEL_SLOT);
+  next = restorePreviousDefault(next);
+  return next.replace(/\n{3,}/g, "\n\n");
+}
+
+export function getGrokSubagentSlot(type) {
+  return GROK_SUBAGENT_TYPES.includes(type) ? modelSlot(type) : null;
+}

package/src/lib/guardRequest.js

@@ -0,0 +1,51 @@
+import { createCookieStore } from "@/next/server";
+
+export function parseCookies(header) {
+  const out = new Map();
+  if (!header) return out;
+  for (const part of header.split(";")) {
+    const i = part.indexOf("=");
+    if (i === -1) continue;
+    const name = part.slice(0, i).trim();
+    const value = part.slice(i + 1).trim();
+    if (name) {
+      try {
+        out.set(name, decodeURIComponent(value));
+      } catch {
+        out.set(name, value);
+      }
+    }
+  }
+  return out;
+}
+
+export function createRequestContext(raw) {
+  const url = new URL(raw.url);
+  const map = parseCookies(raw.headers.get("cookie") || "");
+  const store = {
+    cookies: createCookieStore(map),
+    headers: raw.headers,
+  };
+
+  const guardRequest = new Proxy(raw, {
+    get(t, p) {
+      if (p === "nextUrl") {
+        return {
+          pathname: url.pathname,
+          searchParams: url.searchParams,
+          search: url.search,
+          toString: () => raw.url,
+        };
+      }
+      if (p === "cookies") {
+        return {
+          get: (name) => (map.has(name) ? { name, value: map.get(name) } : undefined),
+          getAll: () => [...map.entries()].map(([name, value]) => ({ name, value })),
+        };
+      }
+      return Reflect.get(t, p);
+    },
+  });
+
+  return { store, guardRequest };
+}

package/src/lib/localDb.js

@@ -0,0 +1,21 @@
+export {
+  getSettings, updateSettings, isCloudEnabled, getCloudUrl,
+  getProviderConnections, getProviderConnectionById, getProviderConnectionsForRouting, getActiveProviderRows,
+  getProviderConnectionsPaged, countProviderConnections,
+  countConnectionsByProxyPool,
+  createProviderConnection, updateProviderConnection,
+  deleteProviderConnection, deleteProviderConnectionsByProvider,
+  reorderProviderConnections, cleanupProviderConnections,
+  getProviderNodes, getProviderNodeById,
+  createProviderNode, updateProviderNode, deleteProviderNode,
+  getProxyPools, getProxyPoolById,
+  createProxyPool, updateProxyPool, deleteProxyPool,
+  getApiKeys, getApiKeyById, getActiveApiKey, getApiKeySecretById, createApiKey, updateApiKey, deleteApiKey, rotateApiKey, validateApiKey,
+  getCombos, getComboById, getComboByName,
+  createCombo, updateCombo, deleteCombo,
+  getCustomModels, addCustomModel, deleteCustomModel,
+  getPricing, getPricingForModel, updatePricing, resetPricing, resetAllPricing,
+  exportDb, importDb,
+} from "@/lib/db/index.js";
+export { flushUsageBuffer } from "@/lib/db/repos/usageRepo.js";
+export { flushRequestDetails } from "@/lib/db/repos/requestDetailsRepo.js";

package/src/lib/mcp/stdioSseBridge.js

@@ -0,0 +1,174 @@
+const { spawn } = require("child_process");
+const crypto = require("crypto");
+const { LOCAL_STDIO_PLUGINS } = require("@/shared/constants/coworkPlugins");
+
+const G_KEY = "__swayrouterMcpBridges";
+const MAX_TEXT_CHARS = 50000;
+const COLLAPSE_THRESHOLD = 30;
+const COLLAPSE_KEEP_HEAD = 10;
+const COLLAPSE_KEEP_TAIL = 5;
+
+function smartFilterText(text) {
+  if (typeof text !== "string" || text.length < 2000) return text;
+  let out = text;
+  out = out.replace(/^\s*-\s*generic:?\s*$/gm, "");
+  out = out.replace(/^\s*-\s*text:\s*""\s*$/gm, "");
+  out = collapseRepeated(out);
+  if (out.length > MAX_TEXT_CHARS) {
+    const head = out.slice(0, MAX_TEXT_CHARS - 300);
+    out = `${head}\n\n... [truncated ${text.length - head.length} chars by swayrouter bridge. Page is large; ask user to scroll/navigate to a specific section, or click an element with the refs shown above]`;
+  }
+  return out;
+}
+
+function collapseRepeated(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const m = line.match(/^(\s*)-\s*([a-zA-Z]+)\b/);
+    if (!m) { out.push(line); i++; continue; }
+    const indent = m[1];
+    const role = m[2];
+    let j = i;
+    while (j < lines.length) {
+      const ln = lines[j];
+      const mm = ln.match(/^(\s*)-\s*([a-zA-Z]+)\b/);
+      if (mm && mm[1] === indent && mm[2] === role) { j++; continue; }
+      if (ln.startsWith(`${indent} `) || ln.startsWith(`${indent}\t`)) { j++; continue; }
+      break;
+    }
+    const groupLen = j - i;
+    if (groupLen >= COLLAPSE_THRESHOLD) {
+      const headEnd = findNthSiblingEnd(lines, i, indent, role, COLLAPSE_KEEP_HEAD);
+      const tailStart = findLastNSiblingStart(lines, j, indent, role, COLLAPSE_KEEP_TAIL);
+      for (let k = i; k < headEnd; k++) out.push(lines[k]);
+      out.push(`${indent}... [${groupLen - COLLAPSE_KEEP_HEAD - COLLAPSE_KEEP_TAIL} similar "${role}" items omitted by swayrouter bridge]`);
+      for (let k = tailStart; k < j; k++) out.push(lines[k]);
+    } else {
+      for (let k = i; k < j; k++) out.push(lines[k]);
+    }
+    i = j;
+  }
+  return out.join("\n");
+}
+
+function findNthSiblingEnd(lines, start, indent, role, n) {
+  let count = 0;
+  for (let k = start; k < lines.length; k++) {
+    const mm = lines[k].match(/^(\s*)-\s*([a-zA-Z]+)\b/);
+    if (mm && mm[1] === indent && mm[2] === role) {
+      count++;
+      if (count > n) return k;
+    }
+  }
+  return lines.length;
+}
+
+function findLastNSiblingStart(lines, end, indent, role, n) {
+  const positions = [];
+  for (let k = 0; k < end; k++) {
+    const mm = lines[k].match(/^(\s*)-\s*([a-zA-Z]+)\b/);
+    if (mm && mm[1] === indent && mm[2] === role) positions.push(k);
+  }
+  return positions.length > n ? positions[positions.length - n] : end;
+}
+
+function filterFrame(line) {
+  try {
+    const msg = JSON.parse(line);
+    const content = msg?.result?.content;
+    if (!Array.isArray(content)) return line;
+    let mutated = false;
+    for (const item of content) {
+      if (item?.type === "text" && typeof item.text === "string") {
+        const filtered = smartFilterText(item.text);
+        if (filtered !== item.text) { item.text = filtered; mutated = true; }
+      }
+    }
+    return mutated ? JSON.stringify(msg) : line;
+  } catch { return line; }
+}
+const getStore = () => {
+  if (!globalThis[G_KEY]) globalThis[G_KEY] = new Map();
+  return globalThis[G_KEY];
+};
+
+function findPlugin(name) {
+  return LOCAL_STDIO_PLUGINS.find((p) => p.name === name) || null;
+}
+
+function getOrSpawn(name) {
+  const store = getStore();
+  let entry = store.get(name);
+  if (entry?.proc && !entry.proc.killed && entry.proc.exitCode === null) return entry;
+
+  const plugin = findPlugin(name);
+  if (!plugin) throw new Error(`Unknown local plugin: ${name}`);
+
+  const proc = spawn(plugin.command, plugin.args, { stdio: ["pipe", "pipe", "pipe"], env: process.env });
+  entry = { proc, sessions: new Map(), buffer: "" };
+  store.set(name, entry);
+
+  proc.stdout.on("data", (chunk) => {
+    entry.buffer += chunk.toString("utf8");
+    let idx;
+    while ((idx = entry.buffer.indexOf("\n")) >= 0) {
+      const raw = entry.buffer.slice(0, idx).trim();
+      entry.buffer = entry.buffer.slice(idx + 1);
+      if (!raw) continue;
+      const line = filterFrame(raw);
+      for (const send of entry.sessions.values()) {
+        try { send(`event: message\ndata: ${line}\n\n`); } catch {                          }
+      }
+    }
+  });
+
+  proc.stderr.on("data", (d) => console.log(`[mcp:${name}]`, d.toString().trim()));
+  proc.on("exit", (code) => {
+    console.log(`[mcp:${name}] exited`, code);
+    store.delete(name);
+  });
+
+  return entry;
+}
+
+function registerSession(name, sendFn) {
+  const entry = getOrSpawn(name);
+  const sid = crypto.randomUUID();
+  entry.sessions.set(sid, sendFn);
+  return sid;
+}
+
+function unregisterSession(name, sid) {
+  const entry = getStore().get(name);
+  if (!entry) return;
+  entry.sessions.delete(sid);
+
+  if (entry.sessions.size === 0) {
+    try { entry.proc.kill(); } catch {              }
+    getStore().delete(name);
+  }
+}
+
+function killAllBridges() {
+  const store = getStore();
+  for (const [name, entry] of store) {
+    try { entry.proc.kill(); } catch {              }
+    store.delete(name);
+  }
+}
+
+function sendToChild(name, jsonRpc) {
+  const entry = getStore().get(name);
+  if (!entry?.proc?.stdin?.writable) throw new Error(`Bridge not running: ${name}`);
+  entry.proc.stdin.write(`${JSON.stringify(jsonRpc)}\n`);
+}
+
+function isRunning(name) {
+  const entry = getStore().get(name);
+  return !!(entry?.proc && !entry.proc.killed && entry.proc.exitCode === null);
+}
+
+module.exports = { getOrSpawn, registerSession, unregisterSession, sendToChild, isRunning, findPlugin, killAllBridges };

package/src/lib/network/connectionProxy.js

@@ -0,0 +1,200 @@
+import { getProxyPoolById } from "@/models";
+import { normalizeProxyUrl } from "./proxyUrl.js";
+import { isRelayProxyType, isSupportedProxyType } from "./relay.js";
+
+function normalizeString(value) {
+  if (value === undefined || value === null) return "";
+  return String(value).trim();
+}
+
+const rotateState = new Map();
+
+export function pickProxyPoolId(poolIds, strategy, providerId) {
+  if (!poolIds || poolIds.length === 0) return null;
+  if (poolIds.length === 1) return poolIds[0];
+
+  if (strategy === "round-robin") {
+    const state = rotateState.get(providerId) || { index: -1 };
+    state.index = (state.index + 1) % poolIds.length;
+    rotateState.set(providerId, state);
+    return poolIds[state.index];
+  }
+
+  if (strategy === "random") {
+    return poolIds[Math.floor(Math.random() * poolIds.length)];
+  }
+
+  return poolIds[0];
+}
+
+function normalizeLegacyProxy(providerSpecificData = {}) {
+  const connectionProxyEnabled =
+    providerSpecificData?.connectionProxyEnabled === true;
+
+  const connectionProxyUrl = normalizeString(
+    providerSpecificData?.connectionProxyUrl
+  );
+
+  const connectionNoProxy = normalizeString(
+    providerSpecificData?.connectionNoProxy
+  );
+
+  return {
+    connectionProxyEnabled,
+    connectionProxyUrl,
+    connectionNoProxy,
+  };
+}
+
+export async function resolveConnectionProxyConfig(
+  providerSpecificData = {}
+) {
+  try {
+    const proxyPoolIdRaw = normalizeString(
+      providerSpecificData?.proxyPoolId
+    );
+
+    const proxyPoolId =
+      proxyPoolIdRaw === "__none__" ? "" : proxyPoolIdRaw;
+
+    const legacy = normalizeLegacyProxy(providerSpecificData);
+
+    if (proxyPoolId) {
+      const proxyPool = await getProxyPoolById(proxyPoolId);
+      const proxyType = normalizeString(proxyPool?.type).toLowerCase();
+
+      const proxyUrlRaw = normalizeString(proxyPool?.proxyUrl);
+      const noProxy = normalizeString(proxyPool?.noProxy);
+      let proxyUrl = "";
+      try {
+        proxyUrl = normalizeProxyUrl(proxyUrlRaw, proxyPool?.type) || "";
+      } catch {
+        proxyUrl = "";
+      }
+
+      const isValidPool =
+        proxyPool &&
+        proxyPool.isActive === true &&
+        proxyPool.state !== "disabled" &&
+        isSupportedProxyType(proxyType) &&
+        proxyUrl;
+
+      if (isValidPool) {
+
+        if (isRelayProxyType(proxyPool.type)) {
+          return {
+            source: proxyPool.type,
+
+            proxyPoolId,
+            proxyPool,
+
+            connectionProxyEnabled: false,
+            connectionProxyUrl: "",
+            connectionNoProxy: noProxy,
+
+            strictProxy: proxyPool.strictProxy === true,
+
+            proxyPoolUnavailable: false,
+            proxyPoolError: "",
+
+            relayUrl: proxyUrl,
+            relayToken: normalizeString(proxyPool.relayToken),
+
+            vercelRelayUrl: proxyUrl,
+          };
+        }
+
+        return {
+          source: "pool",
+
+          proxyPoolId,
+          proxyPool,
+
+          connectionProxyEnabled: true,
+          connectionProxyUrl: proxyUrl,
+          connectionNoProxy: noProxy,
+
+          strictProxy: proxyPool.strictProxy === true,
+
+          proxyPoolUnavailable: false,
+          proxyPoolError: "",
+        };
+      }
+
+      const poolError = !proxyPool
+        ? "Proxy pool not found"
+        : proxyPool.isActive !== true
+          ? "Proxy pool is inactive"
+            : proxyPool.state === "disabled"
+              ? "Proxy pool is disabled"
+              : !isSupportedProxyType(proxyType)
+                ? "Proxy pool type is unsupported"
+              : !proxyUrl
+              ? "Proxy pool URL is invalid"
+              : "Proxy pool is unavailable";
+      if (!proxyPool || proxyPool.strictProxy === true) {
+        return {
+          source: "pool-error",
+
+          proxyPoolId,
+          proxyPool: proxyPool || null,
+
+          connectionProxyEnabled: false,
+          connectionProxyUrl: "",
+          connectionNoProxy: noProxy || legacy.connectionNoProxy,
+
+          strictProxy: true,
+          proxyPoolUnavailable: true,
+          proxyPoolError: poolError,
+        };
+      }
+    }
+
+    if (
+      legacy.connectionProxyEnabled &&
+      legacy.connectionProxyUrl
+    ) {
+      return {
+        source: "legacy",
+
+        proxyPoolId: proxyPoolId || null,
+        proxyPool: null,
+
+        proxyPoolUnavailable: false,
+        proxyPoolError: "",
+
+        ...legacy,
+      };
+    }
+
+    return {
+      source: "none",
+
+      proxyPoolId: proxyPoolId || null,
+      proxyPool: null,
+
+      proxyPoolUnavailable: Boolean(proxyPoolId),
+      proxyPoolError: proxyPoolId ? "Proxy pool is unavailable" : "",
+
+      ...legacy,
+    };
+  } catch (error) {
+    console.error(
+      "[resolveConnectionProxyConfig] Failed to resolve proxy config:",
+      error
+    );
+
+    return {
+      source: "error",
+
+      proxyPoolId: null,
+      proxyPool: null,
+
+      connectionProxyEnabled: false,
+      connectionProxyUrl: "",
+      connectionNoProxy: "",
+
+      strictProxy: false,
+    };
+  }
+}