n9router 0.4.57 → 0.4.59

package/app/open-sse/services/usage/groq.js

@@ -0,0 +1,133 @@
+/**
+ * Groq usage — no dedicated quota endpoint. Rate-limit info instead rides on
+ * every API response as x-ratelimit-* headers (requests + tokens, always
+ * included). We piggyback on the models list (already used as
+ * transport.validateUrl) so reading usage never costs tokens.
+ *
+ * Headers:
+ *   x-ratelimit-limit-requests / x-ratelimit-remaining-requests
+ *   x-ratelimit-limit-tokens   / x-ratelimit-remaining-tokens
+ *   x-ratelimit-reset-requests / x-ratelimit-reset-tokens (duration strings, e.g. "2m59.56s")
+ *
+ * Docs: https://console.groq.com/docs/rate-limits
+ */
+
+import { proxyAwareFetch } from "../../utils/proxyFetch.js";
+import { U } from "./shared.js";
+
+const MODELS_URL = U("groq").url;
+
+// Groq reset headers are Go-style duration strings ("2m59.56s", "7.66s"), not
+// timestamps — parse the h/m/s/ms components and add them to now().
+function parseGroqDurationMs(value) {
+  if (typeof value !== "string" || !value.trim()) return null;
+
+  const re = /(\d+(?:\.\d+)?)(ms|s|m|h)/g;
+  let match;
+  let totalMs = 0;
+  let matched = false;
+  while ((match = re.exec(value))) {
+    matched = true;
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const unitMs = unit === "h" ? 3600000 : unit === "m" ? 60000 : unit === "ms" ? 1 : 1000;
+    totalMs += amount * unitMs;
+  }
+  return matched ? totalMs : null;
+}
+
+function resetAtFromDuration(value) {
+  const ms = parseGroqDurationMs(value);
+  return ms === null ? null : new Date(Date.now() + ms).toISOString();
+}
+
+function buildRateLimitQuota(headers, limitKey, remainingKey, resetKey) {
+  // headers.get() returns null when absent, and Number(null) is 0 (a finite
+  // number) — check presence explicitly so a missing header can't masquerade
+  // as a real "0 remaining" quota.
+  const limitRaw = headers.get(limitKey);
+  const remainingRaw = headers.get(remainingKey);
+  if (limitRaw === null || remainingRaw === null) return null;
+
+  const limit = Number(limitRaw);
+  const remaining = Number(remainingRaw);
+  if (!Number.isFinite(limit) || !Number.isFinite(remaining)) return null;
+
+  return {
+    used: Math.max(0, limit - remaining),
+    total: limit,
+    resetAt: resetAtFromDuration(headers.get(resetKey)),
+    unlimited: false,
+  };
+}
+
+/**
+ * @param {string|null|undefined} apiKey
+ * @param {object|null} proxyOptions
+ */
+export async function getGroqUsage(apiKey, proxyOptions = null) {
+  if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
+    return { message: "Groq API key not available. Add a key to view usage." };
+  }
+
+  try {
+    const response = await proxyAwareFetch(
+      MODELS_URL,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${apiKey.trim()}`,
+          Accept: "application/json",
+        },
+      },
+      proxyOptions,
+    );
+
+    if (response.status === 401 || response.status === 403) {
+      return { plan: "Groq", message: "Groq authentication failed. Check the API key." };
+    }
+
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "");
+      return {
+        plan: "Groq",
+        message: `Groq usage API error (${response.status})${errText ? `: ${errText.slice(0, 120)}` : ""}`,
+      };
+    }
+
+    // The quota data lives in headers, not the body — drain it so the
+    // connection can be released without needing the payload.
+    await response.text().catch(() => {});
+
+    const requests = buildRateLimitQuota(
+      response.headers,
+      "x-ratelimit-limit-requests",
+      "x-ratelimit-remaining-requests",
+      "x-ratelimit-reset-requests",
+    );
+    const tokens = buildRateLimitQuota(
+      response.headers,
+      "x-ratelimit-limit-tokens",
+      "x-ratelimit-remaining-tokens",
+      "x-ratelimit-reset-tokens",
+    );
+
+    if (!requests && !tokens) {
+      // Key is valid (request succeeded) but no rate-limit bucket reported —
+      // distinguish "not tracked yet" from an auth/error state.
+      return {
+        plan: "Groq",
+        message: "Groq connected. No rate-limit data reported for this key yet.",
+        quotas: {},
+      };
+    }
+
+    const quotas = {};
+    if (requests) quotas["Requests"] = requests;
+    if (tokens) quotas["Tokens"] = tokens;
+
+    return { plan: "Groq", quotas };
+  } catch (error) {
+    return { message: `Groq error: ${error.message}` };
+  }
+}

package/app/open-sse/services/usage/misc.js

@@ -5,11 +5,8 @@
 import { proxyAwareFetch } from "../../utils/proxyFetch.js";
 import { U } from "./shared.js";
 
-// GLM quota endpoints (region-aware) — url from registry transport.usage
-const GLM_QUOTA_URLS = {
-  international: U("glm").url,
-  china: U("glm-cn").url,
-};
+export { getGlmUsage } from "./glm.js";
+
 
 // Vercel AI Gateway credits endpoint
 // Returns { balance: "95.50", total_used: "4.50" } (USD as decimal strings).
@@ -112,63 +109,7 @@ export async function getOllamaUsage(apiKey, providerSpecificData, proxyOptions
   }
 }
 
-/**
- * GLM Coding Plan usage (international + China regions)
- */
-export async function getGlmUsage(apiKey, provider, proxyOptions = null) {
-  if (!apiKey) {
-    return { message: "GLM API key not available." };
-  }
-
-  const region = provider === "glm-cn" ? "china" : "international";
-  const quotaUrl = GLM_QUOTA_URLS[region];
-
-  try {
-    const response = await proxyAwareFetch(quotaUrl, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        Accept: "application/json",
-      },
-    }, proxyOptions);
 
-    if (!response.ok) {
-      if (response.status === 401) {
-        return { message: "GLM API key invalid or expired." };
-      }
-      return { message: `GLM quota API error (${response.status}).` };
-    }
-
-    const json = await response.json();
-    const data = json?.data && typeof json.data === "object" ? json.data : {};
-    const limits = Array.isArray(data.limits) ? data.limits : [];
-    const quotas = {};
-
-    for (const limit of limits) {
-      if (!limit || limit.type !== "TOKENS_LIMIT") continue;
-      const usedPercent = Number(limit.percentage) || 0;
-      const resetMs = Number(limit.nextResetTime) || 0;
-      const remaining = Math.max(0, 100 - usedPercent);
-
-      quotas["session"] = {
-        used: usedPercent,
-        total: 100,
-        remaining,
-        remainingPercentage: remaining,
-        resetAt: resetMs > 0 ? new Date(resetMs).toISOString() : null,
-        unlimited: false,
-      };
-    }
-
-    const levelRaw = typeof data.level === "string" ? data.level : "";
-    const plan = levelRaw
-      ? levelRaw.charAt(0).toUpperCase() + levelRaw.slice(1).toLowerCase()
-      : "Unknown";
-
-    return { plan, quotas };
-  } catch (error) {
-    return { message: `GLM error: ${error.message}` };
-  }
-}
 
 /**
  * Vercel AI Gateway usage — credit balance for the API key

package/app/open-sse/services/usage/zed.js

@@ -0,0 +1,222 @@
+/**
+ * Zed usage — GET https://cloud.zed.dev/client/users/me
+ * Auth: Authorization: {user_id} {access_token}
+ *
+ * Quota rows are derived from plan.usage (edit_predictions, optional model_requests)
+ * and subscription_period.ended_at for billing-cycle reset.
+ */
+
+import { fetchZedAuthenticatedUser } from "../../shared/zedAuth.js";
+import { parseResetTime, toFiniteNumber } from "./shared.js";
+
+/** Map plan_v3 ids to dashboard labels (CodexBar-compatible). */
+export function formatZedPlanLabel(rawPlan) {
+  const raw = String(rawPlan || "").trim();
+  if (!raw) return "Zed";
+  switch (raw.toLowerCase()) {
+    case "zed_free":
+      return "Zed Free";
+    case "zed_pro":
+      return "Zed Pro";
+    case "zed_pro_trial":
+      return "Zed Pro Trial";
+    case "zed_student":
+      return "Zed Student";
+    case "zed_business":
+      return "Zed Business";
+    default:
+      return raw
+        .replace(/_/g, " ")
+        .split(/\s+/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(" ");
+  }
+}
+
+/**
+ * Parse Zed UsageLimit JSON: "unlimited", a number, or { limited: N }.
+ */
+export function parseZedUsageLimit(limit) {
+  if (limit == null) return { unlimited: false, total: 0 };
+
+  if (limit === "unlimited" || limit?.unlimited === true) {
+    return { unlimited: true, total: 0 };
+  }
+
+  if (typeof limit === "number" && Number.isFinite(limit)) {
+    return { unlimited: false, total: Math.max(0, limit) };
+  }
+
+  if (typeof limit === "string") {
+    const trimmed = limit.trim();
+    if (trimmed === "unlimited") return { unlimited: true, total: 0 };
+    const parsed = Number(trimmed);
+    if (Number.isFinite(parsed)) return { unlimited: false, total: Math.max(0, parsed) };
+  }
+
+  const limited = limit.limited ?? limit.Limited;
+  if (typeof limited === "number" && Number.isFinite(limited)) {
+    return { unlimited: false, total: Math.max(0, limited) };
+  }
+
+  return { unlimited: false, total: 0 };
+}
+
+/** limit `{ limited: 0 }` on Pro/Student means token billing, not a 0-cap request quota. */
+export function isZedTokenBillingModelRequestsLimit(limitRaw) {
+  const info = parseZedUsageLimit(limitRaw);
+  return !info.unlimited && info.total === 0;
+}
+
+function makeZedQuotaRow(name, usedRaw, limitRaw, resetAt = null) {
+  const used = Math.max(0, toFiniteNumber(usedRaw, 0));
+  const limitInfo = parseZedUsageLimit(limitRaw);
+
+  if (limitInfo.unlimited) {
+    return {
+      used,
+      total: 0,
+      remainingPercentage: 100,
+      resetAt: resetAt || null,
+      unlimited: true,
+    };
+  }
+
+  const total = limitInfo.total;
+  if (total <= 0) {
+    return {
+      used,
+      total: 0,
+      remainingPercentage: 0,
+      resetAt: resetAt || null,
+      unlimited: false,
+    };
+  }
+
+  const clampedUsed = Math.min(used, total);
+  const remaining = Math.max(0, total - clampedUsed);
+  return {
+    used: clampedUsed,
+    total,
+    remainingPercentage: (remaining / total) * 100,
+    resetAt: resetAt || null,
+    unlimited: false,
+  };
+}
+
+function usageBucketLimit(bucket) {
+  if (!bucket || typeof bucket !== "object") return null;
+  if (bucket.limit != null) return bucket.limit;
+  return bucket;
+}
+
+/**
+ * Map /client/users/me JSON → { plan, quotas, message } for the dashboard.
+ */
+export function parseZedAuthenticatedUserUsage(userInfo) {
+  const plan = userInfo?.plan || {};
+  const planId =
+    plan.plan_v3 || plan.plan_v2 || plan.plan || userInfo?.plan_v3 || null;
+  const resetAt =
+    parseResetTime(plan.subscription_period?.ended_at) ||
+    parseResetTime(plan.subscriptionPeriod?.endedAt) ||
+    null;
+
+  const quotas = {};
+  const usage = plan.usage || {};
+
+  const editPredictions = usage.edit_predictions || usage.editPredictions;
+  if (editPredictions) {
+    quotas["Edit Predictions"] = makeZedQuotaRow(
+      "Edit Predictions",
+      editPredictions.used,
+      editPredictions.limit,
+      resetAt,
+    );
+  }
+
+  const modelRequests = usage.model_requests || usage.modelRequests;
+  if (modelRequests) {
+    const limitRaw =
+      modelRequests.limit != null
+        ? modelRequests.limit
+        : usageBucketLimit(modelRequests)?.limit;
+    const limitInfo = parseZedUsageLimit(limitRaw);
+    // Token-billed plans report model_requests.limit=0 — not a request quota.
+    if (limitInfo.unlimited || limitInfo.total > 0) {
+      quotas["Hosted Model Requests"] = makeZedQuotaRow(
+        "Hosted Model Requests",
+        modelRequests.used,
+        limitRaw,
+        resetAt,
+      );
+    }
+  }
+
+  const tokenBillingNote =
+    modelRequests &&
+    isZedTokenBillingModelRequestsLimit(
+      modelRequests.limit ?? usageBucketLimit(modelRequests)?.limit,
+    )
+      ? "Hosted AI models are billed per token (not request count). Edit Predictions are tracked below. Token spend is on dashboard.zed.dev."
+      : null;
+
+  let planLabel = formatZedPlanLabel(planId);
+  if (plan.trial_started_at || plan.trialStartedAt) {
+    if (!/trial/i.test(planLabel)) planLabel = `${planLabel} (Trial active)`;
+  }
+
+  let message = tokenBillingNote;
+  if (plan.has_overdue_invoices || plan.hasOverdueInvoices) {
+    message = "This Zed account has overdue invoices. Usage may be blocked until billing is resolved.";
+  }
+
+  return {
+    plan: planLabel,
+    quotas,
+    message,
+    hasOverdueInvoices: !!(plan.has_overdue_invoices || plan.hasOverdueInvoices),
+    trialStarted: !!(plan.trial_started_at || plan.trialStartedAt),
+    planId: planId || null,
+    resetAt,
+  };
+}
+
+/**
+ * @param {string|null|undefined} accessToken
+ * @param {object|null|undefined} providerSpecificData
+ * @param {object|null|undefined} proxyOptions
+ */
+export async function getZedUsage(
+  accessToken = null,
+  providerSpecificData = {},
+  proxyOptions = null,
+) {
+  const psd = providerSpecificData || {};
+  const userId = psd.userId;
+
+  if (!accessToken || typeof accessToken !== "string" || !accessToken.trim()) {
+    return { message: "Zed access token not available. Re-connect Zed to view quota." };
+  }
+  if (!userId) {
+    return { message: "Zed credential is missing user id. Re-connect Zed to view quota." };
+  }
+
+  const credentials = {
+    accessToken: accessToken.trim(),
+    providerSpecificData: psd,
+  };
+
+  try {
+    const userInfo = await fetchZedAuthenticatedUser(credentials, { proxyOptions });
+    return parseZedAuthenticatedUserUsage(userInfo);
+  } catch (error) {
+    const status = error?.status;
+    if (status === 401 || status === 403) {
+      return {
+        message: "Zed authentication failed. Sign in again from the dashboard or Zed editor.",
+      };
+    }
+    return { message: `Zed error: ${error.message || "Failed to fetch quota"}` };
+  }
+}

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

@@ -14,11 +14,13 @@ import { getCodeBuddyCnUsage, getCodeBuddyIntlUsage } from "./usage/codebuddy-cn
 import { getGrokCliUsage } from "./usage/grok-cli.js";
 import { getKimiUsage } from "./usage/kimi.js";
 import { getDeepseekUsage } from "./usage/deepseek.js";
+import { getGroqUsage } from "./usage/groq.js";
+import { getZedUsage } from "./usage/zed.js";
 import { resolveQoderCredentials } from "./qoderModels.js";
+import { getGlmUsage } from "./usage/glm.js";
 import {
   getIflowUsage,
   getOllamaUsage,
-  getGlmUsage,
   getVercelAiGatewayUsage,
   getQoderUsage,
 } from "./usage/misc.js";
@@ -54,6 +56,8 @@ const USAGE_HANDLERS = {
   "grok-cli": (c) => getGrokCliUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
   kimi: (c) => getKimiUsage(c.accessToken, c.apiKey, c.proxyOptions, c.providerSpecificData),
   deepseek: (c) => getDeepseekUsage(c.apiKey, c.proxyOptions),
+  groq: (c) => getGroqUsage(c.apiKey, c.proxyOptions),
+  zed: (c) => getZedUsage(c.accessToken, c.providerSpecificData, c.proxyOptions),
 };
 
 export async function getUsageForProvider(connection, proxyOptions = null, options = {}) {

package/app/open-sse/shared/zedAuth.js

@@ -172,8 +172,8 @@ function getSystemId(credentials) {
   );
 }
 
-async function fetchJson(url, options) {
-  const res = await proxyAwareFetch(url, options);
+async function fetchJson(url, options, proxyOptions = null) {
+  const res = await proxyAwareFetch(url, options, proxyOptions);
   const text = await res.text();
   let data = null;
   if (text) {
@@ -203,11 +203,15 @@ export async function fetchZedAuthenticatedUser(credentials, options = {}) {
   const systemId = getSystemId(credentials);
   if (systemId) headers[ZED_HEADERS.systemId] = systemId;
 
-  return fetchJson(zedUrl(config, "cloudBaseUrl", "/client/users/me", ZED_CLOUD_BASE_URL), {
-    method: "GET",
-    headers,
-    signal: options.signal ?? undefined,
-  });
+  return fetchJson(
+    zedUrl(config, "cloudBaseUrl", "/client/users/me", ZED_CLOUD_BASE_URL),
+    {
+      method: "GET",
+      headers,
+      signal: options.signal ?? undefined,
+    },
+    options.proxyOptions ?? null,
+  );
 }
 
 function normalizeOrganizationId(value) {

package/app/open-sse/translator/concerns/thinkingUnified.js

@@ -58,6 +58,15 @@ export function extractThinking(body) {
     return { mode: "level", level: e };
   }
 
+  // OpenAI chat / Responses shape — check effort first (zai sends both thinking object and reasoning.effort)
+  const effort = body.reasoning_effort ?? (typeof body.reasoning === "object" ? body.reasoning?.effort : null);
+  if (typeof effort === "string" && effort) {
+    const e = effort.toLowerCase();
+    if (e === "none" || e === "off") return { mode: "none" };
+    if (e === "auto") return { mode: "auto" };
+    return { mode: "level", level: e };
+  }
+
   // Claude shape
   const t = body.thinking;
   if (t && typeof t === "object") {
@@ -69,15 +78,6 @@ export function extractThinking(body) {
     }
   }
 
-  // OpenAI chat / Responses shape
-  const effort = body.reasoning_effort ?? (typeof body.reasoning === "object" ? body.reasoning?.effort : null);
-  if (typeof effort === "string" && effort) {
-    const e = effort.toLowerCase();
-    if (e === "none" || e === "off") return { mode: "none" };
-    if (e === "auto") return { mode: "auto" };
-    return { mode: "level", level: e };
-  }
-
   // Gemini shape (top-level, generationConfig, or request envelope)
   const tc = body.thinkingConfig || body.generationConfig?.thinkingConfig || body.request?.generationConfig?.thinkingConfig;
   if (tc && typeof tc === "object") {
@@ -105,12 +105,16 @@ export function extractThinking(body) {
 // at the call-site where intent is snapshotted before format translation.
 export const captureThinking = extractThinking;
 
-// Resolve thinking format: provider override > capability > derive(targetFormat).
+const NATIVE_ONLY_FORMATS = new Set(["gemini-level", "gemini-budget", "claude-budget", "claude-adaptive", "kiro"]);
+
 function resolveFormat(targetFormat, model, provider) {
   const providerFmt = provider ? PROVIDERS[provider]?.thinkingFormat : null;
   if (providerFmt) return providerFmt;
   const caps = getCapabilitiesForModel(provider, model);
-  if (caps.thinkingFormat) return caps.thinkingFormat;
+  const isOpenAIWire = targetFormat === "openai" || targetFormat === "openai-responses";
+  if (caps.thinkingFormat && !(isOpenAIWire && NATIVE_ONLY_FORMATS.has(caps.thinkingFormat))) {
+    return caps.thinkingFormat;
+  }
   return FORMAT_TO_NATIVE[targetFormat] || "openai";
 }
 
@@ -237,6 +241,10 @@ function applyFormat(fmt, body, cfg, caps, supportedLevels) {
     }
     case "claude-adaptive": {
       if (none && canDisable) { body.thinking = { type: "disabled" }; break; }
+      // Models that can disable thinking need the explicit adaptive switch.
+      // Permanently adaptive models such as Fable 5.1 accept effort directly.
+      if (canDisable) body.thinking = { type: "adaptive" };
+      else delete body.thinking;
       const level = toLevel(eff);
       body.output_config = { effort: level === "xhigh" ? "high" : level };
       break;
@@ -264,6 +272,18 @@ function applyFormat(fmt, body, cfg, caps, supportedLevels) {
       // Z.ai ignores thinking.disabled → must use enable_thinking:false to turn off.
       if (none && canDisable) { body.enable_thinking = false; delete body.thinking; break; }
       body.thinking = { type: "enabled" };
+      // reasoning_effort is only read by z.ai from GLM-5.2 onward — older GLM ignores it
+      // (see thinkingEffortSupported in capabilities.js). Skip on unsupported models so we
+      // don't send a field the API doesn't recognize.
+      if (caps.thinkingEffortSupported) {
+        const zaiLvl = toLevel(eff);
+        // GLM-5.3 only accepts exactly low|high|max (anything else errors); GLM-5.2 accepts
+        // a wider set but z.ai maps low/medium->high and xhigh->max server-side anyway, so
+        // this 3-value mapping matches both.
+        body.reasoning_effort = (zaiLvl === "low" || zaiLvl === "minimal") ? "low"
+          : (zaiLvl === "high" || zaiLvl === "medium") ? "high"
+          : "max";
+      }
       break;
     }
     case "qwen": {

package/app/open-sse/translator/concerns/toolCall.js

@@ -151,3 +151,17 @@ export function fixMissingToolResponses(body) {
   return body;
 }
 
+// Default `type: "custom"` on Claude-format tools that arrive without one.
+// Anthropic's Claude tool schema requires `type` to be explicitly set; strict gateways
+// (e.g., MiniMax Anthropic-compatible endpoint, error 2013) reject legacy payloads that
+// omit it with HTTP 400. Tools that already carry a truthy `type` (e.g., `computer_use`,
+// `bash`, `web_search_20250305`) are passed through untouched.
+//
+// Spread order matters: `{ ...tool, type: "custom" }` (spread first, override last)
+// ensures that falsy `type` values (null, undefined, "") in the original tool don't
+// overwrite the default. `{ type: "custom", ...tool }` would let `type: null` survive.
+export function defaultClaudeToolType(tools) {
+  if (!Array.isArray(tools)) return tools;
+  return tools.map(tool => tool?.type ? tool : { ...tool, type: "custom" });
+}
+