oh-my-opencode 1.2.3 → 1.2.4

package/dist/google-auth.js

@@ -1130,6 +1130,32 @@ function isRetryableError(status) {
     return true;
   return false;
 }
+var GCP_PERMISSION_ERROR_PATTERNS = [
+  "PERMISSION_DENIED",
+  "does not have permission",
+  "Cloud AI Companion API has not been used",
+  "has not been enabled"
+];
+function isGcpPermissionError(text) {
+  return GCP_PERMISSION_ERROR_PATTERNS.some((pattern) => text.includes(pattern));
+}
+function calculateRetryDelay(attempt) {
+  return Math.min(200 * Math.pow(2, attempt), 2000);
+}
+async function isRetryableResponse(response) {
+  if (isRetryableError(response.status))
+    return true;
+  if (response.status === 403) {
+    try {
+      const text = await response.clone().text();
+      if (text.includes("SUBSCRIPTION_REQUIRED") || text.includes("Gemini Code Assist license")) {
+        debugLog3(`[RETRY] 403 SUBSCRIPTION_REQUIRED detected, will retry with next endpoint`);
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}
 async function attemptFetch(options) {
   const { endpoint, url, init, accessToken, projectId, sessionId, modelName, thoughtSignature } = options;
   debugLog3(`Trying endpoint: ${endpoint}`);
@@ -1178,18 +1204,40 @@ async function attemptFetch(options) {
       thoughtSignature
     });
     debugLog3(`[REQ] streaming=${transformed.streaming}, url=${transformed.url}`);
-    const response = await fetch(transformed.url, {
-      method: init.method || "POST",
-      headers: transformed.headers,
-      body: JSON.stringify(transformed.body),
-      signal: init.signal
-    });
-    debugLog3(`[RESP] status=${response.status} content-type=${response.headers.get("content-type") ?? ""} url=${response.url}`);
-    if (!response.ok && isRetryableError(response.status)) {
-      debugLog3(`Endpoint failed: ${endpoint} (status: ${response.status}), trying next`);
-      return null;
+    const maxPermissionRetries = 10;
+    for (let attempt = 0;attempt <= maxPermissionRetries; attempt++) {
+      const response = await fetch(transformed.url, {
+        method: init.method || "POST",
+        headers: transformed.headers,
+        body: JSON.stringify(transformed.body),
+        signal: init.signal
+      });
+      debugLog3(`[RESP] status=${response.status} content-type=${response.headers.get("content-type") ?? ""} url=${response.url}`);
+      if (response.status === 401) {
+        debugLog3(`[401] Unauthorized response detected, signaling token refresh needed`);
+        return "needs-refresh";
+      }
+      if (response.status === 403) {
+        try {
+          const text = await response.clone().text();
+          if (isGcpPermissionError(text)) {
+            if (attempt < maxPermissionRetries) {
+              const delay = calculateRetryDelay(attempt);
+              debugLog3(`[RETRY] GCP permission error, retry ${attempt + 1}/${maxPermissionRetries} after ${delay}ms`);
+              await new Promise((resolve) => setTimeout(resolve, delay));
+              continue;
+            }
+            debugLog3(`[RETRY] GCP permission error, max retries exceeded`);
+          }
+        } catch {}
+      }
+      if (!response.ok && await isRetryableResponse(response)) {
+        debugLog3(`Endpoint failed: ${endpoint} (status: ${response.status}), trying next`);
+        return null;
+      }
+      return response;
     }
-    return response;
+    return null;
   } catch (error) {
     debugLog3(`Endpoint failed: ${endpoint} (${error instanceof Error ? error.message : "Unknown error"}), trying next`);
     return null;
@@ -1318,45 +1366,99 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
     const sessionId = getOrCreateSessionId(fetchInstanceId);
     const thoughtSignature = getThoughtSignature(fetchInstanceId);
     debugLog3(`[TSIG][GET] sessionId=${sessionId}, signature=${thoughtSignature ? thoughtSignature.substring(0, 20) + "..." : "none"}`);
-    for (let i = 0;i < maxEndpoints; i++) {
-      const endpoint = ANTIGRAVITY_ENDPOINT_FALLBACKS[i];
-      const response = await attemptFetch({
-        endpoint,
-        url,
-        init,
-        accessToken: cachedTokens.access_token,
-        projectId,
-        sessionId,
-        modelName,
-        thoughtSignature
-      });
-      if (response === "pass-through") {
-        debugLog3("Non-string body detected, passing through with auth headers");
-        const headersWithAuth = {
-          ...init.headers,
-          Authorization: `Bearer ${cachedTokens.access_token}`
-        };
-        return fetch(url, { ...init, headers: headersWithAuth });
-      }
-      if (response) {
-        debugLog3(`Success with endpoint: ${endpoint}`);
-        const transformedResponse = await transformResponseWithThinking(response, modelName || "", fetchInstanceId);
-        return transformedResponse;
-      }
-    }
-    const errorMessage = `All Antigravity endpoints failed after ${maxEndpoints} attempts`;
-    debugLog3(errorMessage);
-    return new Response(JSON.stringify({
-      error: {
-        message: errorMessage,
-        type: "endpoint_failure",
-        code: "all_endpoints_failed"
+    let hasRefreshedFor401 = false;
+    const executeWithEndpoints = async () => {
+      for (let i = 0;i < maxEndpoints; i++) {
+        const endpoint = ANTIGRAVITY_ENDPOINT_FALLBACKS[i];
+        const response = await attemptFetch({
+          endpoint,
+          url,
+          init,
+          accessToken: cachedTokens.access_token,
+          projectId,
+          sessionId,
+          modelName,
+          thoughtSignature
+        });
+        if (response === "pass-through") {
+          debugLog3("Non-string body detected, passing through with auth headers");
+          const headersWithAuth = {
+            ...init.headers,
+            Authorization: `Bearer ${cachedTokens.access_token}`
+          };
+          return fetch(url, { ...init, headers: headersWithAuth });
+        }
+        if (response === "needs-refresh") {
+          if (hasRefreshedFor401) {
+            debugLog3("[401] Already refreshed once, returning unauthorized error");
+            return new Response(JSON.stringify({
+              error: {
+                message: "Authentication failed after token refresh",
+                type: "unauthorized",
+                code: "token_refresh_failed"
+              }
+            }), {
+              status: 401,
+              statusText: "Unauthorized",
+              headers: { "Content-Type": "application/json" }
+            });
+          }
+          debugLog3("[401] Refreshing token and retrying...");
+          hasRefreshedFor401 = true;
+          try {
+            const newTokens = await refreshAccessToken(refreshParts.refreshToken, clientId, clientSecret);
+            cachedTokens = {
+              type: "antigravity",
+              access_token: newTokens.access_token,
+              refresh_token: newTokens.refresh_token,
+              expires_in: newTokens.expires_in,
+              timestamp: Date.now()
+            };
+            clearProjectContextCache();
+            const formattedRefresh = formatTokenForStorage(newTokens.refresh_token, refreshParts.projectId || "", refreshParts.managedProjectId);
+            await client.set(providerId, {
+              access: newTokens.access_token,
+              refresh: formattedRefresh,
+              expires: Date.now() + newTokens.expires_in * 1000
+            });
+            debugLog3("[401] Token refreshed, retrying request...");
+            return executeWithEndpoints();
+          } catch (refreshError) {
+            debugLog3(`[401] Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`);
+            return new Response(JSON.stringify({
+              error: {
+                message: `Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`,
+                type: "unauthorized",
+                code: "token_refresh_failed"
+              }
+            }), {
+              status: 401,
+              statusText: "Unauthorized",
+              headers: { "Content-Type": "application/json" }
+            });
+          }
+        }
+        if (response) {
+          debugLog3(`Success with endpoint: ${endpoint}`);
+          const transformedResponse = await transformResponseWithThinking(response, modelName || "", fetchInstanceId);
+          return transformedResponse;
+        }
       }
-    }), {
-      status: 503,
-      statusText: "Service Unavailable",
-      headers: { "Content-Type": "application/json" }
-    });
+      const errorMessage = `All Antigravity endpoints failed after ${maxEndpoints} attempts`;
+      debugLog3(errorMessage);
+      return new Response(JSON.stringify({
+        error: {
+          message: errorMessage,
+          type: "endpoint_failure",
+          code: "all_endpoints_failed"
+        }
+      }), {
+        status: 503,
+        statusText: "Service Unavailable",
+        headers: { "Content-Type": "application/json" }
+      });
+    };
+    return executeWithEndpoints();
   };
 }
 // src/auth/antigravity/plugin.ts