opencode-antigravity-auth 1.2.6 → 1.2.7-beta.1

package/dist/src/plugin/request-helpers.js

@@ -1,5 +1,6 @@
 import { KEEP_THINKING_BLOCKS } from "../constants.js";
 import { createLogger } from "./logger";
+import { EMPTY_SCHEMA_PLACEHOLDER_NAME, EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION, } from "../constants";
 const log = createLogger("request-helpers");
 const ANTIGRAVITY_PREVIEW_LINK = "https://goo.gle/enable-preview-features"; // TODO: Update to Antigravity link if available
 // ============================================================================
@@ -244,10 +245,61 @@ function scoreSchemaOption(schema) {
     // Null or no type
     return { score: 0, typeName: type || "null" };
 }
+/**
+ * Checks if an anyOf/oneOf array represents enum choices.
+ * Returns the merged enum values if so, otherwise null.
+ *
+ * Handles patterns like:
+ * - anyOf: [{ const: "a" }, { const: "b" }]
+ * - anyOf: [{ enum: ["a"] }, { enum: ["b"] }]
+ * - anyOf: [{ type: "string", const: "a" }, { type: "string", const: "b" }]
+ */
+function tryMergeEnumFromUnion(options) {
+    if (!Array.isArray(options) || options.length === 0) {
+        return null;
+    }
+    const enumValues = [];
+    for (const option of options) {
+        if (!option || typeof option !== "object") {
+            return null;
+        }
+        // Check for const value
+        if (option.const !== undefined) {
+            enumValues.push(String(option.const));
+            continue;
+        }
+        // Check for single-value enum
+        if (Array.isArray(option.enum) && option.enum.length === 1) {
+            enumValues.push(String(option.enum[0]));
+            continue;
+        }
+        // Check for multi-value enum (merge all values)
+        if (Array.isArray(option.enum) && option.enum.length > 0) {
+            for (const val of option.enum) {
+                enumValues.push(String(val));
+            }
+            continue;
+        }
+        // If option has complex structure (properties, items, etc.), it's not a simple enum
+        if (option.properties || option.items || option.anyOf || option.oneOf || option.allOf) {
+            return null;
+        }
+        // If option has only type (no const/enum), it's not an enum pattern
+        if (option.type && !option.const && !option.enum) {
+            return null;
+        }
+    }
+    // Only return if we found actual enum values
+    return enumValues.length > 0 ? enumValues : null;
+}
 /**
  * Phase 2b: Flattens anyOf/oneOf to the best option with type hints.
  * { anyOf: [{ type: "string" }, { type: "number" }] }
  * → { type: "string", description: "(Accepts: string | number)" }
+ *
+ * Special handling for enum patterns:
+ * { anyOf: [{ const: "a" }, { const: "b" }] }
+ * → { type: "string", enum: ["a", "b"] }
  */
 function flattenAnyOfOneOf(schema) {
     if (!schema || typeof schema !== "object") {
@@ -262,6 +314,24 @@ function flattenAnyOfOneOf(schema) {
         if (Array.isArray(result[unionKey]) && result[unionKey].length > 0) {
             const options = result[unionKey];
             const parentDesc = typeof result.description === "string" ? result.description : "";
+            // First, check if this is an enum pattern (anyOf with const/enum values)
+            // This is crucial for tools like WebFetch where format: anyOf[{const:"text"},{const:"markdown"},{const:"html"}]
+            const mergedEnum = tryMergeEnumFromUnion(options);
+            if (mergedEnum !== null) {
+                // This is an enum pattern - merge all values into a single enum
+                const { [unionKey]: _, ...rest } = result;
+                result = {
+                    ...rest,
+                    type: "string",
+                    enum: mergedEnum,
+                };
+                // Preserve parent description
+                if (parentDesc) {
+                    result.description = parentDesc;
+                }
+                continue;
+            }
+            // Not an enum pattern - use standard flattening logic
             // Score each option and find the best
             let bestIdx = 0;
             let bestScore = -1;
@@ -376,23 +446,31 @@ function flattenTypeArrays(schema, nullableFields, currentPath) {
 }
 /**
  * Phase 3: Removes unsupported keywords after hints have been extracted.
+ * @param insideProperties - When true, keys are property NAMES (preserve); when false, keys are JSON Schema keywords (filter).
  */
-function removeUnsupportedKeywords(schema) {
+function removeUnsupportedKeywords(schema, insideProperties = false) {
     if (!schema || typeof schema !== "object") {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => removeUnsupportedKeywords(item));
+        return schema.map(item => removeUnsupportedKeywords(item, false));
     }
     const result = {};
     for (const [key, value] of Object.entries(schema)) {
-        // Skip unsupported keywords
-        if (UNSUPPORTED_KEYWORDS.includes(key)) {
+        if (!insideProperties && UNSUPPORTED_KEYWORDS.includes(key)) {
             continue;
         }
-        // Recursively process nested objects
         if (typeof value === "object" && value !== null) {
-            result[key] = removeUnsupportedKeywords(value);
+            if (key === "properties") {
+                const propertiesResult = {};
+                for (const [propName, propSchema] of Object.entries(value)) {
+                    propertiesResult[propName] = removeUnsupportedKeywords(propSchema, false);
+                }
+                result[key] = propertiesResult;
+            }
+            else {
+                result[key] = removeUnsupportedKeywords(value, false);
+            }
         }
         else {
             result[key] = value;
@@ -449,12 +527,12 @@ function addEmptySchemaPlaceholder(schema) {
             Object.keys(result.properties).length > 0;
         if (!hasProperties) {
             result.properties = {
-                reason: {
-                    type: "string",
-                    description: "Brief explanation of why you are calling this tool",
+                [EMPTY_SCHEMA_PLACEHOLDER_NAME]: {
+                    type: "boolean",
+                    description: EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION,
                 },
             };
-            result.required = ["reason"];
+            result.required = [EMPTY_SCHEMA_PLACEHOLDER_NAME];
         }
     }
     // Recursively process nested objects
@@ -750,7 +828,16 @@ function sanitizeThinkingPart(part) {
     // Fallback: strip cache_control recursively.
     return stripCacheControlRecursively(part);
 }
-function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isClaudeModel) {
+function findLastAssistantIndex(contents, roleValue) {
+    for (let i = contents.length - 1; i >= 0; i--) {
+        const content = contents[i];
+        if (content && typeof content === "object" && content.role === roleValue) {
+            return i;
+        }
+    }
+    return -1;
+}
+function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isClaudeModel, isLastAssistantMessage) {
     // For Claude models, strip thinking blocks by default for reliability
     // User can opt-in to keep thinking via OPENCODE_ANTIGRAVITY_KEEP_THINKING=1
     if (isClaudeModel && !KEEP_THINKING_BLOCKS) {
@@ -772,6 +859,13 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
             filtered.push(item);
             continue;
         }
+        // CRITICAL: For the LAST assistant message, thinking blocks MUST remain byte-for-byte
+        // identical to what the API returned. Anthropic rejects any modification.
+        // Pass through unchanged - do NOT sanitize or reconstruct.
+        if (isLastAssistantMessage && (isThinking || hasSignature)) {
+            filtered.push(item);
+            continue;
+        }
         if (isOurCachedSignature(item, sessionId, getCachedSignatureFn)) {
             filtered.push(sanitizeThinkingPart(item));
             continue;
@@ -805,12 +899,14 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
  * @param getCachedSignatureFn - Optional function to retrieve cached signatures
  */
 export function filterUnsignedThinkingBlocks(contents, sessionId, getCachedSignatureFn, isClaudeModel) {
-    return contents.map((content) => {
+    const lastAssistantIdx = findLastAssistantIndex(contents, "model");
+    return contents.map((content, idx) => {
         if (!content || typeof content !== "object") {
             return content;
         }
+        const isLastAssistant = idx === lastAssistantIdx;
         if (Array.isArray(content.parts)) {
-            const filteredParts = filterContentArray(content.parts, sessionId, getCachedSignatureFn, isClaudeModel);
+            const filteredParts = filterContentArray(content.parts, sessionId, getCachedSignatureFn, isClaudeModel, isLastAssistant);
             const trimmedParts = content.role === "model" && !isClaudeModel
                 ? removeTrailingThinkingBlocks(filteredParts, sessionId, getCachedSignatureFn)
                 : filteredParts;
@@ -818,7 +914,9 @@ export function filterUnsignedThinkingBlocks(contents, sessionId, getCachedSigna
         }
         if (Array.isArray(content.content)) {
             const isAssistantRole = content.role === "assistant";
-            const filteredContent = filterContentArray(content.content, sessionId, getCachedSignatureFn, isClaudeModel);
+            const isLastAssistantContent = idx === lastAssistantIdx ||
+                (isAssistantRole && idx === findLastAssistantIndex(contents, "assistant"));
+            const filteredContent = filterContentArray(content.content, sessionId, getCachedSignatureFn, isClaudeModel, isLastAssistantContent);
             const trimmedContent = isAssistantRole && !isClaudeModel
                 ? removeTrailingThinkingBlocks(filteredContent, sessionId, getCachedSignatureFn)
                 : filteredContent;
@@ -831,13 +929,15 @@ export function filterUnsignedThinkingBlocks(contents, sessionId, getCachedSigna
  * Filters thinking blocks from Anthropic-style messages[] payloads using cached signatures.
  */
 export function filterMessagesThinkingBlocks(messages, sessionId, getCachedSignatureFn, isClaudeModel) {
-    return messages.map((message) => {
+    const lastAssistantIdx = findLastAssistantIndex(messages, "assistant");
+    return messages.map((message, idx) => {
         if (!message || typeof message !== "object") {
             return message;
         }
         if (Array.isArray(message.content)) {
             const isAssistantRole = message.role === "assistant";
-            const filteredContent = filterContentArray(message.content, sessionId, getCachedSignatureFn, isClaudeModel);
+            const isLastAssistant = isAssistantRole && idx === lastAssistantIdx;
+            const filteredContent = filterContentArray(message.content, sessionId, getCachedSignatureFn, isClaudeModel, isLastAssistant);
             const trimmedContent = isAssistantRole && !isClaudeModel
                 ? removeTrailingThinkingBlocks(filteredContent, sessionId, getCachedSignatureFn)
                 : filteredContent;
@@ -893,18 +993,24 @@ function transformGeminiCandidate(candidate) {
         // Handle Gemini-style: thought: true
         if (part.thought === true) {
             thinkingTexts.push(part.text || "");
-            return { ...part, type: "reasoning" };
+            const transformed = { ...part, type: "reasoning" };
+            if (part.cache_control)
+                transformed.cache_control = part.cache_control;
+            return transformed;
         }
         // Handle Anthropic-style in candidates: type: "thinking"
         if (part.type === "thinking") {
             const thinkingText = part.thinking || part.text || "";
             thinkingTexts.push(thinkingText);
-            return {
+            const transformed = {
                 ...part,
                 type: "reasoning",
                 text: thinkingText,
                 thought: true,
             };
+            if (part.cache_control)
+                transformed.cache_control = part.cache_control;
+            return transformed;
         }
         // Handle functionCall: parse JSON strings in args
         // (Ported from LLM-API-Key-Proxy's _extract_tool_call)
@@ -1033,6 +1139,7 @@ export function extractUsageMetadata(body) {
         promptTokenCount: toNumber(asRecord.promptTokenCount),
         candidatesTokenCount: toNumber(asRecord.candidatesTokenCount),
         cachedContentTokenCount: toNumber(asRecord.cachedContentTokenCount),
+        thoughtsTokenCount: toNumber(asRecord.thoughtsTokenCount),
     };
 }
 /**
@@ -1773,6 +1880,10 @@ export function injectParameterSignatures(tools, promptTemplate = "\n\n⚠️ ST
         if (!Array.isArray(declarations))
             return tool;
         const newDeclarations = declarations.map((decl) => {
+            // Skip if signature already injected (avoids duplicate injection)
+            if (decl.description?.includes("STRICT PARAMETERS:")) {
+                return decl;
+            }
             const schema = decl.parameters || decl.parametersJsonSchema;
             if (!schema)
                 return decl;
@@ -1804,9 +1915,16 @@ export function injectParameterSignatures(tools, promptTemplate = "\n\n⚠️ ST
 export function injectToolHardeningInstruction(payload, instructionText) {
     if (!instructionText)
         return;
+    // Skip if instruction already present (avoids duplicate injection)
+    const existing = payload.systemInstruction;
+    if (existing && typeof existing === "object" && "parts" in existing) {
+        const parts = existing.parts;
+        if (Array.isArray(parts) && parts.some(p => p.text?.includes("CRITICAL TOOL USAGE INSTRUCTIONS"))) {
+            return;
+        }
+    }
     const instructionPart = { text: instructionText };
     if (payload.systemInstruction) {
-        const existing = payload.systemInstruction;
         if (existing && typeof existing === "object" && "parts" in existing) {
             const parts = existing.parts;
             if (Array.isArray(parts)) {
@@ -1833,4 +1951,117 @@ export function injectToolHardeningInstruction(payload, instructionText) {
         };
     }
 }
+// ============================================================================
+// TOOL PROCESSING FOR WRAPPED REQUESTS
+// Shared logic for assigning tool IDs and fixing tool pairing
+// ============================================================================
+/**
+ * Assigns IDs to functionCall parts and returns the pending call IDs by name.
+ * This is the first pass of tool ID assignment.
+ *
+ * @param contents - Gemini-style contents array
+ * @returns Object with modified contents and pending call IDs map
+ */
+export function assignToolIdsToContents(contents) {
+    if (!Array.isArray(contents)) {
+        return { contents, pendingCallIdsByName: new Map(), toolCallCounter: 0 };
+    }
+    let toolCallCounter = 0;
+    const pendingCallIdsByName = new Map();
+    const newContents = contents.map((content) => {
+        if (!content || !Array.isArray(content.parts)) {
+            return content;
+        }
+        const newParts = content.parts.map((part) => {
+            if (part && typeof part === "object" && part.functionCall) {
+                const call = { ...part.functionCall };
+                if (!call.id) {
+                    call.id = `tool-call-${++toolCallCounter}`;
+                }
+                const nameKey = typeof call.name === "string" ? call.name : `tool-${toolCallCounter}`;
+                const queue = pendingCallIdsByName.get(nameKey) || [];
+                queue.push(call.id);
+                pendingCallIdsByName.set(nameKey, queue);
+                return { ...part, functionCall: call };
+            }
+            return part;
+        });
+        return { ...content, parts: newParts };
+    });
+    return { contents: newContents, pendingCallIdsByName, toolCallCounter };
+}
+/**
+ * Matches functionResponse IDs to their corresponding functionCall IDs.
+ * This is the second pass of tool ID assignment.
+ *
+ * @param contents - Gemini-style contents array
+ * @param pendingCallIdsByName - Map of function names to pending call IDs
+ * @returns Modified contents with matched response IDs
+ */
+export function matchResponseIdsToContents(contents, pendingCallIdsByName) {
+    if (!Array.isArray(contents)) {
+        return contents;
+    }
+    return contents.map((content) => {
+        if (!content || !Array.isArray(content.parts)) {
+            return content;
+        }
+        const newParts = content.parts.map((part) => {
+            if (part && typeof part === "object" && part.functionResponse) {
+                const resp = { ...part.functionResponse };
+                if (!resp.id && typeof resp.name === "string") {
+                    const queue = pendingCallIdsByName.get(resp.name);
+                    if (queue && queue.length > 0) {
+                        resp.id = queue.shift();
+                        pendingCallIdsByName.set(resp.name, queue);
+                    }
+                }
+                return { ...part, functionResponse: resp };
+            }
+            return part;
+        });
+        return { ...content, parts: newParts };
+    });
+}
+/**
+ * Applies all tool fixes to a request payload for Claude models.
+ * This includes:
+ * 1. Tool ID assignment for functionCalls
+ * 2. Response ID matching for functionResponses
+ * 3. Orphan recovery via fixToolResponseGrouping
+ * 4. Claude format pairing fix via validateAndFixClaudeToolPairing
+ *
+ * @param payload - Request payload object
+ * @param isClaude - Whether this is a Claude model request
+ * @returns Object with fix applied status
+ */
+export function applyToolPairingFixes(payload, isClaude) {
+    let contentsFixed = false;
+    let messagesFixed = false;
+    if (!isClaude) {
+        return { contentsFixed, messagesFixed };
+    }
+    // Fix Gemini format (contents[])
+    if (Array.isArray(payload.contents)) {
+        // First pass: assign IDs to functionCalls
+        const { contents: contentsWithIds, pendingCallIdsByName } = assignToolIdsToContents(payload.contents);
+        // Second pass: match functionResponse IDs
+        const contentsWithMatchedIds = matchResponseIdsToContents(contentsWithIds, pendingCallIdsByName);
+        // Third pass: fix orphan recovery
+        payload.contents = fixToolResponseGrouping(contentsWithMatchedIds);
+        contentsFixed = true;
+        log.debug("Applied tool pairing fixes to contents[]", {
+            originalLength: payload.contents.length,
+        });
+    }
+    // Fix Claude format (messages[])
+    if (Array.isArray(payload.messages)) {
+        payload.messages = validateAndFixClaudeToolPairing(payload.messages);
+        messagesFixed = true;
+        log.debug("Applied tool pairing fixes to messages[]", {
+            originalLength: payload.messages.length,
+        });
+    }
+    return { contentsFixed, messagesFixed };
+}
 //# sourceMappingURL=request-helpers.js.map