fix(gemini): API field casing, safety finish reasons, pagination timeout

.gitignore

@@ -56,6 +56,7 @@ next-env.d.ts
 
 # data and logs
 data/
+.data/
 logs/*
 
 # analysis directories (generated, not tracked)
@@ -153,4 +154,7 @@ vscode-extension/
 typescript
 
 # Gemini Antigravity agent data
-.gemini/
+.gemini/
+
+# Superpowers plans/specs (internal tooling, not project code)
+docs/superpowers/

open-sse/config/providerRegistry.ts

@@ -192,22 +192,9 @@ export const REGISTRY: Record<string, RegistryEntry> = {
       clientSecretEnv: "GEMINI_OAUTH_CLIENT_SECRET",
       clientSecretDefault: "",
     },
-    models: [
-      { id: "gemini-3.1-pro-high", name: "Gemini 3.1 Pro High" },
-      { id: "gemini-3.1-pro-low", name: "Gemini 3.1 Pro Low" },
-      { id: "gemini-3.1-pro", name: "Gemini 3.1 Pro" },
-      { id: "gemini-3-1-pro", name: "Gemini 3.1 Pro (Alt ID)" },
-      { id: "gemini-3.1-pro-preview", name: "Gemini 3.1 Pro Preview" },
-      { id: "gemini-3.1-flash-lite-preview", name: "Gemini 3.1 Flash Lite Preview" },
-      { id: "gemini-3-flash-preview", name: "Gemini 3 Flash Preview" },
-      { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro" },
-      { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash" },
-      { id: "gemini-2.5-flash-lite", name: "Gemini 2.5 Flash Lite" },
-      { id: "gemini-2.0-flash", name: "Gemini 2.0 Flash" },
-      { id: "gemini-2.0-flash-exp", name: "Gemini 2.0 Flash Exp" },
-      { id: "gemini-1.5-pro", name: "Gemini 1.5 Pro" },
-      { id: "gemini-1.5-flash", name: "Gemini 1.5 Flash" },
-    ],
+    models: [],
+    // Models are populated from Google's API via sync-models (per API key).
+    // No hardcoded fallback — show nothing until a key is added.
   },
 
   "gemini-cli": {

open-sse/handlers/chatCore.ts

@@ -13,7 +13,9 @@ import { refreshWithRetry } from "../services/tokenRefresh.ts";
 import { createRequestLogger } from "../utils/requestLogger.ts";
 import { getModelTargetFormat, PROVIDER_ID_TO_ALIAS } from "../config/providerModels.ts";
 import { resolveModelAlias } from "../services/modelDeprecation.ts";
-import { getUnsupportedParams, getPassthroughProviders } from "../config/providerRegistry.ts";
+import { getUnsupportedParams } from "../config/providerRegistry.ts";
+import { hasPerModelQuota, lockModelIfPerModelQuota } from "../services/accountFallback.ts";
+import { COOLDOWN_MS } from "../config/constants.ts";
 import {
   buildErrorBody,
   createErrorResult,
@@ -1375,16 +1377,12 @@ export async function handleChatCore({
             `[provider] Node ${connectionId} account deactivated (${statusCode}) — disabling permanently`
           );
         } else if (errorType === PROVIDER_ERROR_TYPES.RATE_LIMITED) {
-          // For passthrough providers (e.g. Antigravity), each model has independent
-          // quota.  A 429 on one model must NOT lock out the entire connection — other
-          // models may still have quota available.  Use lockModel() instead.
-          const isPassthrough = provider && getPassthroughProviders().has(provider);
-          if (isPassthrough) {
-            const { lockModel } = await import("../services/accountFallback.ts");
-            const cooldown = retryAfterMs || 120_000; // 2 min default, same as COOLDOWN_MS.rateLimit
-            lockModel(provider, connectionId, model, "rate_limited", cooldown);
+          // For providers with per-model quotas (passthrough providers, Gemini),
+          // each model has independent quota. A 429 on one model must NOT lock out
+          // the entire connection — other models may still have quota available.
+          if (lockModelIfPerModelQuota(provider, connectionId, model, "rate_limited", retryAfterMs || COOLDOWN_MS.rateLimit)) {
             console.warn(
-              `[provider] Node ${connectionId} model-only rate limited (${statusCode}) for ${model} - ${Math.ceil(cooldown / 1000)}s (connection stays active)`
+              `[provider] Node ${connectionId} model-only rate limited (${statusCode}) for ${model} - ${Math.ceil((retryAfterMs || COOLDOWN_MS.rateLimit) / 1000)}s (connection stays active)`
             );
           } else {
             const rateLimitedUntil = new Date(Date.now() + retryAfterMs).toISOString();
@@ -1402,13 +1400,20 @@ export async function handleChatCore({
             );
           }
         } else if (errorType === PROVIDER_ERROR_TYPES.QUOTA_EXHAUSTED) {
-          await updateProviderConnection(connectionId, {
-            testStatus: "credits_exhausted",
-            lastErrorType: errorType,
-            lastError: message,
-            errorCode: statusCode,
-          });
-          console.warn(`[provider] Node ${connectionId} exhausted quota (${statusCode})`);
+          // Providers with per-model quotas — lock the model only, not the connection
+          if (lockModelIfPerModelQuota(provider, connectionId, model, "quota_exhausted", retryAfterMs || COOLDOWN_MS.rateLimit)) {
+            console.warn(
+              `[provider] Node ${connectionId} model-only quota exhausted (${statusCode}) for ${model} - ${Math.ceil((retryAfterMs || COOLDOWN_MS.rateLimit) / 1000)}s (connection stays active)`
+            );
+          } else {
+            await updateProviderConnection(connectionId, {
+              testStatus: "credits_exhausted",
+              lastErrorType: errorType,
+              lastError: message,
+              errorCode: statusCode,
+            });
+            console.warn(`[provider] Node ${connectionId} exhausted quota (${statusCode})`);
+          }
         } else if (errorType === PROVIDER_ERROR_TYPES.ACCOUNT_DEACTIVATED) {
           await updateProviderConnection(connectionId, {
             isActive: false,

open-sse/services/accountFallback.ts

@@ -100,13 +100,49 @@ export function lockModel(provider, connectionId, model, reason, cooldownMs) {
   if (!model) return; // No model → skip model-level locking
   ensureCleanupTimer();
   const key = `${provider}:${connectionId}:${model}`;
+  const newUntil = Date.now() + cooldownMs;
+  // Preserve the longer cooldown if an existing lock has more time remaining.
+  // Safe without a mutex: no await between get/set, so this runs atomically
+  // within Node.js's single-threaded event loop.
+  const existing = modelLockouts.get(key);
+  if (existing && existing.until > newUntil) return;
   modelLockouts.set(key, {
     reason,
-    until: Date.now() + cooldownMs,
+    until: newUntil,
     lockedAt: Date.now(),
   });
 }
 
+/**
+ * Whether a provider should use per-model lockouts instead of connection-wide cooldowns.
+ * Gemini AI Studio has per-model quotas; passthrough providers have independent model limits.
+ */
+export function hasPerModelQuota(provider: string): boolean {
+  if (provider === "gemini") return true;
+  try {
+    const { getPassthroughProviders } = require("../config/providerRegistry.ts");
+    return getPassthroughProviders().has(provider);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Lock a model (not connection) for a provider with per-model quotas.
+ * No-ops for providers that don't use per-model lockouts.
+ */
+export function lockModelIfPerModelQuota(
+  provider: string,
+  connectionId: string,
+  model: string | null,
+  reason: string,
+  cooldownMs: number
+): boolean {
+  if (!hasPerModelQuota(provider) || !model) return false;
+  lockModel(provider, connectionId, model, reason, cooldownMs);
+  return true;
+}
+
 /**
  * Check if a specific model on a specific account is locked
  * @returns {boolean}

open-sse/services/rateLimitManager.ts

@@ -200,6 +200,11 @@ function getLimiterKey(provider, connectionId, model = null) {
   if (provider === "codex" && model) {
     return `${provider}:${getCodexRateLimitKey(connectionId, model)}`;
   }
+  // Gemini AI Studio has per-model quotas — use model-scoped limiter keys
+  // so a 429 on one model doesn't pause requests for other models.
+  if (provider === "gemini" && model) {
+    return `${provider}:${connectionId}:${model}`;
+  }
   return `${provider}:${connectionId}`;
 }
 
@@ -570,7 +575,7 @@ export function updateFromResponseBody(provider, connectionId, responseBody, sta
   const { retryAfterMs, reason } = parseRetryAfterFromBody(responseBody);
 
   if (retryAfterMs && retryAfterMs > 0) {
-    const limiter = getLimiter(provider, connectionId, null);
+    const limiter = getLimiter(provider, connectionId, model);
     console.log(
       `🚫 [RATE-LIMIT] ${provider}:${connectionId.slice(0, 8)} — body-parsed retry: ${Math.ceil(retryAfterMs / 1000)}s (${reason})`
     );

open-sse/translator/helpers/geminiHelper.ts

@@ -84,7 +84,7 @@ export function convertOpenAIContentToParts(content) {
           const mimeType = mimePart.split(";")[0];
 
           parts.push({
-            inlineData: { mime_type: mimeType, data: data },
+            inlineData: { mimeType, data },
           });
         }
       }

open-sse/translator/request/claude-to-gemini.ts

@@ -192,7 +192,7 @@ export function claudeToGeminiRequest(model, body, stream) {
   if (body.thinking?.type === "enabled" && body.thinking.budget_tokens) {
     result.generationConfig.thinkingConfig = {
       thinkingBudget: body.thinking.budget_tokens,
-      include_thoughts: true,
+      includeThoughts: true,
     };
   }
 

open-sse/translator/request/gemini-to-openai.ts

@@ -92,11 +92,13 @@ function convertGeminiContent(content) {
       parts.push({ type: "text", text: part.text });
     }
 
-    if (part.inlineData) {
+    if (part.inlineData || part.inline_data) {
+      const data = part.inlineData || part.inline_data;
+      const mimeType = data.mimeType || data.mime_type || "image/png";
       parts.push({
         type: "image_url",
         image_url: {
-          url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
+          url: `data:${mimeType};base64,${data.data}`,
         },
       });
     }

open-sse/translator/request/openai-to-gemini.ts

@@ -33,7 +33,7 @@ type GeminiGenerationConfig = {
   maxOutputTokens?: unknown;
   thinkingConfig?: {
     thinkingBudget: number;
-    include_thoughts: boolean;
+    includeThoughts: boolean;
   };
   responseMimeType?: string;
   responseSchema?: unknown;
@@ -317,15 +317,15 @@ export function openaiToGeminiCLIRequest(model, body, stream) {
     const budget = budgetMap[body.reasoning_effort] || getDefaultThinkingBudget(model) || 8192;
     gemini.generationConfig.thinkingConfig = {
       thinkingBudget: budget,
-      include_thoughts: true,
+      includeThoughts: true,
     };
   }
 
   // Thinking config from Claude format
   if (body.thinking?.type === "enabled" && body.thinking.budget_tokens) {
     gemini.generationConfig.thinkingConfig = {
       thinkingBudget: body.thinking.budget_tokens,
-      include_thoughts: true,
+      includeThoughts: true,
     };
   }
 
@@ -446,7 +446,7 @@ function wrapInCloudCodeEnvelopeForClaude(model, claudeRequest, credentials = nu
           } else if (block.type === "image" && block.source) {
             parts.push({
               inlineData: {
-                mime_type: block.source.media_type,
+                mimeType: block.source.media_type,
                 data: block.source.data,
               },
             });

open-sse/translator/response/gemini-to-claude.ts

@@ -171,6 +171,11 @@ export function geminiToClaudeResponse(chunk, state) {
       stopReason = "tool_use";
     } else if (reason === "max_tokens" || reason === "length") {
       stopReason = "max_tokens";
+    } else if (reason === "safety" || reason === "recitation" || reason === "blocklist") {
+      // Content blocked by Gemini safety. Any text streamed before this finish
+      // reason has already been emitted to the client — this is unavoidable in
+      // SSE streaming. Map to end_turn (Claude has no "content blocked" reason).
+      stopReason = "end_turn";
     } else {
       stopReason = "end_turn";
     }

open-sse/translator/response/gemini-to-openai.ts

@@ -225,6 +225,11 @@ export function geminiToOpenAIResponse(chunk, state) {
     if (finishReason === "stop" && state.toolCalls.size > 0) {
       finishReason = "tool_calls";
     }
+    // Content blocked by Gemini safety filters — pass through as "content_filter"
+    // so downstream clients can distinguish from normal completion.
+    if (finishReason === "safety" || finishReason === "recitation" || finishReason === "blocklist") {
+      finishReason = "content_filter";
+    }
 
     const finalChunk: Record<string, unknown> = {
       id: `chatcmpl-${state.messageId}`,