swayrouter 1.0.7 → 1.0.8

package/.env.example

@@ -41,3 +41,9 @@ PORT=14045
 # Advanced performance overrides intentionally live in README.md so the
 # normal setup stays small. Automatic resource profiles detect memory/CPU and
 # bound concurrency, queues, request bodies, retries, and usage retention.
+# The upstream routing guardrails below are also optional. Defaults are 3 account
+# attempts per request, 15 seconds per upstream attempt, and a 45-second Sway
+# deadline before a fast gateway timeout.
+#SWAY_MAX_ACCOUNT_ATTEMPTS=3
+#SWAY_UPSTREAM_ATTEMPT_TIMEOUT_MS=15000
+#SWAY_UPSTREAM_DEADLINE_MS=45000

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swayrouter",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Self-hosted AI gateway with a clean local dashboard",
   "license": "MIT",
   "repository": {

package/src/executors/antigravity.js

@@ -4,9 +4,10 @@ import { PROVIDERS } from "../config/providers.js";
 import { OAUTH_ENDPOINTS, ANTIGRAVITY_HEADERS } from "../config/appConstants.js";
 import { HTTP_STATUS } from "../config/runtimeConfig.js";
 import { resolveSessionId } from "../utils/sessionManager.js";
-import { proxyAwareFetch } from "../utils/proxyFetch.js";
-import { cleanJSONSchemaForAntigravity } from "../translator/formats/gemini.js";
-import { DEFAULT_THINKING_AG_SIGNATURE } from "../config/defaultThinkingSignature.js";
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { cleanJSONSchemaForAntigravity } from "../translator/formats/gemini.js";
+import { DEFAULT_THINKING_AG_SIGNATURE } from "../config/defaultThinkingSignature.js";
+import { getGeminiThoughtSignatureSync } from "../services/thoughtSignatureStore.js";
 
 function sanitizeFunctionName(name) {
   if (!name) return "_unknown";
@@ -186,17 +187,26 @@ export class AntigravityExecutor extends BaseExecutor {
         return true;
       });
 
-      const needsBackfill = parts?.some(p => p.functionCall && !p.thoughtSignature) ?? false;
-      if (role !== c.role || parts?.length !== c.parts?.length || needsBackfill) {
-        return {
-          ...c, role,
-          parts: needsBackfill
-            ? parts.map(p => (p.functionCall && !p.thoughtSignature)
-                ? { ...p, thoughtSignature: DEFAULT_THINKING_AG_SIGNATURE }
-                : p)
-            : parts,
-        };
-      }
+      let firstFunctionCallSeen = false;
+      const modifiedParts = parts?.map(p => {
+        if (!p.functionCall) return p;
+        const callId = p.functionCall.id;
+        const cachedSig = callId
+          ? getGeminiThoughtSignatureSync(callId, sessionId, body.model || model)
+          : null;
+        const callSig = p.thoughtSignature
+          || cachedSig
+          || (!firstFunctionCallSeen ? DEFAULT_THINKING_AG_SIGNATURE : undefined);
+        firstFunctionCallSeen = true;
+        return callSig ? { ...p, thoughtSignature: callSig } : p;
+      });
+      const needsBackfill = modifiedParts?.some((p, index) => p !== parts[index]) ?? false;
+      if (role !== c.role || parts?.length !== c.parts?.length || needsBackfill) {
+        return {
+          ...c, role,
+          parts: modifiedParts || parts,
+        };
+      }
       return c;
     });
 
@@ -240,18 +250,18 @@ export class AntigravityExecutor extends BaseExecutor {
       ...(tools?.length > 0 && { toolConfig: { functionCallingConfig: { mode: "VALIDATED" } } })
     };
 
-    stripBlacklisted(body);
-
-    this._lastSessionId = transformedRequest.sessionId;
-
-    return {
-      ...body,
-      project: projectId,
-      model: body.model || model,
-      userAgent: "antigravity",
-      requestType: "agent",
-      requestId: buildIdeRequestId({ body, request: transformedRequest, credentials, model, requestType: "agent" }),
-      request: transformedRequest
+    stripBlacklisted(body);
+    delete body.requestType;
+
+    this._lastSessionId = transformedRequest.sessionId;
+
+    return {
+      ...body,
+      project: projectId,
+      model: body.model || model,
+      userAgent: "antigravity",
+      requestId: buildIdeRequestId({ body, request: transformedRequest, credentials, model, requestType: "agent" }),
+      request: transformedRequest
     };
   }
 

package/src/executors/base.js

@@ -3,8 +3,9 @@ import { shouldRefreshCredentials } from "../services/oauthCredentialManager.js"
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
 import { dbg } from "../utils/debugLog.js";
 import { ANTHROPIC_API_VERSION, OPENAI_COMPAT_BASE, ANTHROPIC_COMPAT_BASE } from "../providers/shared.js";
-import { resolveOpenAICompatibleApiType } from "../services/provider.js";
-import { env } from "@/lib/env";
+import { resolveOpenAICompatibleApiType } from "../services/provider.js";
+import { env } from "@/lib/env";
+import { createUpstreamAttemptSignal } from "../utils/upstreamTimeout.js";
 
 export function waitForRetry(delayMs, signal) {
   if (!delayMs || delayMs <= 0) {
@@ -124,7 +125,7 @@ export class BaseExecutor {
     return { status: response.status, message: bodyText || `HTTP ${response.status}` };
   }
 
-  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null, requestTag = "", attemptReason = "initial", maxTotalAttempts = env.upstreamMaxAttempts }) {
+  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null, requestTag = "", attemptReason = "initial", maxTotalAttempts = env.upstreamMaxAttempts, attemptTimeoutMs = env.upstreamAttemptTimeoutMs, deadlineAt = null }) {
     const fallbackCount = this.getFallbackCount();
     const totalAttemptLimit = Math.max(1, Number(maxTotalAttempts) || env.upstreamMaxAttempts || 8);
     let attempt = 0;
@@ -157,27 +158,28 @@ export class BaseExecutor {
 
       if (!retryAttemptsByUrl[urlIndex]) retryAttemptsByUrl[urlIndex] = 0;
 
-      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 {
-        attempt++;
+      const configuredTimeoutMs = this.config?.timeoutMs || FETCH_CONNECT_TIMEOUT_MS;
+      const attemptControl = createUpstreamAttemptSignal({
+        signal,
+        timeoutMs: Math.min(configuredTimeoutMs, attemptTimeoutMs || env.upstreamAttemptTimeoutMs),
+        deadlineAt,
+      });
+
+      try {
+        attempt++;
         const bodyStr = JSON.stringify(transformedBody);
         const fetchT0 = Date.now();
         const attemptMeta = `attempt=${attempt} · reason=${attemptReason}`;
         let upstreamHost = url;
         try { upstreamHost = new URL(url).host || url; } catch {                                      }
         log?.line?.(requestTag, "FETCH", `${this.provider.toUpperCase()} → ${upstreamHost} · ${attemptMeta}`);
-        dbg("FETCH", `${this.provider.toUpperCase()} → ${url} | body=${bodyStr.length}B | connectTimeout=${timeoutMs}ms | ${attemptMeta}`);
-        const response = await proxyAwareFetch(url, {
-          method: "POST",
-          headers,
-          body: bodyStr,
-          signal: mergedSignal
-        }, proxyOptions);
-        clearTimeout(connectTimer);
+        dbg("FETCH", `${this.provider.toUpperCase()} → ${url} | body=${bodyStr.length}B | attemptTimeout=${attemptControl.timeoutMs}ms | ${attemptMeta}`);
+        const response = await proxyAwareFetch(url, {
+          method: "POST",
+          headers,
+          body: bodyStr,
+          signal: attemptControl.signal
+        }, proxyOptions);
         const ct = response.headers?.get?.("content-type") || "";
         const cl = response.headers?.get?.("content-length") || "?";
         const responseLabel = response.status >= 400 ? "ERROR" : "RESPONSE";
@@ -198,15 +200,14 @@ export class BaseExecutor {
         }
 
         return { response, url, headers, transformedBody };
-      } catch (error) {
-        clearTimeout(connectTimer);
-
-        if (signal?.aborted) throw signal.reason || error;
-        lastError = error;
-        const isConnectTimeout = connectCtrl.signal.aborted && error.name === "AbortError";
-        dbg("FETCH", `${this.provider.toUpperCase()} ✖ ${error.name}: ${error.message}${isConnectTimeout ? " (connect timeout)" : ""}`);
-
-        if (error.name === "AbortError" && !isConnectTimeout) throw error;
+      } catch (error) {
+        if (attemptControl.wasTimeout()) throw attemptControl.timeoutError;
+
+        if (signal?.aborted) throw signal.reason || error;
+        lastError = error;
+        dbg("FETCH", `${this.provider.toUpperCase()} ✖ ${error.name}: ${error.message}`);
+
+        if (error.name === "AbortError") throw error;
 
         if (await tryRetry(urlIndex, HTTP_STATUS.BAD_GATEWAY, `network "${error.message}"`)) { urlIndex--; continue; }
 
@@ -214,8 +215,10 @@ export class BaseExecutor {
           log?.debug?.("RETRY", `Error on ${url}, trying fallback ${urlIndex + 1}`);
           continue;
         }
-        throw error;
-      }
+        throw error;
+      } finally {
+        attemptControl.cleanup();
+      }
     }
 
     throw lastError || new Error(`All ${fallbackCount} URLs failed with status ${lastStatus}`);

package/src/executors/qoder.js

@@ -15,6 +15,8 @@ import {
   QODER_MODEL_MAP,
 } from "../shared/qoder/constants.js";
 import { getQoderModelConfig, resolveQoderModels, isQoderPat, resolveQoderCredentials } from "../services/qoderModels.js";
+import { createUpstreamAttemptSignal } from "../utils/upstreamTimeout.js";
+import { env } from "@/lib/env";
 
 function normalizeMessages(messages) {
   if (!Array.isArray(messages) || messages.length === 0) {
@@ -305,7 +307,7 @@ export class QoderExecutor extends BaseExecutor {
     return QODER_CHAT_URL_ENCODED;
   }
 
-  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
+  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null, attemptTimeoutMs = env.upstreamAttemptTimeoutMs, deadlineAt = null }) {
 
     const rawToken = credentials?.apiKey || credentials?.accessToken;
     if (isQoderPat(rawToken)) {
@@ -390,20 +392,25 @@ export class QoderExecutor extends BaseExecutor {
       ...cosyHeaders,
     };
 
-    const timeoutMs = this.config?.timeoutMs || FETCH_CONNECT_TIMEOUT_MS;
-    const connectCtrl = new AbortController();
-    const connectTimer = setTimeout(() => connectCtrl.abort(new Error("fetch connect timeout")), timeoutMs);
-    const mergedSignal = signal ? AbortSignal.any([signal, connectCtrl.signal]) : connectCtrl.signal;
+    const configuredTimeoutMs = this.config?.timeoutMs || FETCH_CONNECT_TIMEOUT_MS;
+    const attemptControl = createUpstreamAttemptSignal({
+      signal,
+      timeoutMs: Math.min(configuredTimeoutMs, attemptTimeoutMs || env.upstreamAttemptTimeoutMs),
+      deadlineAt,
+    });
 
     let response;
     try {
       response = await proxyAwareFetch(
         url,
-        { method: "POST", headers, body: encodedBodyBuf, signal: mergedSignal },
+        { method: "POST", headers, body: encodedBodyBuf, signal: attemptControl.signal },
         proxyOptions,
       );
+    } catch (error) {
+      if (attemptControl.wasTimeout()) throw attemptControl.timeoutError;
+      throw error;
     } finally {
-      clearTimeout(connectTimer);
+      attemptControl.cleanup();
     }
 
     if (!response.ok) {

package/src/handlers/chatCore/streamingHandler.js

@@ -89,7 +89,7 @@ export async function coerceOpenAIJsonToSSE(providerResponse, model, provider =
   });
 }
 
-function buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, customToolNames, model, connectionId, body, onStreamComplete, apiKey }) {
+function buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, customToolNames, model, connectionId, body, onStreamComplete, apiKey, sessionId }) {
   const isDroidCLI = userAgent?.toLowerCase().includes("droid") || userAgent?.toLowerCase().includes("codex-cli");
 
   const isResponsesProvider = PROVIDERS[provider]?.format === FORMATS.OPENAI_RESPONSES;
@@ -97,11 +97,11 @@ function buildTransformStream({ provider, sourceFormat, targetFormat, userAgent,
 
   if (needsCodexTranslation) {
     const codexTarget = CODEX_SOURCE_TO_TARGET[sourceFormat] || FORMATS.OPENAI;
-    return createSSETransformStreamWithLogger(FORMATS.OPENAI_RESPONSES, codexTarget, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey, customToolNames);
+    return createSSETransformStreamWithLogger(FORMATS.OPENAI_RESPONSES, codexTarget, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey, customToolNames, sessionId);
   }
 
   if (needsTranslation(targetFormat, sourceFormat)) {
-    return createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey, customToolNames);
+    return createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete, apiKey, customToolNames, sessionId);
   }
 
   return createPassthroughStreamWithLogger(provider, reqLogger, model, connectionId, body, onStreamComplete, apiKey);
@@ -151,7 +151,8 @@ export async function handleStreamingResponse({ providerResponse, provider, mode
     };
   }
 
-  const transformStream = buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, customToolNames, model, connectionId, body, onStreamComplete, apiKey });
+  const sessionId = finalBody?.request?.sessionId || translatedBody?.request?.sessionId || body?.request?.sessionId || null;
+  const transformStream = buildTransformStream({ provider, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, customToolNames, model, connectionId, body, onStreamComplete, apiKey, sessionId });
 
   const isResponsesPassthrough = sourceFormat === FORMATS.OPENAI_RESPONSES && targetFormat === FORMATS.OPENAI_RESPONSES;
   const onAbortTerminal = isResponsesPassthrough ? buildAbortedResponsesTerminalBytes : null;

package/src/handlers/chatCore.js

@@ -33,6 +33,8 @@ import { stripUnsupportedModalities } from "../translator/concerns/modality.js";
 import { prefetchRemoteImages } from "../translator/concerns/prefetch.js";
 import { resolveSessionId } from "../utils/sessionManager.js";
 import { normalizeTranslationRequest, resolveTranslationSurface, unsupportedFeatures } from "../translator/canonical.js";
+import { executeWithAttemptDeadline, isUpstreamTimeoutError } from "../utils/upstreamTimeout.js";
+import { env } from "@/lib/env";
 
 export function stripContinuityFields(body) {
   if (!body || !Array.isArray(body.messages)) return body;
@@ -45,7 +47,7 @@ export function stripContinuityFields(body) {
   return body;
 }
 
-export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest, connectionId, userAgent, apiKey, ccFilterNaming, rtkEnabled, cavemanEnabled, cavemanLevel, ponytailEnabled, ponytailLevel, sourceFormatOverride, providerThinking, requestSignal }) {
+export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest, connectionId, userAgent, apiKey, ccFilterNaming, rtkEnabled, cavemanEnabled, cavemanLevel, ponytailEnabled, ponytailLevel, sourceFormatOverride, providerThinking, requestSignal, deadlineAt = null }) {
   const { provider, model, modelCapabilities } = modelInfo;
   const requestStartTime = Date.now();
   let failureRecorded = false;
@@ -315,6 +317,8 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
     signal: streamController.signal, log, proxyOptions,
     requestTag: reqTag,
     attemptReason: "initial",
+    attemptTimeoutMs: env.upstreamAttemptTimeoutMs,
+    deadlineAt,
   };
   trackPendingRequest(model, provider, connectionId, true);
   appendRequestLog({ model, provider, connectionId, status: "PENDING" }).catch(() => { });
@@ -352,7 +356,10 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
 
   let providerResponseFormat = targetFormat;
   try {
-    const result = await executor.execute(executeOptions);
+    const result = await executeWithAttemptDeadline(
+      (signal) => executor.execute({ ...executeOptions, signal }),
+      { signal: executeOptions.signal, timeoutMs: env.upstreamAttemptTimeoutMs, deadlineAt },
+    );
     providerResponse = result.response;
     providerUrl = result.url;
     providerHeaders = result.headers;
@@ -361,19 +368,24 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
     reqLogger.logTargetRequest(providerUrl, providerHeaders, finalBody);
   } catch (error) {
     trackPendingRequest(model, provider, connectionId, false, true);
-    const failedStatus = recordFailure(error.message || String(error), error.name === "AbortError" ? 499 : HTTP_STATUS.BAD_GATEWAY);
-    appendRequestLog({ model, provider, connectionId, status: `FAILED ${error.name === "AbortError" ? 499 : HTTP_STATUS.BAD_GATEWAY}` }).catch(() => { });
+    const timeout = isUpstreamTimeoutError(error);
+    const failedStatus = recordFailure(error.message || String(error), timeout ? HTTP_STATUS.GATEWAY_TIMEOUT : error.name === "AbortError" ? 499 : HTTP_STATUS.BAD_GATEWAY);
+    appendRequestLog({ model, provider, connectionId, status: `FAILED ${timeout ? HTTP_STATUS.GATEWAY_TIMEOUT : error.name === "AbortError" ? 499 : HTTP_STATUS.BAD_GATEWAY}` }).catch(() => { });
     saveRequestDetail(buildRequestDetail({
       provider, model, connectionId,
       latency: { ttft: 0, total: Date.now() - requestStartTime },
       tokens: { prompt_tokens: 0, completion_tokens: 0 },
       request: extractRequestConfig(body, stream),
       providerRequest: translatedBody || null,
-      response: { error: error.message || String(error), status: error.name === "AbortError" ? 499 : 502, thinking: null },
+      response: { error: error.message || String(error), status: timeout ? HTTP_STATUS.GATEWAY_TIMEOUT : error.name === "AbortError" ? 499 : 502, thinking: null },
       status: "error",
       client: { id: clientMeta.id, confidence: clientMeta.confidence, signals: clientMeta.signals, conflicts: clientMeta.conflicts }
     }), clientRawRequest).catch(() => { });
 
+    if (timeout) {
+      streamController.handleError(error);
+      return createErrorResult(HTTP_STATUS.GATEWAY_TIMEOUT, "Upstream request timed out");
+    }
     if (error.name === "AbortError") {
       streamController.handleError(error);
       return createErrorResult(499, "Request aborted");
@@ -403,7 +415,10 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
           try { await onCredentialsRefreshed(newCredentials); } catch (e) { log?.warn?.("TOKEN", `onCredentialsRefreshed failed: ${e.message}`); }
         }
         try {
-          const retryResult = await executor.execute({ ...executeOptions, attemptReason: "oauth-refresh" });
+          const retryResult = await executeWithAttemptDeadline(
+            (signal) => executor.execute({ ...executeOptions, signal, attemptReason: "oauth-refresh" }),
+            { signal: executeOptions.signal, timeoutMs: env.upstreamAttemptTimeoutMs, deadlineAt },
+          );
           if (retryResult.response.ok) {
             providerResponse = retryResult.response;
             providerUrl = retryResult.url;
@@ -448,6 +463,7 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
               reqLogger.logTargetRequest(providerUrl, providerHeaders, finalBody);
             }
           } catch (e) {
+            if (isUpstreamTimeoutError(e)) throw e;
             if (log?.warn) log.warn("A4.4", `retry after strip "${rejectedField}" threw: ${e?.message || e}`);
           }
         } else if (apply.retryable && !apply.removed) {
@@ -517,10 +533,14 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
       }
       log?.line?.(reqTag, "RETRY", `A4.3 pre-content socket close · ${provider}/${model}`);
       try {
-        const retryResp = await executor.execute({
-          ...executeOptions,
-          attemptReason: "stream-preview-network",
-        });
+        const retryResp = await executeWithAttemptDeadline(
+          (signal) => executor.execute({
+            ...executeOptions,
+            signal,
+            attemptReason: "stream-preview-network",
+          }),
+          { signal: executeOptions.signal, timeoutMs: env.upstreamAttemptTimeoutMs, deadlineAt },
+        );
         if (retryResp?.response?.ok) {
           providerResponse = retryResp.response;
           providerUrl = retryResp.url;
@@ -541,6 +561,10 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
           );
         }
       } catch (error) {
+        if (isUpstreamTimeoutError(error)) {
+          recordFailure(error?.message || String(error), HTTP_STATUS.GATEWAY_TIMEOUT);
+          return createErrorResult(HTTP_STATUS.GATEWAY_TIMEOUT, "Upstream request timed out");
+        }
         if (requestSignal?.aborted || error?.name === "AbortError") {
           recordFailure("Request aborted", 499);
           return createErrorResult(499, "Request aborted");
@@ -578,10 +602,14 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
           recordFailure("Request aborted", 499);
           return createErrorResult(499, "Request aborted");
         }
-        const retryResp = await executor.execute({
-          ...executeOptions,
-          attemptReason: "stream-preview",
-        });
+        const retryResp = await executeWithAttemptDeadline(
+          (signal) => executor.execute({
+            ...executeOptions,
+            signal,
+            attemptReason: "stream-preview",
+          }),
+          { signal: executeOptions.signal, timeoutMs: env.upstreamAttemptTimeoutMs, deadlineAt },
+        );
         if (retryResp?.response?.ok) {
           providerResponse = retryResp.response;
           providerUrl = retryResp.url;
@@ -604,8 +632,9 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
       } catch (e) {
         log?.warn?.("A4.3", `retry threw: ${e?.message || e}`);
 
-        recordFailure(e?.message || String(e), HTTP_STATUS.BAD_GATEWAY);
-        return createErrorResult(HTTP_STATUS.BAD_GATEWAY, formatProviderError(e, provider, model, HTTP_STATUS.BAD_GATEWAY));
+        const status = isUpstreamTimeoutError(e) ? HTTP_STATUS.GATEWAY_TIMEOUT : HTTP_STATUS.BAD_GATEWAY;
+        recordFailure(e?.message || String(e), status);
+        return createErrorResult(status, isUpstreamTimeoutError(e) ? "Upstream request timed out" : formatProviderError(e, provider, model, status));
       }
     } else if (preview && (preview.kind === "committed" || preview.kind === "timeout" || preview.kind === "streamClosed")) {
 

package/src/lib/env.ts

@@ -39,6 +39,9 @@ export interface EnvConfig {
   usageHistoryMaxRows: number;
 
   upstreamMaxAttempts: number;
+  upstreamAttemptTimeoutMs: number;
+  upstreamDeadlineMs: number;
+  maxAccountAttempts: number;
 }
 
 const DEFAULT_PASSWORD = "123456";
@@ -161,6 +164,21 @@ export function loadEnv(source: Record<string, string | undefined> = process.env
       nodeEnv === "production" ? resource.upstreamMaxAttempts : 8,
       100,
     ),
+    upstreamAttemptTimeoutMs: parsePositiveInt(
+      source.SWAY_UPSTREAM_ATTEMPT_TIMEOUT_MS,
+      15_000,
+      10 * 60 * 1000,
+    ),
+    upstreamDeadlineMs: parsePositiveInt(
+      source.SWAY_UPSTREAM_DEADLINE_MS,
+      45_000,
+      10 * 60 * 1000,
+    ),
+    maxAccountAttempts: parsePositiveInt(
+      source.SWAY_MAX_ACCOUNT_ATTEMPTS,
+      3,
+      100,
+    ),
   });
 }
 

package/src/providers/registry/codebuddy-intl.js

@@ -38,7 +38,7 @@ export default {
     },
 
     usage: {
-      url: "https://www.codebuddy.ai/billing/meter/get-user-resource",
+      url: "https://www.codebuddy.ai/v2/billing/meter/get-user-resource",
     },
   },
 

package/src/services/thoughtSignatureStore.js

@@ -0,0 +1,49 @@
+const MAX_ENTRIES = 4096;
+const TTL_MS = 30 * 60 * 1000;
+
+const signatures = new Map();
+
+function keyFor(callId, sessionId, model) {
+  return `${String(sessionId)}\u0000${String(model)}\u0000${String(callId)}`;
+}
+
+function isUsable(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 64 * 1024;
+}
+
+function prune(now = Date.now()) {
+  for (const [key, entry] of signatures) {
+    if (entry.expiresAt <= now) signatures.delete(key);
+  }
+  while (signatures.size > MAX_ENTRIES) {
+    const oldest = signatures.keys().next().value;
+    if (oldest === undefined) break;
+    signatures.delete(oldest);
+  }
+}
+
+export function rememberGeminiThoughtSignature(callId, sessionId, model, signature) {
+  if (!isUsable(callId) || !isUsable(sessionId) || !isUsable(model) || !isUsable(signature)) return;
+  const key = keyFor(callId, sessionId, model);
+  signatures.delete(key);
+  signatures.set(key, { signature, expiresAt: Date.now() + TTL_MS });
+  prune();
+}
+
+export function getGeminiThoughtSignatureSync(callId, sessionId, model) {
+  if (!isUsable(callId) || !isUsable(sessionId) || !isUsable(model)) return null;
+  const key = keyFor(callId, sessionId, model);
+  const entry = signatures.get(key);
+  if (!entry) return null;
+  if (entry.expiresAt <= Date.now()) {
+    signatures.delete(key);
+    return null;
+  }
+  signatures.delete(key);
+  signatures.set(key, entry);
+  return entry.signature;
+}
+
+export function clearGeminiThoughtSignatures() {
+  signatures.clear();
+}

package/src/sse/handlers/chat.js

@@ -240,10 +240,11 @@ export async function handleChat(request, clientRawRequest = null) {
   return handleSingleModelChat(body, modelStr, clientRawRequest, request, apiKey, preferredConnectionId, request?.signal);
 }
 
-async function handleSingleModelChat(body, modelStr, clientRawRequest = null, request = null, apiKey = null, preferredConnectionId = null, requestSignal = null) {
-  requestSignal ||= request?.signal || null;
-  if (requestSignal?.aborted) return errorResponse(499, "Request aborted");
-  const incomingClient = clientRawRequest?.headers
+async function handleSingleModelChat(body, modelStr, clientRawRequest = null, request = null, apiKey = null, preferredConnectionId = null, requestSignal = null) {
+  requestSignal ||= request?.signal || null;
+  if (requestSignal?.aborted) return errorResponse(499, "Request aborted");
+  const deadlineAt = Date.now() + env.upstreamDeadlineMs;
+  const incomingClient = clientRawRequest?.headers
     ? Object.fromEntries(clientRawRequest.headers.entries?.() || [])
     : {};
   const settings = await getSettings();
@@ -311,12 +312,17 @@ async function handleSingleModelChat(body, modelStr, clientRawRequest = null, re
 
   const excludeConnectionIds = new Set();
   let lastError = null;
-  let lastStatus = null;
-
-  const cacheKey = extractCacheKey(body);
-  let retryCount = 0;
-
-  while (true) {
+  let lastStatus = null;
+
+  const cacheKey = extractCacheKey(body);
+  let retryCount = 0;
+  let accountAttempts = 0;
+
+  while (accountAttempts < env.maxAccountAttempts) {
+    if (Date.now() >= deadlineAt) {
+      return errorResponse(HTTP_STATUS.GATEWAY_TIMEOUT, "Sway Router upstream deadline exceeded");
+    }
+
     const credentials = await getProviderCredentials(provider, excludeConnectionIds, model, {
       cacheKey,
       preferredConnectionId,
@@ -348,9 +354,10 @@ async function handleSingleModelChat(body, modelStr, clientRawRequest = null, re
         credentials.retryAfter,
         credentials.retryAfterHuman || "retry shortly",
       );
-    }
-
-    const releaseAccountSlot = credentials.releaseAccountSlot;
+    }
+
+    accountAttempts += 1;
+    const releaseAccountSlot = credentials.releaseAccountSlot;
     let result;
     try {
       const refreshedCredentials = await checkAndRefreshToken(provider, credentials);
@@ -381,8 +388,9 @@ async function handleSingleModelChat(body, modelStr, clientRawRequest = null, re
         cavemanLevel: chatSettings.cavemanLevel || "full",
         ponytailEnabled: !!chatSettings.ponytailEnabled,
         ponytailLevel: chatSettings.ponytailLevel || "full",
-        providerThinking,
-        requestSignal,
+        providerThinking,
+        requestSignal,
+        deadlineAt,
 
         sourceFormatOverride: request?.url ? detectFormatByEndpoint(new URL(request.url).pathname, body) : null,
         onCredentialsRefreshed: async (newCreds) => {
@@ -406,21 +414,33 @@ async function handleSingleModelChat(body, modelStr, clientRawRequest = null, re
 
     releaseAccountSlot?.();
 
-    if (isCallerCancellation({ requestSignal, status: result.status })) {
-      return result.response;
-    }
+    if (isCallerCancellation({ requestSignal, status: result.status })) {
+      return result.response;
+    }
+
+    if (Date.now() >= deadlineAt) {
+      return result.response.status === HTTP_STATUS.GATEWAY_TIMEOUT
+        ? result.response
+        : errorResponse(HTTP_STATUS.GATEWAY_TIMEOUT, "Sway Router upstream deadline exceeded");
+    }
 
     const { shouldFallback } = await markAccountUnavailable(credentials.connectionId, result.status, result.error, provider, model, result.resetsAtMs, { retryCount });
 
-    if (shouldFallback) {
-      log.warn("FALLBACK", `⇄ ACC:${credentials.connectionName} UNAVAILABLE (${result.status}) → NEXT ACCOUNT`);
-      excludeConnectionIds.add(credentials.connectionId);
-      lastError = result.error;
-      lastStatus = result.status;
-      retryCount += 1;
-      continue;
+    if (shouldFallback) {
+      log.warn("FALLBACK", `⇄ ACC:${credentials.connectionName} UNAVAILABLE (${result.status}) → NEXT ACCOUNT`);
+      excludeConnectionIds.add(credentials.connectionId);
+      lastError = result.error;
+      lastStatus = result.status;
+      retryCount += 1;
+      if (accountAttempts >= env.maxAccountAttempts) {
+        log.warn("FALLBACK", `[${provider}/${model}] account attempt limit reached (${env.maxAccountAttempts})`);
+        return errorResponse(HTTP_STATUS.SERVICE_UNAVAILABLE, "Provider account fallback limit reached; retry shortly");
+      }
+      continue;
     }
 
-    return result.response;
-  }
-}
+    return result.response;
+  }
+
+  return errorResponse(HTTP_STATUS.SERVICE_UNAVAILABLE, "Provider account fallback limit reached; retry shortly");
+}

package/src/translator/response/gemini-to-openai.js

@@ -5,7 +5,8 @@ import { buildChunk } from "../concerns/chunk.js";
 import { toOpenAIUsage } from "../concerns/usage.js";
 import { reasoningDelta } from "../concerns/reasoning.js";
 import { encodeDataUri } from "../concerns/image.js";
-import { toOpenAIFinish } from "../concerns/finishReason.js";
+import { toOpenAIFinish } from "../concerns/finishReason.js";
+import { rememberGeminiThoughtSignature } from "../../services/thoughtSignatureStore.js";
 
 function chunkMeta(state) {
   return { id: `chatcmpl-${state.messageId}`, created: Math.floor(Date.now() / 1000), model: state.model };
@@ -47,9 +48,24 @@ export function geminiToOpenAIResponse(chunk, state) {
   }
 
   if (content?.parts) {
-    for (const part of content.parts) {
-      const hasThoughtSig = part.thoughtSignature || part.thought_signature;
-      const isThought = part.thought === true;
+    for (const part of content.parts) {
+      const hasThoughtSig = part.thoughtSignature || part.thought_signature;
+      const isThought = part.thought === true;
+
+      if (
+        state.provider === "antigravity"
+        && state.sessionId
+        && (state.signatureModel || state.model)
+        && part.functionCall?.id
+        && hasThoughtSig
+      ) {
+        rememberGeminiThoughtSignature(
+          part.functionCall.id,
+          state.sessionId,
+          state.signatureModel || state.model,
+          hasThoughtSig,
+        );
+      }
 
       if (hasThoughtSig) {
         const hasTextContent = part.text !== undefined && part.text !== "";

package/src/utils/stream.js

@@ -101,9 +101,10 @@ export function createSSEStream(options = {}) {
     customToolNames = null,
     model = null,
     connectionId = null,
-    body = null,
-    onStreamComplete = null,
-    apiKey = null
+    body = null,
+    onStreamComplete = null,
+    apiKey = null,
+    sessionId = null
   } = options;
 
   let buffer = "";
@@ -111,8 +112,8 @@ export function createSSEStream(options = {}) {
 
   const decoder = new TextDecoder("utf-8", { fatal: false });
 
-  const state = mode === STREAM_MODE.TRANSLATE
-    ? { ...initState(sourceFormat), provider, toolNameMap, customToolNames: new Set(customToolNames || []), model }
+  const state = mode === STREAM_MODE.TRANSLATE
+    ? { ...initState(sourceFormat), provider, toolNameMap, customToolNames: new Set(customToolNames || []), model, signatureModel: model, sessionId }
     : null;
 
   let totalContentLength = 0;
@@ -480,7 +481,7 @@ export function createSSEStream(options = {}) {
   });
 }
 
-export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider = null, reqLogger = null, toolNameMap = null, model = null, connectionId = null, body = null, onStreamComplete = null, apiKey = null, customToolNames = null) {
+export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider = null, reqLogger = null, toolNameMap = null, model = null, connectionId = null, body = null, onStreamComplete = null, apiKey = null, customToolNames = null, sessionId = null) {
   return createSSEStream({
     mode: STREAM_MODE.TRANSLATE,
     targetFormat,
@@ -493,9 +494,10 @@ export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, p
     connectionId,
     body,
     onStreamComplete,
-    apiKey
-  });
-}
+    apiKey,
+    sessionId
+  });
+}
 
 export function createPassthroughStreamWithLogger(provider = null, reqLogger = null, model = null, connectionId = null, body = null, onStreamComplete = null, apiKey = null) {
   return createSSEStream({

package/src/utils/upstreamTimeout.js

@@ -0,0 +1,67 @@
+const DEFAULT_ATTEMPT_TIMEOUT_MS = 15_000;
+
+export class UpstreamTimeoutError extends Error {
+  constructor(message, { kind = "attempt", timeoutMs = 0 } = {}) {
+    super(message);
+    this.name = "UpstreamTimeoutError";
+    this.code = "UPSTREAM_TIMEOUT";
+    this.kind = kind;
+    this.timeoutMs = timeoutMs;
+  }
+}
+export function isUpstreamTimeoutError(error) {
+  return error?.name === "UpstreamTimeoutError" || error?.code === "UPSTREAM_TIMEOUT";
+}
+
+function resolveTimeoutMs(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ATTEMPT_TIMEOUT_MS;
+}
+
+export function createUpstreamAttemptSignal({ signal = null, timeoutMs, deadlineAt = null } = {}) {
+  const configuredTimeoutMs = resolveTimeoutMs(timeoutMs);
+  const remainingMs = deadlineAt == null ? Infinity : Number(deadlineAt) - Date.now();
+
+  if (remainingMs <= 0) {
+    throw new UpstreamTimeoutError("Upstream request deadline exceeded", {
+      kind: "deadline",
+      timeoutMs: 0,
+    });
+  }
+
+  const budgetMs = Math.max(1, Math.min(configuredTimeoutMs, remainingMs));
+  const kind = Number.isFinite(remainingMs) && remainingMs <= configuredTimeoutMs
+    ? "deadline"
+    : "attempt";
+  const timeoutError = new UpstreamTimeoutError(
+    kind === "deadline"
+      ? "Upstream request deadline exceeded"
+      : `Upstream attempt timed out after ${Math.ceil(budgetMs)}ms`,
+    { kind, timeoutMs: budgetMs },
+  );
+  const timeoutController = new AbortController();
+  const mergedSignal = signal
+    ? AbortSignal.any([signal, timeoutController.signal])
+    : timeoutController.signal;
+  const timer = setTimeout(() => timeoutController.abort(timeoutError), budgetMs);
+
+  return {
+    signal: mergedSignal,
+    timeoutError,
+    timeoutMs: budgetMs,
+    wasTimeout: () => timeoutController.signal.aborted && !signal?.aborted,
+    cleanup: () => clearTimeout(timer),
+  };
+}
+
+export async function executeWithAttemptDeadline(execute, options = {}) {
+  const attempt = createUpstreamAttemptSignal(options);
+  try {
+    return await execute(attempt.signal, attempt.timeoutMs);
+  } catch (error) {
+    if (attempt.wasTimeout()) throw attempt.timeoutError;
+    throw error;
+  } finally {
+    attempt.cleanup();
+  }
+}