opencode-antigravity-auth-tweaked 1.8.7 → 1.9.0

package/dist/src/plugin.js

@@ -792,7 +792,7 @@ function extractRateLimitBodyInfo(body, rawBody) {
     let directMessage = undefined;
     // Pattern 1: { error: { message, details, ... } } - Google API format
     const errorProp = body.error;
-    if (errorProp) {
+    if (errorProp && typeof errorProp === "object") {
         error = errorProp;
     }
     // Pattern 2: { message: string } - Direct message format
@@ -864,6 +864,10 @@ function extractRateLimitBodyInfo(body, rawBody) {
 async function extractRetryInfoFromBody(response) {
     try {
         const text = await response.clone().text();
+        // Handle empty response
+        if (!text || text.trim() === "") {
+            return { retryDelayMs: null, rawBody: text };
+        }
         try {
             let parsed = JSON.parse(text);
             // Handle case where response is wrapped in an array (SSE stream or batched response)
@@ -874,15 +878,33 @@ async function extractRetryInfoFromBody(response) {
             // Always include raw body for fallback display
             return { ...info, rawBody: text };
         }
-        catch {
+        catch (parseError) {
             // JSON parsing failed, but text might contain a plain error message
+            // Return the raw text as the message
             return { retryDelayMs: null, message: text.trim() || undefined, rawBody: text };
         }
     }
-    catch {
+    catch (readError) {
+        // Failed to read response body at all
         return { retryDelayMs: null };
     }
 }
+/**
+ * Extract error message from raw response body when structured parsing fails.
+ * Uses regex to find message field in JSON-like content.
+ */
+function extractMessageFromRawBody(rawBody) {
+    if (!rawBody || rawBody.trim() === "")
+        return undefined;
+    // Try to find "message": "..." pattern in the raw body
+    // This regex handles escaped quotes within the message value
+    const messageMatch = rawBody.match(/"message"\s*:\s*"((?:[^"\\]|\\.)*)"/i);
+    if (messageMatch && messageMatch[1]) {
+        // Unescape JSON string
+        return messageMatch[1].replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+    }
+    return undefined;
+}
 function formatWaitTime(ms) {
     if (ms < 1000)
         return `${ms}ms`;
@@ -1497,7 +1519,12 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                 });
                                 try {
                                     pushDebug("thinking-warmup: start");
-                                    const warmupResponse = await fetch(warmupUrl, warmupInit);
+                                    // Add 30s timeout for warmup to prevent hanging the main request
+                                    const warmupTimeoutSignal = AbortSignal.timeout(30000);
+                                    const combinedWarmupSignal = warmupInit.signal
+                                        ? AbortSignal.any([warmupInit.signal, warmupTimeoutSignal])
+                                        : warmupTimeoutSignal;
+                                    const warmupResponse = await fetch(warmupUrl, { ...warmupInit, signal: combinedWarmupSignal });
                                     const transformed = await transformAntigravityResponse(warmupResponse, true, warmupDebugContext, prepared.requestedModel, projectId, warmupUrl, prepared.effectiveModel, prepared.sessionId);
                                     await transformed.text();
                                     markWarmupSuccess(prepared.sessionId);
@@ -1597,6 +1624,10 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             claudePromptAutoCaching: config.claude_prompt_auto_caching,
                                             fingerprint: account.fingerprint,
                                         });
+                                        // Show recovery message if present (e.g. session fixation)
+                                        if (prepared.thinkingRecoveryMessage) {
+                                            await showToast(prepared.thinkingRecoveryMessage, "info");
+                                        }
                                         const originalUrl = toUrlString(input);
                                         const resolvedUrl = toUrlString(prepared.request);
                                         pushDebug(`endpoint=${currentEndpoint}`);
@@ -1637,9 +1668,43 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                         }
                                         // Increment active requests for concurrency tracking
                                         getConcurrencyTracker().increment(account.index);
+                                        // Calculate timeout for this request
+                                        const timeoutMs = (config.request_timeout_seconds ?? 120) * 1000;
+                                        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+                                        const combinedSignal = prepared.init.signal
+                                            ? AbortSignal.any([prepared.init.signal, timeoutSignal])
+                                            : timeoutSignal;
                                         let response;
                                         try {
-                                            response = await fetch(prepared.request, prepared.init);
+                                            response = await fetch(prepared.request, { ...prepared.init, signal: combinedSignal });
+                                        }
+                                        catch (error) {
+                                            // Special handling for timeouts to provide better user feedback
+                                            if (error instanceof Error && (error.name === "TimeoutError" || (error.name === "AbortError" && timeoutSignal.aborted))) {
+                                                const timeoutMsg = `Request timed out after ${config.request_timeout_seconds}s`;
+                                                pushDebug(timeoutMsg);
+                                                await showToast(`${timeoutMsg}. Try a different model or endpoint.`, "error");
+                                                // Treat timeout as a 504 Gateway Timeout for the purpose of fallback logic
+                                                lastFailure = {
+                                                    response: new Response(JSON.stringify({ error: { message: timeoutMsg } }), {
+                                                        status: 504,
+                                                        statusText: "Gateway Timeout",
+                                                        headers: { "Content-Type": "application/json" }
+                                                    }),
+                                                    streaming: prepared.streaming,
+                                                    debugContext,
+                                                    requestedModel: prepared.requestedModel,
+                                                    projectId: projectContext.effectiveProjectId,
+                                                    endpoint: prepared.endpoint,
+                                                    effectiveModel: prepared.effectiveModel,
+                                                    sessionId: prepared.sessionId,
+                                                    toolDebugMissing: prepared.toolDebugMissing,
+                                                    toolDebugSummary: prepared.toolDebugSummary,
+                                                    toolDebugPayload: prepared.toolDebugPayload,
+                                                };
+                                                continue; // Try next endpoint or account
+                                            }
+                                            throw error;
                                         }
                                         finally {
                                             // Decrement active requests - MUST happen even on network errors
@@ -1662,8 +1727,13 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             const headerRetryMs = retryAfterMsFromResponse(response, defaultRetryMs);
                                             const bodyInfo = await extractRetryInfoFromBody(response);
                                             const serverRetryMs = bodyInfo.retryDelayMs ?? headerRetryMs;
+                                            // Extract message from raw body if structured extraction failed
+                                            // This ensures we can still classify the error correctly
+                                            const messageForClassification = bodyInfo.message
+                                                || extractMessageFromRawBody(bodyInfo.rawBody || "")
+                                                || undefined;
                                             // [Enhanced Parsing] Pass status to handling logic
-                                            const rateLimitReason = parseRateLimitReason(bodyInfo.reason, bodyInfo.message, response.status);
+                                            const rateLimitReason = parseRateLimitReason(bodyInfo.reason, messageForClassification, response.status);
                                             // Calculate backoff/wait time
                                             const quotaKey = headerStyleToQuotaKey(headerStyle, family);
                                             const { attempt, delayMs } = getRateLimitBackoff(account.index, quotaKey, serverRetryMs);
@@ -1681,17 +1751,23 @@ export const createAntigravityPlugin = (providerId) => async ({ client, director
                                             await logResponseBody(debugContext, response, response.status);
                                             getHealthTracker().recordRateLimit(account.index);
                                             // Define display reason for user feedback
-                                            // Never show "UNKNOWN" - show the full response body or "NO_BODY" instead
+                                            // Never show "UNKNOWN" - show the actual server message or "NO_BODY" instead
                                             let displayReason;
                                             if (bodyInfo.message && bodyInfo.message.trim()) {
                                                 displayReason = bodyInfo.message;
                                             }
-                                            else if (bodyInfo.rawBody && bodyInfo.rawBody.trim()) {
-                                                // Show the full raw response body when parsing failed or no structured message found
-                                                displayReason = bodyInfo.rawBody;
-                                            }
                                             else {
-                                                displayReason = "NO_BODY";
+                                                // Try to extract a message from raw body as a last resort
+                                                const extractedMessage = extractMessageFromRawBody(bodyInfo.rawBody || "");
+                                                if (extractedMessage && extractedMessage.trim()) {
+                                                    displayReason = extractedMessage;
+                                                }
+                                                else if (bodyInfo.rawBody && bodyInfo.rawBody.trim()) {
+                                                    displayReason = bodyInfo.rawBody;
+                                                }
+                                                else {
+                                                    displayReason = "NO_BODY";
+                                                }
                                             }
                                             // ENHANCED RATE LIMIT HANDLING:
                                             // Actually wait for the ratelimited amount of time (plus 1-3s random jitter)