zevairouter 1.0.152 → 1.0.154

package/open-sse/handlers/responsesHandler.js

@@ -5,9 +5,6 @@
 
 import { handleChatCore } from "./chatCore.js";
 import { getSettings } from "@/lib/localDb.js";
-import { convertResponsesApiFormat } from "../translator/helpers/responsesApiHelper.js";
-import { createResponsesApiTransformStream } from "../transformer/responsesTransformer.js";
-import { convertResponsesStreamToJson } from "../transformer/streamToJsonConverter.js";
 
 /**
  * Handle /v1/responses request
@@ -23,15 +20,9 @@ import { convertResponsesStreamToJson } from "../transformer/streamToJsonConvert
  * @returns {Promise<{success: boolean, response?: Response, status?: number, error?: string}>}
  */
 export async function handleResponsesCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, connectionId }) {
-  // Convert Responses API format to Chat Completions format
-  const convertedBody = convertResponsesApiFormat(body);
-
-  // Preserve client's stream preference (matches OpenClaw behavior)
-  // Default to false if omitted: Boolean(undefined) = false
-  const clientRequestedStreaming = convertedBody.stream === true;
-  if (convertedBody.stream === undefined) {
-    convertedBody.stream = false;
-  }
+  // chatCore owns both request and response translation. Keeping the original
+  // Responses shape here avoids converting the same payload twice.
+  const requestBody = { ...body, stream: body.stream === true };
 
   // Call chat core handler — force sourceFormat so streaming path knows this is a Responses API client
   let contextInjectionEnabled = false;
@@ -40,8 +31,8 @@ export async function handleResponsesCore({ body, modelInfo, credentials, log, o
     contextInjectionEnabled = !!s.contextInjectionEnabled;
   } catch { /* default off */ }
 
-  const result = await handleChatCore({
-    body: convertedBody,
+  return handleChatCore({
+    body: requestBody,
     modelInfo,
     credentials,
     log,
@@ -52,60 +43,4 @@ export async function handleResponsesCore({ body, modelInfo, credentials, log, o
     contextInjectionEnabled,
     sourceFormatOverride: "openai-responses"
   });
-
-  if (!result.success || !result.response) {
-    return result;
-  }
-
-  const response = result.response;
-  const contentType = response.headers.get("Content-Type") || "";
-
-  // Case 1: Client wants non-streaming, but got SSE (provider forced it, e.g., Codex)
-  if (!clientRequestedStreaming && contentType.includes("text/event-stream")) {
-    try {
-      const jsonResponse = await convertResponsesStreamToJson(response.body);
-
-      return {
-        success: true,
-        response: new Response(JSON.stringify(jsonResponse), {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json",
-            "Cache-Control": "no-cache",
-            "Access-Control-Allow-Origin": "*"
-          }
-        })
-      };
-    } catch (error) {
-      console.error("[Responses API] Stream-to-JSON conversion failed:", error);
-      return {
-        success: false,
-        status: 500,
-        error: "Failed to convert streaming response to JSON"
-      };
-    }
-  }
-
-  // Case 2: Client wants streaming, got SSE - transform it
-  if (clientRequestedStreaming && contentType.includes("text/event-stream")) {
-    const transformStream = createResponsesApiTransformStream(null);
-    const transformedBody = response.body.pipeThrough(transformStream);
-
-    return {
-      success: true,
-      response: new Response(transformedBody, {
-        status: 200,
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          "Connection": "keep-alive",
-          "Access-Control-Allow-Origin": "*"
-        }
-      })
-    };
-  }
-
-  // Case 3: Non-SSE response (error or non-streaming from provider) - return as-is
-  return result;
 }
-

package/open-sse/services/accountFallback.js

@@ -1,4 +1,6 @@
 import { ERROR_RULES, BACKOFF_CONFIG, TRANSIENT_COOLDOWN_MS } from "../config/errorConfig.js";
+import { getModelQuotaFamily, getModelUpstreamId } from "../config/providerModels.js";
+import { parseThinkingSuffix } from "../utils/thinkingSuffix.js";
 
 const NON_ACCOUNT_ERROR_TEXTS = [
   "content_length_exceeds_threshold",
@@ -23,6 +25,13 @@ export function isNonAccountError(status, errorText) {
   return status === 400 && NON_ACCOUNT_ERROR_TEXTS.some(text => lowerError.includes(text));
 }
 
+/** HTML 403 pages normally come from an egress proxy/WAF, not the credential. */
+export function isSharedEgressError(status, errorText) {
+  if (status !== 403 || !errorText) return false;
+  const text = typeof errorText === "string" ? errorText : JSON.stringify(errorText);
+  return /<!doctype\s+html|<html(?:\s|>)/i.test(text || "");
+}
+
 export function extractProviderErrorCode(errorText) {
   if (!errorText) return null;
   const text = typeof errorText === "string" ? errorText : JSON.stringify(errorText);
@@ -58,9 +67,21 @@ export function getQuotaExhaustedUntil(usage) {
  * still has capacity. Requiring all windows avoids treating an account with an
  * exhausted weekly window as recovered just because its short window is open.
  */
-export function hasAvailableQuota(usage) {
-  if (!usage || usage.limitReached === true) return false;
-  const quotas = Object.values(usage.quotas || {});
+export function hasAvailableQuota(usage, quotaFamily = null) {
+  if (!usage) return false;
+  if (quotaFamily === "review") {
+    if (usage.reviewLimitReached === true) return false;
+  } else if (usage.limitReached === true) {
+    return false;
+  }
+
+  const quotas = Object.entries(usage.quotas || {})
+    .filter(([key]) => {
+      if (quotaFamily === "review") return key.startsWith("review_");
+      if (quotaFamily === "normal") return !key.startsWith("review_");
+      return true;
+    })
+    .map(([, quota]) => quota);
   const remaining = quotas.map((quota) => {
     if (Number.isFinite(quota?.remaining)) return quota.remaining;
     if (Number.isFinite(quota?.remainingPercentage)) return quota.remainingPercentage;
@@ -74,17 +95,34 @@ export function hasAvailableQuota(usage) {
 
 /**
  * A successful quota poll newer than the error which created a model lock is
- * authoritative evidence that a Codex account recovered. The caller may probe
- * the account once; a fresh upstream failure updates lastErrorAt and makes the
- * same snapshot too old to bypass the replacement lock.
+ * authoritative evidence that a Codex account recovered. New locks carry an
+ * explicit lockedAt timestamp. Legacy locks fall back to lastErrorAt, then the
+ * connection update timestamp when older health checks already cleared the
+ * error metadata.
  */
-export function isModelLockRecoveredByQuota(connection, model, snapshot) {
-  if (!isModelLockActive(connection, model) || !hasAvailableQuota(snapshot?.usage)) {
+export function isModelLockRecoveredByQuota(connection, model, snapshot, provider = null, options = {}) {
+  const quotaFamily = getModelLockQuotaFamily(provider, model);
+  if (
+    !isModelLockActive(connection, model, provider)
+    || !hasAvailableQuota(snapshot?.usage, quotaFamily)
+    || (!options.ignoreProbe && isModelRecoveryProbeActive(connection, model, provider))
+  ) {
     return false;
   }
 
   const fetchedAt = Date.parse(snapshot?.fetchedAt);
-  const errorAt = Date.parse(connection?.lastErrorAt);
+  const reason = connection?.modelLockReason;
+  const reasonMatches = reason?.model
+    && getModelLockIdentity(provider, reason.model) === getModelLockIdentity(provider, model);
+  const reasonAt = reasonMatches ? Date.parse(reason?.lockedAt) : Number.NaN;
+  const lastErrorAt = Date.parse(connection?.lastErrorAt);
+  const legacyUpdatedAt = Date.parse(connection?.updatedAt);
+  const errorAt = Number.isFinite(reasonAt)
+    ? reasonAt
+    : Number.isFinite(lastErrorAt)
+      ? lastErrorAt
+      : legacyUpdatedAt;
+
   return Number.isFinite(fetchedAt)
     && Number.isFinite(errorAt)
     && fetchedAt > errorAt;
@@ -200,23 +238,85 @@ export function formatRetryAfter(rateLimitedUntil) {
 /** Prefix for model lock flat fields on connection record */
 export const MODEL_LOCK_PREFIX = "modelLock_";
 
+/** Recovery-probe leases are separate from lock fields so UI lock scans ignore them. */
+export const MODEL_RECOVERY_PROBE_PREFIX = "modelRecoveryProbe_";
+
+export const MODEL_RECOVERY_PROBE_LEASE_MS = 5 * 60 * 1000;
+
 /** Special key used when no model is known (account-level lock) */
 export const MODEL_LOCK_ALL = `${MODEL_LOCK_PREFIX}__all`;
 
+const CODEX_EFFORT_SUFFIX = /-(?:minimal|xhigh|none|low|medium|high|max|ultra)$/;
+
+export function getModelLockQuotaFamily(provider, model) {
+  if ((provider !== "codex" && provider !== "cx") || !model) return null;
+  if (String(model).startsWith("review:")) return "review";
+  const { cleanModel } = parseThinkingSuffix(String(model));
+  return getModelQuotaFamily("cx", cleanModel);
+}
+
+/** Normalize aliases and effort variants that share one Codex upstream quota. */
+export function getModelLockIdentity(provider, model) {
+  if (!model) return null;
+  if (provider !== "codex" && provider !== "cx") return String(model);
+  if (String(model).startsWith("review:")) return String(model);
+
+  const { cleanModel } = parseThinkingSuffix(String(model));
+  const quotaFamily = getModelQuotaFamily("cx", cleanModel);
+  const upstreamModel = String(getModelUpstreamId("cx", cleanModel) || cleanModel)
+    .replace(CODEX_EFFORT_SUFFIX, "");
+  return quotaFamily === "review" ? `review:${upstreamModel}` : upstreamModel;
+}
+
 /** Build the flat field key for a model lock */
-export function getModelLockKey(model) {
-  return model ? `${MODEL_LOCK_PREFIX}${model}` : MODEL_LOCK_ALL;
+export function getModelLockKey(model, provider = null) {
+  const identity = getModelLockIdentity(provider, model);
+  return identity ? `${MODEL_LOCK_PREFIX}${identity}` : MODEL_LOCK_ALL;
+}
+
+export function getModelRecoveryProbeKey(model, provider = null) {
+  const identity = getModelLockIdentity(provider, model);
+  return identity ? `${MODEL_RECOVERY_PROBE_PREFIX}${identity}` : `${MODEL_RECOVERY_PROBE_PREFIX}__all`;
+}
+
+function getMatchingModelLockEntries(connection, model, provider = null) {
+  const identity = getModelLockIdentity(provider, model);
+  return Object.entries(connection || {}).filter(([key]) => {
+    if (!key.startsWith(MODEL_LOCK_PREFIX) || key === MODEL_LOCK_ALL) return false;
+    const storedModel = key.slice(MODEL_LOCK_PREFIX.length);
+    return getModelLockIdentity(provider, storedModel) === identity;
+  });
+}
+
+/** Effective expiry for a model includes aliases plus the account-wide lock. */
+export function getModelLockUntil(connection, model, provider = null) {
+  if (!connection) return null;
+  const expiries = [
+    ...getMatchingModelLockEntries(connection, model, provider).map(([, value]) => value),
+    connection[MODEL_LOCK_ALL],
+  ]
+    .map((value) => Date.parse(value))
+    .filter((timestamp) => Number.isFinite(timestamp) && timestamp > Date.now());
+  return expiries.length ? new Date(Math.max(...expiries)).toISOString() : null;
 }
 
 /**
  * Check if a model lock on a connection is still active.
  * Reads flat field `modelLock_${model}` (or `modelLock___all` when model=null).
  */
-export function isModelLockActive(connection, model) {
-  const key = getModelLockKey(model);
-  const expiry = connection[key] || connection[MODEL_LOCK_ALL];
-  if (!expiry) return false;
-  return new Date(expiry).getTime() > Date.now();
+export function isModelLockActive(connection, model, provider = null) {
+  return !!getModelLockUntil(connection, model, provider);
+}
+
+export function isModelRecoveryProbeActive(connection, model, provider = null) {
+  const expiry = connection?.[getModelRecoveryProbeKey(model, provider)];
+  return Number.isFinite(Date.parse(expiry)) && Date.parse(expiry) > Date.now();
+}
+
+export function buildModelRecoveryProbeUpdate(model, provider = null, leaseMs = MODEL_RECOVERY_PROBE_LEASE_MS) {
+  return {
+    [getModelRecoveryProbeKey(model, provider)]: new Date(Date.now() + leaseMs).toISOString(),
+  };
 }
 
 /**
@@ -239,11 +339,39 @@ export function getEarliestModelLockUntil(connection) {
 /**
  * Build update object to set a model lock on a connection.
  */
-export function buildModelLockUpdate(model, cooldownMs) {
-  const key = getModelLockKey(model);
+export function buildModelLockUpdate(model, cooldownMs, provider = null) {
+  const key = getModelLockKey(model, provider);
   return { [key]: new Date(Date.now() + cooldownMs).toISOString() };
 }
 
+function getRemainingPercentage(quota) {
+  if (Number.isFinite(quota?.remainingPercentage)) return quota.remainingPercentage;
+  if (Number.isFinite(quota?.remaining) && Number.isFinite(quota?.total) && quota.total > 0) {
+    return (quota.remaining / quota.total) * 100;
+  }
+  return null;
+}
+
+/** Score cached quota for routing, respecting Codex normal/review quota families. */
+export function getQuotaRemainingScore(usage, provider, model) {
+  const quotas = usage?.quotas;
+  if (!quotas || typeof quotas !== "object") return -1;
+
+  const exact = quotas[model];
+  if (exact) return getRemainingPercentage(exact) ?? -1;
+
+  const family = getModelLockQuotaFamily(provider, model);
+  const values = Object.entries(quotas)
+    .filter(([key]) => {
+      if (family === "review") return key.startsWith("review_");
+      if (family === "normal") return !key.startsWith("review_");
+      return true;
+    })
+    .map(([, quota]) => getRemainingPercentage(quota))
+    .filter((value) => value !== null);
+  return values.length ? Math.min(...values) : -1;
+}
+
 /**
  * Build update object to clear all model locks on a connection.
  */