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

package/dist/index.js

@@ -17756,7 +17756,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 +17782,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 +17846,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 +18093,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 +18115,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 +18142,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 +18160,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 +18276,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 +18327,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 +18339,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;
@@ -18342,6 +18546,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 +18604,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;