@amir83nasr/10router 0.1.7 → 0.1.9

package/open-sse/handlers/chatCore/sseToJsonHandler.js

@@ -413,10 +413,17 @@ export async function handleForcedSSEToJson({
         "Invalid SSE response for non-streaming request",
       );
     if (parsed.error) {
-      return createErrorResult(
-        HTTP_STATUS.BAD_GATEWAY,
-        parsed.error.message || "Upstream SSE stream failed",
-      );
+      // Request-scoped errors (e.g. Zed context_length_exceeded, surfaced as an
+      // in-stream error frame) keep their own status: 400 must not cool the
+      // account via the fallback layer, and must reach the client as 400.
+      const upstreamCode = String(parsed.error.code || "");
+      const status =
+        parsed.error.type === "invalid_request_error" ||
+        upstreamCode === "context_length_exceeded" ||
+        upstreamCode === "bad_request"
+          ? HTTP_STATUS.BAD_REQUEST
+          : HTTP_STATUS.BAD_GATEWAY;
+      return createErrorResult(status, parsed.error.message || "Upstream SSE stream failed");
     }
 
     if (onRequestSuccess) await onRequestSuccess();

package/open-sse/providers/pricing.js

@@ -1099,18 +1099,32 @@ export const PATTERN_PRICING = [
 /**
  * Match a model ID against a glob pattern (* = wildcard). Case-insensitive:
  * registry ids mix casing (e.g. "MiniMax-M2.5" vs "minimax-m2.5").
+ *
+ * Patterns are a fixed config table, so the compiled RegExp is memoized:
+ * callers loop over ~100 patterns, and this used to recompile every one of
+ * them on each call (several times per request).
  */
+const PATTERN_REGEX_CACHE = new Map();
+
+function patternRegex(pattern) {
+  let regex = PATTERN_REGEX_CACHE.get(pattern);
+  if (!regex) {
+    regex = new RegExp(
+      "^" +
+        pattern
+          .split("*")
+          .map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+          .join(".*") +
+        "$",
+      "i",
+    );
+    PATTERN_REGEX_CACHE.set(pattern, regex);
+  }
+  return regex;
+}
+
 export function matchPattern(pattern, model) {
-  const regex = new RegExp(
-    "^" +
-      pattern
-        .split("*")
-        .map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-        .join(".*") +
-      "$",
-    "i",
-  );
-  return regex.test(model);
+  return patternRegex(pattern).test(model);
 }
 
 /**

package/open-sse/services/usage/antigravity-weekly.js

@@ -16,6 +16,16 @@ const WEEKLY_CONFIG = {
 const WEEKLY_CACHE_TTL_MS = 180_000; // 3 minutes
 const weeklyCache = new Map(); // cacheKey -> { result, expiresAt } | { promise }
 
+// Keys embed the access token, which rotates. Expiry is only read-checked, so
+// retired tokens would accumulate — sweep on a slow unref'd timer.
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, hit] of weeklyCache) {
+    if (hit?.promise) continue; // in-flight
+    if (!hit || hit.expiresAt <= now) weeklyCache.delete(key);
+  }
+}, WEEKLY_CACHE_TTL_MS).unref?.();
+
 function cacheKey(accessToken, projectId) {
   return `${accessToken}::${projectId || ""}`;
 }

package/open-sse/services/usage/claude.js

@@ -24,6 +24,21 @@ const oauthCooldown = new Map();
 const USAGE_CACHE_TTL_MS = 300000;
 const usageCache = new Map(); // token -> { promise } | { result, expiresAt }
 
+// Both maps are keyed by access token, which rotates. Expiry is only checked on
+// read, so entries for retired tokens would live forever — sweep them on a slow
+// timer (unref'd so it never holds the process open).
+function sweepExpired() {
+  const now = Date.now();
+  for (const [token, hit] of usageCache) {
+    if (hit?.promise) continue; // in-flight
+    if (!hit || hit.expiresAt <= now) usageCache.delete(token);
+  }
+  for (const [token, until] of oauthCooldown) {
+    if (until <= now) oauthCooldown.delete(token);
+  }
+}
+setInterval(sweepExpired, USAGE_CACHE_TTL_MS).unref?.();
+
 export async function getClaudeUsage(accessToken, proxyOptions = null, options = {}) {
   const force = options?.force === true;
 

package/open-sse/shared/zedAuth.js

@@ -11,6 +11,7 @@
 
 import crypto from "node:crypto";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { DEFAULT_RETRY_CONFIG, resolveRetryEntry } from "../config/runtimeConfig.js";
 
 export const ZED_WEB_BASE_URL = "https://zed.dev";
 export const ZED_CLOUD_BASE_URL = "https://cloud.zed.dev";
@@ -179,8 +180,48 @@ function getSystemId(credentials) {
   return String(credentials?.providerSpecificData?.systemId || credentials?.systemId || "");
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Transient socket failures (ECONNRESET/ETIMEDOUT/socket hang up via relay or
+// direct) surface as thrown TypeErrors from fetch. Retry those with the same
+// 502-config the BaseExecutor pipeline uses. Anything else — including caller
+// aborts and permanent failures (ENOTFOUND, bad TLS, 5xx bodies that resolve
+// normally) — is rethrown immediately: retrying it only adds delay to an
+// outcome that cannot change.
+const TRANSIENT_NET_CODES = new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EPIPE",
+  "EAI_AGAIN",
+  "UND_ERR_SOCKET",
+]);
+
+function isTransientNetError(error) {
+  if (!error || error.name === "AbortError") return false;
+  const code = error.code || error.cause?.code;
+  if (code && TRANSIENT_NET_CODES.has(code)) return true;
+  // Node's undici raises a bare TypeError("fetch failed") / "socket hang up"
+  // for relay-side resets, so the message is the only signal available.
+  return /socket hang up|ECONNRESET|other side closed/i.test(String(error.message || ""));
+}
+
+async function zedFetchWithRetry(url, options, proxyOptions = null, statusKey = 502) {
+  const { attempts, delayMs } = resolveRetryEntry(DEFAULT_RETRY_CONFIG[statusKey]);
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await proxyAwareFetch(url, options, proxyOptions);
+    } catch (error) {
+      if (!isTransientNetError(error) || attempt >= attempts) throw error;
+      await sleep(delayMs);
+    }
+  }
+}
+
 async function fetchJson(url, options, proxyOptions = null) {
-  const res = await proxyAwareFetch(url, options, proxyOptions);
+  const res = await zedFetchWithRetry(url, options, proxyOptions);
   const text = await res.text();
   let data = null;
   if (text) {
@@ -309,7 +350,7 @@ export async function zedLlmFetch(credentials, path, options = {}) {
   const url = zedUrl(config, "llmBaseUrl", path, ZED_LLM_BASE_URL);
   const buildRequest = async (forceRefresh) => {
     const token = await fetchZedLlmToken(credentials, { ...options, forceRefresh });
-    return proxyAwareFetch(
+    return zedFetchWithRetry(
       url,
       {
         ...options.fetchOptions,

package/open-sse/translator/concerns/prefetch.js

@@ -89,11 +89,19 @@ export async function prefetchRemoteImages(body, sourceFormat, targetFormat, opt
   const refs = collectImageRefs(body, sourceFormat);
   if (!refs.length) return 0;
 
+  // Fetch in parallel: this runs in the pre-first-byte path, and serial
+  // round trips made N images cost N × latency. Per-ref failure is already
+  // fail-open, so allSettled preserves existing behaviour.
+  const fetchedList = await Promise.all(
+    refs.map(async (ref) => {
+      const url = ref.get();
+      if (parseDataUri(url)) return { ref, fetched: null };
+      return { ref, fetched: await fetchImageAsBase64(url, options) };
+    }),
+  );
+
   let converted = 0;
-  for (const ref of refs) {
-    const url = ref.get();
-    if (parseDataUri(url)) continue; // already inline
-    const fetched = await fetchImageAsBase64(url, options);
+  for (const { ref, fetched } of fetchedList) {
     if (!fetched) continue;
     if (ref.set) ref.set(fetched.url);
     else if (ref.part) {

package/open-sse/translator/response/claude-to-openai.js

@@ -71,9 +71,10 @@ export function claudeToOpenAIResponse(chunk, state) {
       if (block?.type === CLAUDE_BLOCK.TEXT) {
         state.textBlockStarted = true;
       } else if (block?.type === CLAUDE_BLOCK.THINKING) {
+        // Thinking text streams as `reasoning_content` below; no literal tag is
+        // emitted into `content` — clients render that as part of the answer.
         state.inThinkingBlock = true;
         state.currentBlockIndex = chunk.index;
-        results.push(createChunk(state, { content: "<think>" }));
       } else if (block?.type === CLAUDE_BLOCK.TOOL_USE) {
         const toolCallIndex = state.toolCallIndex++;
         // Restore original tool name from mapping (Claude OAuth)
@@ -128,7 +129,6 @@ export function claudeToOpenAIResponse(chunk, state) {
         break;
       }
       if (state.inThinkingBlock && chunk.index === state.currentBlockIndex) {
-        results.push(createChunk(state, { content: "</think>" }));
         state.inThinkingBlock = false;
       }
       state.textBlockStarted = false;

package/open-sse/utils/streamHandler.js

@@ -94,11 +94,7 @@ export function createStreamController({
         return;
       }
 
-      logStream(
-        "ERROR",
-        `ERROR: ${error.message}${error.stack ? `\n    ${error.stack}` : ""}`,
-        true,
-      );
+      logStream("ERROR", `${error.message}${error.stack ? `\n    ${error.stack}` : ""}`, true);
       onError?.(error);
     },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amir83nasr/10router",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Amir83Nasr/10Router.git"
@@ -79,10 +79,6 @@
     "uuid": "^13.0.0",
     "zustand": "^5.0.10"
   },
-  "optionalDependencies": {
-    "better-sqlite3": "^12.6.2"
-  },
-  "comment_better_sqlite3": "kept in optionalDependencies so npm install doesn't fail on systems without build tools — sql.js is used as fallback at runtime",
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.18",
     "@types/node": "^26.6.1",

package/src/app/(dashboard)/dashboard/providers/[id]/BulkImportGrokCliModal.tsx

@@ -76,7 +76,7 @@ export default function BulkImportGrokCliModal({ isOpen, onClose, onSuccess }: a
   const processFiles = async (files: any) => {
     if (!files || files.length === 0) return;
     setParseError("");
-    const jsonFiles: any[] = Array.from(files).filter(
+    const jsonFiles: File[] = Array.from(files as FileList).filter(
       (file) => file.name.endsWith(".json") || file.type === "application/json" || file.type === "",
     );
 

package/src/app/(dashboard)/dashboard/providers/[id]/page.tsx

@@ -556,7 +556,7 @@ export default function ProviderDetailPage() {
     modelId,
     type = "llm",
     providerAliasOverride = providerStorageAlias,
-    caps,
+    caps?: unknown,
   ) => {
     try {
       const res = await fetch("/api/models/custom", {

package/src/app/(dashboard)/dashboard/usage/components/ProviderHealth.tsx

@@ -0,0 +1,221 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { Badge } from "@/components/ui/badge";
+import { Card, CardContent } from "@/components/ui/card";
+import Icon from "@/shared/components/Icon";
+
+type HealthStatus = "healthy" | "degraded" | "down" | "cooldown" | "idle";
+
+interface ProviderEntry {
+  provider: string;
+  connectionId: string;
+  connectionName: string;
+  requests: number;
+  errors: number;
+  detailErrors: number;
+  successRate: number | null;
+  p50LatencyMs: number | null;
+  lastError: string | null;
+  lastErrorAt: string | null;
+  cooldownUntil: string | null;
+  status: HealthStatus;
+}
+
+interface FailureEntry {
+  timestamp: string;
+  provider: string;
+  model: string;
+  connectionId: string | null;
+  connectionName: string | null;
+  status: string;
+  latencyMs: number | null;
+  error: string | null;
+}
+
+const STATUS_META: Record<HealthStatus, { label: string; className: string }> = {
+  down: { label: "Down", className: "bg-destructive/10 text-destructive" },
+  cooldown: { label: "Cooldown", className: "bg-amber-500/10 text-amber-600" },
+  degraded: { label: "Degraded", className: "bg-amber-500/10 text-amber-600" },
+  healthy: { label: "Healthy", className: "bg-emerald-500/10 text-emerald-600" },
+  idle: { label: "Idle", className: "bg-muted text-muted-foreground" },
+};
+
+function fmtPct(rate: number | null): string {
+  if (rate == null) return "—";
+  return `${Math.round(rate * 100)}%`;
+}
+
+function fmtLatency(ms: number | null): string {
+  if (ms == null) return "—";
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function fmtTime(iso: string | null): string {
+  if (!iso) return "—";
+  const diffMins = Math.floor((Date.now() - new Date(iso).getTime()) / 60000);
+  if (diffMins < 1) return "Just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffMins < 1440) return `${Math.floor(diffMins / 60)}h ago`;
+  return new Date(iso).toLocaleDateString();
+}
+
+export default function ProviderHealth() {
+  const [entries, setEntries] = useState<ProviderEntry[]>([]);
+  const [failures, setFailures] = useState<FailureEntry[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    let cancelled = false;
+    fetch("/api/usage/health")
+      .then((r) => (r.ok ? r.json() : null))
+      .then((data) => {
+        if (cancelled || !data) return;
+        setEntries(data.providers || []);
+        setFailures(data.recentFailures || []);
+      })
+      .catch(() => {})
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  const problemCount = entries.filter(
+    (e) => e.status === "down" || e.status === "cooldown" || e.status === "degraded",
+  ).length;
+
+  return (
+    <Card className="flex min-w-0 flex-col overflow-hidden" style={{ paddingBlock: 0, gap: 0 }}>
+      <div className="flex shrink-0 items-center gap-2 border-b border-border bg-card/80 px-4 py-3 backdrop-blur">
+        <span className="text-xs font-semibold uppercase tracking-wide text-muted-foreground">
+          Fallback Health
+        </span>
+        <span className="text-[11px] text-muted-foreground">24h · per account</span>
+        {!loading && (
+          <Badge variant="secondary" className="ml-auto text-xs">
+            {problemCount === 0 ? "all healthy" : `${problemCount} need attention`}
+          </Badge>
+        )}
+      </div>
+      <CardContent className="flex min-h-0 flex-1 flex-col p-0">
+        {loading ? (
+          <div className="flex items-center justify-center py-8 text-muted-foreground">
+            <Icon name="progress_activity" className="text-[24px] animate-spin" />
+          </div>
+        ) : entries.length === 0 ? (
+          <div className="flex flex-col items-center justify-center gap-2 py-8 text-muted-foreground">
+            <Icon name="history" className="text-2xl opacity-50" />
+            <p className="text-xs">No provider traffic in the last 24h.</p>
+          </div>
+        ) : (
+          <div className="overflow-x-auto">
+            <table className="w-full text-left text-sm">
+              <thead className="border-b border-border/60 text-muted-foreground">
+                <tr>
+                  <th className="px-4 py-2 text-[11px] font-semibold uppercase tracking-wide">
+                    Account
+                  </th>
+                  <th className="px-4 py-2 text-right text-[11px] font-semibold uppercase tracking-wide">
+                    Requests
+                  </th>
+                  <th className="px-4 py-2 text-right text-[11px] font-semibold uppercase tracking-wide">
+                    Success
+                  </th>
+                  <th className="px-4 py-2 text-right text-[11px] font-semibold uppercase tracking-wide">
+                    p50
+                  </th>
+                  <th className="px-4 py-2 text-[11px] font-semibold uppercase tracking-wide">
+                    Last error
+                  </th>
+                  <th className="px-4 py-2 text-right text-[11px] font-semibold uppercase tracking-wide">
+                    Status
+                  </th>
+                </tr>
+              </thead>
+              <tbody className="divide-y divide-border/40">
+                {entries.slice(0, 12).map((e) => {
+                  const meta = STATUS_META[e.status];
+                  return (
+                    <tr key={`${e.provider}-${e.connectionId}`} className="hover:bg-accent/60">
+                      <td className="px-4 py-2.5">
+                        <div className="flex min-w-0 flex-col">
+                          <span className="truncate font-mono text-xs font-medium">
+                            {e.connectionName}
+                          </span>
+                          <span className="truncate text-[11px] text-muted-foreground">
+                            {e.provider}
+                          </span>
+                        </div>
+                      </td>
+                      <td className="px-4 py-2.5 text-right text-xs tabular-nums">
+                        {e.requests + e.detailErrors}
+                      </td>
+                      <td className="px-4 py-2.5 text-right text-xs tabular-nums">
+                        {fmtPct(e.successRate)}
+                      </td>
+                      <td className="px-4 py-2.5 text-right text-xs tabular-nums">
+                        {fmtLatency(e.p50LatencyMs)}
+                      </td>
+                      <td className="max-w-64 px-4 py-2.5">
+                        {e.lastError ? (
+                          <span
+                            className="block truncate text-[11px] text-muted-foreground"
+                            title={`${e.lastError} (${fmtTime(e.lastErrorAt)})`}
+                          >
+                            {e.lastError}
+                          </span>
+                        ) : (
+                          <span className="text-[11px] text-muted-foreground">—</span>
+                        )}
+                      </td>
+                      <td className="px-4 py-2.5 text-right">
+                        <Badge variant="secondary" className={`text-[11px] ${meta.className}`}>
+                          {meta.label}
+                        </Badge>
+                      </td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </table>
+            {failures.length > 0 && (
+              <div className="border-t border-border/60 px-4 py-3">
+                <p className="mb-2 text-[11px] font-semibold uppercase tracking-wide text-muted-foreground">
+                  Recent failures — why fallback triggered
+                </p>
+                <div className="flex flex-col gap-1.5">
+                  {failures.slice(0, 5).map((f, i) => (
+                    <div
+                      key={`${f.timestamp}-${i}`}
+                      className="flex min-w-0 items-center gap-2 text-[11px]"
+                    >
+                      <span className="h-1.5 w-1.5 shrink-0 rounded-full bg-destructive" />
+                      <span className="shrink-0 font-mono text-muted-foreground">
+                        {fmtTime(f.timestamp)}
+                      </span>
+                      <span className="shrink-0 font-mono font-medium">
+                        {f.model || f.provider}
+                      </span>
+                      <span
+                        className="min-w-0 flex-1 truncate text-muted-foreground"
+                        title={f.error || ""}
+                      >
+                        {f.error || f.status} ·{" "}
+                        {f.connectionName || f.connectionId?.slice(0, 8) || "?"}
+                        {f.latencyMs != null ? ` · ${fmtLatency(f.latencyMs)}` : ""}
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}

package/src/app/(dashboard)/dashboard/usage/components/ProviderTopology.tsx

@@ -423,12 +423,15 @@ export default function ProviderTopology({
   const lastKey = lastProvider?.toLowerCase() || "";
   const errorKey = errorProvider?.toLowerCase() || "";
 
-  const rawActiveSet = useMemo(() => new Set(activeKey ? activeKey.split(",") : []), [activeKey]);
+  const rawActiveSet = useMemo(
+    () => new Set<string>(activeKey ? activeKey.split(",") : []),
+    [activeKey],
+  );
   const lastSet = useMemo(() => new Set(lastKey ? [lastKey] : []), [lastKey]);
   const errorSet = useMemo(() => new Set(errorKey ? [errorKey] : []), [errorKey]);
 
   // Track firstSeen per active provider; drop provider if running too long (BE stuck)
-  const firstSeenRef = useRef({});
+  const firstSeenRef = useRef<Record<string, number>>({});
   const [tick, setTick] = useState<number>(0);
 
   useEffect(() => {

package/src/app/api/combos/[id]/route.js

@@ -1,6 +1,14 @@
 import { NextResponse } from "next/server";
-import { getComboById, updateCombo, deleteCombo, getComboByName } from "@/lib/localDb";
+import {
+  getComboById,
+  updateCombo,
+  deleteCombo,
+  getComboByName,
+  getCombos,
+  getModelAliases,
+} from "@/lib/localDb";
 import { resetComboRotation } from "open-sse/services/combo.js";
+import { findComboMemberProblems } from "@/lib/validateComboModels";
 
 // Validate combo name: only a-z, A-Z, 0-9, -, _
 const VALID_NAME_REGEX = /^[a-zA-Z0-9_.\-]+$/;
@@ -46,6 +54,35 @@ export async function PUT(request, { params }) {
 
     // Capture previous name to invalidate rotation state on rename
     const prev = await getComboById(id);
+    if (!prev) {
+      return NextResponse.json({ error: "Combo not found" }, { status: 404 });
+    }
+
+    // Same member validation as POST (see validateComboModels.ts).
+    if (body.models !== undefined) {
+      const [aliases, combos] = await Promise.all([getModelAliases(), getCombos()]);
+      const cleanedModels = Array.isArray(body.models)
+        ? [
+            ...new Set(
+              body.models.map((m) => (typeof m === "string" ? m.trim() : "")).filter(Boolean),
+            ),
+          ]
+        : [];
+      const problems = findComboMemberProblems(cleanedModels, {
+        aliases,
+        comboNames: combos.filter((c) => c.id !== id).map((c) => c.name),
+        selfName: body.name || prev.name,
+      });
+      if (!Array.isArray(body.models) || problems.length > 0) {
+        return NextResponse.json(
+          {
+            error: `Invalid combo models: ${!Array.isArray(body.models) ? "models must be an array" : problems.join("; ")}`,
+          },
+          { status: 400 },
+        );
+      }
+      body = { ...body, models: cleanedModels };
+    }
     const combo = await updateCombo(id, body);
 
     if (!combo) {

package/src/app/api/combos/route.js

@@ -1,5 +1,6 @@
 import { NextResponse } from "next/server";
-import { getCombos, createCombo, getComboByName } from "@/lib/localDb";
+import { getCombos, createCombo, getComboByName, getModelAliases } from "@/lib/localDb";
+import { findComboMemberProblems } from "@/lib/validateComboModels";
 
 export const dynamic = "force-dynamic";
 
@@ -41,7 +42,31 @@ export async function POST(request) {
       return NextResponse.json({ error: "Combo name already exists" }, { status: 400 });
     }
 
-    const combo = await createCombo({ name, models: models || [], kind: kind || null });
+    // Validate members: bare words ("Support", "Last") die at request time
+    // with "Invalid model format", so reject them at save time instead.
+    const [aliases, combos] = await Promise.all([getModelAliases(), getCombos()]);
+    if (models !== undefined && !Array.isArray(models)) {
+      return NextResponse.json(
+        { error: "Invalid combo models: models must be an array" },
+        { status: 400 },
+      );
+    }
+    const cleanedModels = Array.isArray(models)
+      ? [...new Set(models.map((m) => (typeof m === "string" ? m.trim() : "")).filter(Boolean))]
+      : [];
+    const problems = findComboMemberProblems(cleanedModels, {
+      aliases,
+      comboNames: combos.map((c) => c.name),
+      selfName: name,
+    });
+    if (problems.length > 0) {
+      return NextResponse.json(
+        { error: `Invalid combo models: ${problems.join("; ")}` },
+        { status: 400 },
+      );
+    }
+
+    const combo = await createCombo({ name, models: cleanedModels, kind: kind || null });
 
     return NextResponse.json(combo, { status: 201 });
   } catch (error) {

package/src/app/api/providers/[id]/models/route.js

@@ -285,12 +285,23 @@ const PROVIDER_MODELS_CONFIG = {
   zed: {
     customResolver: async (connection) => {
       try {
+        const proxy = await resolveConnectionProxyConfig(connection.providerSpecificData || {});
         const result = await resolveZedModels(
           {
             accessToken: connection.accessToken,
             providerSpecificData: connection.providerSpecificData || {},
           },
-          { config: ZED_HOSTED_CONFIG, forceRefresh: true },
+          {
+            config: ZED_HOSTED_CONFIG,
+            forceRefresh: true,
+            proxyOptions: {
+              connectionProxyEnabled: proxy.connectionProxyEnabled === true,
+              connectionProxyUrl: proxy.connectionProxyUrl || "",
+              connectionNoProxy: proxy.connectionNoProxy || "",
+              vercelRelayUrl: proxy.vercelRelayUrl || "",
+              strictProxy: proxy.strictProxy === true,
+            },
+          },
         );
         const models = (result?.models || [])
           .filter((m) => m && !m.isDisabled)

package/src/app/api/providers/route.js

@@ -70,7 +70,10 @@ export async function GET() {
       for (const node of nodes) {
         if (node.id && node.name) nodeNameMap[node.id] = node.name;
       }
-    } catch {}
+    } catch (err) {
+      // Non-fatal: names degrade to raw provider ids, but stay visible.
+      console.warn("Failed to load provider nodes for name map:", err);
+    }
 
     // Hide sensitive fields, enrich name for compatible providers
     const safeConnections = connections.map((c) => {