@anthonyhaussman/opencode-agy-auth 1.1.13 → 1.1.14-alpha.1

package/dist/index.js

@@ -516,6 +516,69 @@ function normalizeErrorEnvelope(parsed) {
   }
   return isObject(parsed) ? parsed : null;
 }
+var MAX_QUOTA_RESET_WAIT_MS = 72e5;
+function findResetTimeForModel(summary, model) {
+  if (!summary) return null;
+  const normalize2 = (str) => str.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const modelNorm = model ? normalize2(model) : "";
+  let targetGroups = summary.groups ?? [];
+  if (modelNorm && targetGroups.length > 0) {
+    const matched = targetGroups.filter((g) => {
+      const gName = normalize2(g.displayName ?? "");
+      return gName.includes(modelNorm) || modelNorm.includes(gName);
+    });
+    if (matched.length > 0) {
+      targetGroups = matched;
+    }
+  }
+  const allBuckets = [];
+  for (const group of targetGroups) {
+    if (group.buckets) {
+      allBuckets.push(...group.buckets);
+    }
+  }
+  if (allBuckets.length === 0 && summary.buckets) {
+    allBuckets.push(...summary.buckets);
+  }
+  const now = Date.now();
+  const validResetBuckets = allBuckets.filter((b) => {
+    if (!b.resetTime) return false;
+    const t = new Date(b.resetTime).getTime();
+    return !Number.isNaN(t) && t > now;
+  });
+  if (validResetBuckets.length === 0) {
+    return null;
+  }
+  const exhaustedFiveHour = validResetBuckets.find(
+    (b) => (b.remainingFraction === 0 || b.disabled) && b.window?.toUpperCase() === "FIVE_HOUR"
+  );
+  if (exhaustedFiveHour?.resetTime) return exhaustedFiveHour.resetTime;
+  const exhaustedAny = validResetBuckets.find((b) => b.remainingFraction === 0 || b.disabled);
+  if (exhaustedAny?.resetTime) return exhaustedAny.resetTime;
+  const fiveHour = validResetBuckets.find((b) => b.window?.toUpperCase() === "FIVE_HOUR");
+  if (fiveHour?.resetTime) return fiveHour.resetTime;
+  validResetBuckets.sort(
+    (a, b) => new Date(a.resetTime).getTime() - new Date(b.resetTime).getTime()
+  );
+  return validResetBuckets[0]?.resetTime ?? null;
+}
+async function resolveQuotaResetDelay(accessToken, projectId, model, userAgentModel) {
+  try {
+    const summary = await retrieveUserQuotaSummary(accessToken, projectId, userAgentModel);
+    if (!summary) return null;
+    const resetTime = findResetTimeForModel(summary, model);
+    if (!resetTime) return null;
+    const resetTimestamp = new Date(resetTime).getTime();
+    if (Number.isNaN(resetTimestamp)) return null;
+    const waitMs = resetTimestamp - Date.now() + 1e3;
+    if (waitMs <= 0 || waitMs > MAX_QUOTA_RESET_WAIT_MS) {
+      return null;
+    }
+    return { waitMs, resetTime };
+  } catch {
+    return null;
+  }
+}
 
 // src/sdk/retry/helpers.ts
 var DEFAULT_MAX_ATTEMPTS = 3;
@@ -812,6 +875,7 @@ async function fetchWithRetry(input, init) {
   const throttleKey = buildRetryThrottleKey(input, retryInit);
   await waitForRetryCooldown(throttleKey, retryInit.signal);
   let attempt = 1;
+  let hasRetriedQuotaReset = false;
   const url2 = readRequestUrl(input);
   while (attempt <= DEFAULT_MAX_ATTEMPTS) {
     let response;
@@ -837,6 +901,25 @@ async function fetchWithRetry(input, init) {
       if (quotaContext.reason === "MODEL_CAPACITY_EXHAUSTED") {
         const cooldownMs = quotaContext.retryDelayMs ?? MODEL_CAPACITY_COOLDOWN_MS;
         setRetryCooldown(throttleKey, cooldownMs);
+        return response;
+      }
+      if (quotaContext.reason === "QUOTA_EXHAUSTED" && !hasRetriedQuotaReset && !retryInit.signal?.aborted) {
+        const body = typeof retryInit.body === "string" ? safeParseBody(retryInit.body) : null;
+        const project = readString(body?.project);
+        const model = readString(body?.model);
+        const token = extractAuthToken(retryInit.headers);
+        if (token && project) {
+          const resetInfo = await resolveQuotaResetDelay(token, project, model);
+          if (resetInfo && resetInfo.waitMs > 0 && resetInfo.waitMs <= MAX_QUOTA_RESET_WAIT_MS) {
+            hasRetriedQuotaReset = true;
+            setRetryCooldown(throttleKey, resetInfo.waitMs);
+            await wait(resetInfo.waitMs);
+            if (retryInit.signal?.aborted) {
+              return response;
+            }
+            continue;
+          }
+        }
       }
       return response;
     }
@@ -922,6 +1005,14 @@ function safeParseBody(body) {
 function readString(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
+function extractAuthToken(headers) {
+  if (!headers) return void 0;
+  const h = new Headers(headers);
+  const auth = h.get("authorization") || h.get("Authorization");
+  if (!auth) return void 0;
+  const match = auth.match(/^Bearer\s+(.+)$/i);
+  return match?.[1]?.trim() || auth.trim();
+}
 
 // src/sdk/terminal-hyperlink.ts
 var OSC8_OPEN = "\x1B]8;;";
@@ -17756,7 +17847,7 @@ function normalizeRequestPayloadIdentifiers(payload) {
 }
 
 // src/sdk/request/openai.ts
-function transformOpenAIToolCalls(requestPayload) {
+function transformOpenAIToolCalls(requestPayload, toolMapper) {
   const messages = requestPayload.messages;
   if (!messages || !Array.isArray(messages)) {
     return;
@@ -17782,10 +17873,11 @@ function transformOpenAIToolCalls(requestPayload) {
       if (!fn || typeof fn !== "object") {
         continue;
       }
-      const name = fn.name;
+      const rawName = fn.name ?? "";
+      const name = toolMapper ? toolMapper.toGemini(rawName) : rawName;
       const args = parseJsonObject(fn.arguments);
       const functionCallPart = {
-        name: name ?? "",
+        name,
         args
       };
       if (typeof toolCall.id === "string" && toolCall.id.length > 0) {
@@ -17845,6 +17937,165 @@ function parseJsonObject(value) {
   }
 }
 
+// src/sdk/request/tool-mapper.ts
+function sanitizeToolName(name) {
+  if (!name || typeof name !== "string") {
+    return "unnamed_tool";
+  }
+  let sanitized = name.replace(/[^a-zA-Z0-9_]/g, "_");
+  if (!/^[a-zA-Z_]/.test(sanitized)) {
+    sanitized = `_${sanitized}`;
+  }
+  return sanitized;
+}
+var ToolMapper = class {
+  originalToSanitized = /* @__PURE__ */ new Map();
+  sanitizedToOriginal = /* @__PURE__ */ new Map();
+  /**
+   * Register a tool name and get its Gemini-compliant sanitized name.
+   * Handles naming collisions by appending a numeric suffix if needed.
+   */
+  register(originalName) {
+    if (!originalName || typeof originalName !== "string") {
+      return originalName;
+    }
+    const existing = this.originalToSanitized.get(originalName);
+    if (existing) {
+      return existing;
+    }
+    const baseSanitized = sanitizeToolName(originalName);
+    let sanitized = baseSanitized;
+    let counter = 1;
+    while (this.sanitizedToOriginal.has(sanitized) && this.sanitizedToOriginal.get(sanitized) !== originalName) {
+      sanitized = `${baseSanitized}_${counter++}`;
+    }
+    this.originalToSanitized.set(originalName, sanitized);
+    this.sanitizedToOriginal.set(sanitized, originalName);
+    return sanitized;
+  }
+  /**
+   * Map an original tool name to sanitized Gemini name.
+   * If not already registered, registers it on the fly.
+   */
+  toGemini(originalName) {
+    if (!originalName || typeof originalName !== "string") {
+      return originalName;
+    }
+    const sanitized = this.originalToSanitized.get(originalName);
+    if (sanitized) {
+      return sanitized;
+    }
+    return this.register(originalName);
+  }
+  /**
+   * Restore a sanitized Gemini tool name back to the original client tool name.
+   */
+  fromGemini(sanitizedName) {
+    if (!sanitizedName || typeof sanitizedName !== "string") {
+      return sanitizedName;
+    }
+    return this.sanitizedToOriginal.get(sanitizedName) ?? sanitizedName;
+  }
+  /**
+   * Register tools from Gemini `tools[].functionDeclarations` array.
+   */
+  registerFromFunctionDeclarations(tools) {
+    if (!Array.isArray(tools)) return;
+    for (const tool2 of tools) {
+      if (tool2 && Array.isArray(tool2.functionDeclarations)) {
+        for (const fn of tool2.functionDeclarations) {
+          if (fn && typeof fn.name === "string") {
+            this.register(fn.name);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Register tools from OpenAI format `tools[].function.name`.
+   */
+  registerFromOpenAITools(tools) {
+    if (!Array.isArray(tools)) return;
+    for (const tool2 of tools) {
+      if (tool2 && typeof tool2 === "object") {
+        const fn = tool2.function;
+        if (fn && typeof fn.name === "string") {
+          this.register(fn.name);
+        }
+      }
+    }
+  }
+  /**
+   * Scan contents/messages to register any previously used tool names.
+   */
+  registerFromContents(contents) {
+    if (!Array.isArray(contents)) return;
+    for (const content of contents) {
+      if (!content || typeof content !== "object") continue;
+      const parts = content.parts;
+      if (Array.isArray(parts)) {
+        for (const part of parts) {
+          if (!part || typeof part !== "object") continue;
+          const p = part;
+          if (p.functionCall && typeof p.functionCall.name === "string") {
+            this.register(p.functionCall.name);
+          }
+          if (p.functionResponse && typeof p.functionResponse.name === "string") {
+            this.register(p.functionResponse.name);
+          }
+        }
+      }
+    }
+  }
+};
+var sessionMappers = /* @__PURE__ */ new Map();
+var MAX_SESSION_AGE_MS = 24 * 60 * 60 * 1e3;
+function getToolMapper(sessionId) {
+  if (!sessionId) {
+    return new ToolMapper();
+  }
+  const now = Date.now();
+  const existing = sessionMappers.get(sessionId);
+  if (existing && now - existing.updatedAt < MAX_SESSION_AGE_MS) {
+    existing.updatedAt = now;
+    return existing.mapper;
+  }
+  if (sessionMappers.size > 1e3) {
+    for (const [key, value] of sessionMappers.entries()) {
+      if (now - value.updatedAt >= MAX_SESSION_AGE_MS) {
+        sessionMappers.delete(key);
+      }
+    }
+  }
+  const mapper = new ToolMapper();
+  sessionMappers.set(sessionId, { mapper, updatedAt: now });
+  return mapper;
+}
+function restoreToolNamesInResponse(body, toolMapper) {
+  if (!body || typeof body !== "object") return;
+  const b = body;
+  const target = b.response && typeof b.response === "object" ? b.response : b;
+  const candidates = target.candidates;
+  if (Array.isArray(candidates)) {
+    for (const cand of candidates) {
+      if (!cand || typeof cand !== "object") continue;
+      const content = cand.content;
+      if (!content || typeof content !== "object") continue;
+      const parts = content.parts;
+      if (Array.isArray(parts)) {
+        for (const part of parts) {
+          if (!part || typeof part !== "object") continue;
+          const p = part;
+          if (p.functionCall && typeof p.functionCall.name === "string") {
+            const fnCall = p.functionCall;
+            fnCall.name = toolMapper.fromGemini(fnCall.name);
+          }
+        }
+      }
+    }
+  }
+}
+
 // src/sdk/request/prepare.ts
 var STREAM_ACTION = "streamGenerateContent";
 function prepareAgyRequest(input, init, accessToken, projectId, thinkingConfigDefaults) {
@@ -17933,8 +18184,11 @@ function transformRequestBody(body, projectId, effectiveModel, requestedModel, t
         wrappedBody2.userAgent = wrappedBody2.userAgent || "antigravity";
       }
       const { userPromptId: userPromptId2, sessionId: sessionId2, requestId: requestId2 } = normalizeWrappedIdentifiers(wrappedBody2);
+      const toolMapper2 = getToolMapper(sessionId2);
       const requestPayloadInside = wrappedBody2.request;
       if (requestPayloadInside) {
+        toolMapper2.registerFromFunctionDeclarations(requestPayloadInside.tools);
+        toolMapper2.registerFromContents(requestPayloadInside.contents);
         normalizeThinking(
           requestPayloadInside,
           resolveDefaultThinkingConfig(thinkingConfigDefaults, requestedModel, effectiveModel),
@@ -17952,10 +18206,14 @@ function transformRequestBody(body, projectId, effectiveModel, requestedModel, t
         };
       }
       if (requestPayloadInside && Array.isArray(requestPayloadInside.tools)) {
-        normalizeToolSchemaTypes(requestPayloadInside.tools);
+        normalizeToolSchemaTypes(requestPayloadInside.tools, toolMapper2);
+      }
+      if (requestPayloadInside) {
+        normalizeToolConfig(requestPayloadInside, toolMapper2);
       }
       if (requestPayloadInside && Array.isArray(requestPayloadInside.contents)) {
         let contents2 = requestPayloadInside.contents;
+        normalizeToolNamesInContents(contents2, toolMapper2);
         injectMissingToolCallIds(contents2);
         fixOrphanedFunctionResponses(contents2);
         const tracker = getTurnStateTracker();
@@ -17975,10 +18233,16 @@ function transformRequestBody(body, projectId, effectiveModel, requestedModel, t
       return { body: JSON.stringify(wrappedBody2), userPromptId: userPromptId2, sessionId: sessionId2 };
     }
     const requestPayload = { ...parsedBody };
+    const { userPromptId, sessionId, requestId } = normalizeRequestPayloadIdentifiers(requestPayload);
+    const toolMapper = getToolMapper(sessionId);
+    toolMapper.registerFromOpenAITools(requestPayload.tools);
+    toolMapper.registerFromFunctionDeclarations(requestPayload.tools);
+    toolMapper.registerFromContents(requestPayload.contents);
     if (Array.isArray(requestPayload.tools)) {
-      normalizeToolSchemaTypes(requestPayload.tools);
+      normalizeToolSchemaTypes(requestPayload.tools, toolMapper);
     }
-    transformOpenAIToolCalls(requestPayload);
+    normalizeToolConfig(requestPayload, toolMapper);
+    transformOpenAIToolCalls(requestPayload, toolMapper);
     addThoughtSignaturesToFunctionCalls(requestPayload);
     normalizeThinking(
       requestPayload,
@@ -17987,9 +18251,9 @@ function transformRequestBody(body, projectId, effectiveModel, requestedModel, t
     );
     normalizeSystemInstruction(requestPayload);
     normalizeCachedContent(requestPayload);
-    const { userPromptId, sessionId, requestId } = normalizeRequestPayloadIdentifiers(requestPayload);
     let contents = requestPayload.contents;
     if (Array.isArray(contents)) {
+      normalizeToolNamesInContents(contents, toolMapper);
       injectMissingToolCallIds(contents);
       fixOrphanedFunctionResponses(contents);
       const tracker = getTurnStateTracker();
@@ -18103,7 +18367,7 @@ function mergeThinkingConfigs(...configs) {
 function isRecord2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function normalizeToolSchemaTypes(tools) {
+function normalizeToolSchemaTypes(tools, toolMapper) {
   if (!Array.isArray(tools)) return;
   const validSchemaKeys = /* @__PURE__ */ new Set([
     "type",
@@ -18154,7 +18418,7 @@ function normalizeToolSchemaTypes(tools) {
     if (tool2 && Array.isArray(tool2.functionDeclarations)) {
       for (const fn of tool2.functionDeclarations) {
         if (fn && typeof fn.name === "string") {
-          fn.name = fn.name.replace(/[^a-zA-Z0-9_]/g, "_");
+          fn.name = toolMapper ? toolMapper.toGemini(fn.name) : sanitizeToolName(fn.name);
         }
         if (fn) {
           if (!fn.parameters) {
@@ -18166,6 +18430,37 @@ function normalizeToolSchemaTypes(tools) {
     }
   }
 }
+function normalizeToolConfig(requestPayload, toolMapper) {
+  const toolConfig = requestPayload.toolConfig ?? requestPayload.tool_config;
+  if (!toolConfig || typeof toolConfig !== "object") return;
+  const fnCallingConfig = toolConfig.functionCallingConfig ?? toolConfig.function_calling_config;
+  if (!fnCallingConfig || typeof fnCallingConfig !== "object") return;
+  const allowedNames = fnCallingConfig.allowedFunctionNames ?? fnCallingConfig.allowed_function_names;
+  if (Array.isArray(allowedNames)) {
+    const mapped = allowedNames.map((name) => typeof name === "string" ? toolMapper.toGemini(name) : name);
+    if (fnCallingConfig.allowedFunctionNames) {
+      fnCallingConfig.allowedFunctionNames = mapped;
+    }
+    if (fnCallingConfig.allowed_function_names) {
+      fnCallingConfig.allowed_function_names = mapped;
+    }
+  }
+}
+function normalizeToolNamesInContents(contents, toolMapper) {
+  if (!Array.isArray(contents)) return;
+  for (const msg of contents) {
+    if (!msg || typeof msg !== "object" || !Array.isArray(msg.parts)) continue;
+    for (const part of msg.parts) {
+      if (!part || typeof part !== "object") continue;
+      if (part.functionCall && typeof part.functionCall.name === "string") {
+        part.functionCall.name = toolMapper.toGemini(part.functionCall.name);
+      }
+      if (part.functionResponse && typeof part.functionResponse.name === "string") {
+        part.functionResponse.name = toolMapper.toGemini(part.functionResponse.name);
+      }
+    }
+  }
+}
 function normalizeSystemInstruction(requestPayload) {
   if ("system_instruction" in requestPayload) {
     requestPayload.systemInstruction = requestPayload.system_instruction;
@@ -18249,7 +18544,7 @@ function applyLatestSignature(contents, latestSig) {
     if (content && typeof content === "object" && Array.isArray(content.parts)) {
       for (const part of content.parts) {
         if (part && typeof part === "object" && part.functionCall) {
-          allFunctionCalls.push(part);
+          allFunctionCalls.push(part.functionCall);
         }
       }
     }
@@ -18342,6 +18637,10 @@ async function transformAgyResponse(response, streaming, _ignoredDebugContext, r
     const previewPatched = parsed ? rewriteGeminiPreviewAccessError(enhanced?.body ?? parsed, response.status, requestedModel) : null;
     const effectiveBodyRaw = previewPatched ?? enhanced?.body ?? parsed ?? void 0;
     const effectiveBody = effectiveBodyRaw && typeof effectiveBodyRaw === "object" ? injectResponseIdFromTrace(effectiveBodyRaw) : effectiveBodyRaw;
+    if (effectiveBody) {
+      const toolMapper = getToolMapper(sessionId);
+      restoreToolNamesInResponse(effectiveBody, toolMapper);
+    }
     attachUsageHeaders(headers, effectiveBody);
     if (!parsed) {
       return new Response(text, init);
@@ -18396,6 +18695,8 @@ function transformStreamingPayloadStream(stream, sessionId, chatLogger) {
     },
     transformThinkingParts: (response) => {
       if (response && typeof response === "object") {
+        const toolMapper = getToolMapper(sessionId);
+        restoreToolNamesInResponse(response, toolMapper);
         return injectResponseIdFromTrace(response);
       }
       return response;
@@ -19105,7 +19406,7 @@ function resolveThinkingConfigDefaults(provider) {
   const providerOptions = provider && typeof provider === "object" ? provider.options ?? void 0 : void 0;
   const providerThinkingConfig = providerOptions?.thinkingConfig;
   const modelThinkingConfigByModel = {};
-  for (const [modelId, model] of Object.entries(provider.models ?? {})) {
+  for (const [modelId, model] of Object.entries(provider?.models ?? {})) {
     if (!model || typeof model !== "object") {
       continue;
     }