opencode-antigravity-auth-tweaked 1.9.4 → 1.9.6

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

@@ -1,10 +1,10 @@
-import { getKeepThinking } from "./config";
-import { createLogger } from "./logger";
-import { cacheSignature } from "./cache";
-import { EMPTY_SCHEMA_PLACEHOLDER_NAME, EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION, SKIP_THOUGHT_SIGNATURE, } from "../constants";
-import { processImageData } from "./image-saver";
+import { getKeepThinking } from "./config/index.js";
+import { createLogger } from "./logger.js";
+import { cacheSignature } from "./cache.js";
+import { EMPTY_SCHEMA_PLACEHOLDER_NAME, EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION, SKIP_THOUGHT_SIGNATURE, } from "../constants.js";
+import { processImageData } from "./image-saver.js";
 const log = createLogger("request-helpers");
-const ANTIGRAVITY_PREVIEW_LINK = "https://goo.gle/enable-preview-features"; // TODO: Update to Antigravity link if available
+const ANTIGRAVITY_PREVIEW_LINK = "https://goo.gle/enable-preview-features"; // Link for enabling preview features
 // ============================================================================
 // JSON SCHEMA CLEANING FOR ANTIGRAVITY API
 // Ported from CLIProxyAPI's CleanJSONSchemaForAntigravity (gemini_schema.go)
@@ -30,10 +30,13 @@ const UNSUPPORTED_KEYWORDS = [
  * Appends a hint to a schema's description field.
  */
 function appendDescriptionHint(schema, hint) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== "object" || !hint) {
         return schema;
     }
     const existing = typeof schema.description === "string" ? schema.description : "";
+    if (existing.includes(hint)) {
+        return schema;
+    }
     const newDescription = existing ? `${existing} (${hint})` : hint;
     return { ...schema, description: newDescription };
 }
@@ -242,10 +245,10 @@ function scoreSchemaOption(schema) {
     }
     // Any other non-null type
     if (type && type !== "null") {
-        return { score: 1, typeName: type };
+        return { score: 1, typeName: typeof type === "string" ? type : type[0] || "unknown" };
     }
     // Null or no type
-    return { score: 0, typeName: type || "null" };
+    return { score: 0, typeName: (typeof type === "string" ? type : type?.[0]) || "null" };
 }
 /**
  * Checks if an anyOf/oneOf array represents enum choices.
@@ -261,38 +264,48 @@ function tryMergeEnumFromUnion(options) {
         return null;
     }
     const enumValues = [];
+    let hasEnumPattern = false;
     for (const option of options) {
         if (!option || typeof option !== "object") {
-            return null;
+            continue;
+        }
+        // Handle nested anyOf/oneOf (recursive)
+        if (Array.isArray(option.anyOf)) {
+            const nested = tryMergeEnumFromUnion(option.anyOf);
+            if (nested) {
+                enumValues.push(...nested);
+                hasEnumPattern = true;
+            }
+            continue;
+        }
+        if (Array.isArray(option.oneOf)) {
+            const nested = tryMergeEnumFromUnion(option.oneOf);
+            if (nested) {
+                enumValues.push(...nested);
+                hasEnumPattern = true;
+            }
+            continue;
         }
         // Check for const value
         if (option.const !== undefined) {
             enumValues.push(String(option.const));
+            hasEnumPattern = true;
             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)
+        // Check for enum
         if (Array.isArray(option.enum) && option.enum.length > 0) {
             for (const val of option.enum) {
                 enumValues.push(String(val));
             }
+            hasEnumPattern = true;
             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;
+    // Only return if we found actual enum values and it looks like an enum pattern
+    if (enumValues.length > 0 && hasEnumPattern) {
+        return Array.from(new Set(enumValues));
+    }
+    return null;
 }
 /**
  * Phase 2b: Flattens anyOf/oneOf to the best option with type hints.
@@ -331,6 +344,16 @@ function flattenAnyOfOneOf(schema) {
                 if (parentDesc) {
                     result.description = parentDesc;
                 }
+                // If any option was null, add nullable hint
+                const hasNullOption = options.some(opt => opt && typeof opt === "object" && opt.type === "null");
+                if (hasNullOption) {
+                    result = appendDescriptionHint(result, "nullable");
+                }
+                // Add enum hint if we just created/merged an enum
+                if (mergedEnum.length > 1 && mergedEnum.length <= 10) {
+                    const vals = mergedEnum.join(", ");
+                    result = appendDescriptionHint(result, `Allowed: ${vals}`);
+                }
                 continue;
             }
             // Not an enum pattern - use standard flattening logic
@@ -364,6 +387,10 @@ function flattenAnyOfOneOf(schema) {
                 const uniqueTypes = Array.from(new Set(allTypes));
                 const hint = `Accepts: ${uniqueTypes.join(" | ")}`;
                 selected = appendDescriptionHint(selected, hint);
+                // If 'null' was one of the options, add 'nullable' hint explicitly
+                if (uniqueTypes.includes("null")) {
+                    selected = appendDescriptionHint(selected, "nullable");
+                }
             }
             // Replace result with selected schema, preserving other fields
             const { [unionKey]: _, description: __, ...rest } = result;
@@ -790,32 +817,34 @@ function isOurCachedSignature(part, sessionId, getCachedSignatureFn) {
     if (!sessionId || !getCachedSignatureFn) {
         return false;
     }
-    const text = getThinkingText(part);
-    if (!text) {
+    const textContent = getThinkingText(part);
+    if (!textContent) {
         return false;
     }
     const partSignature = getSignature(part);
     if (!partSignature) {
         return false;
     }
-    const cachedSignature = getCachedSignatureFn(sessionId, text);
+    const cachedSignature = getCachedSignatureFn(sessionId, textContent);
     return cachedSignature === partSignature;
 }
 /**
  * Gets the text content from a thinking part.
  */
 function getThinkingText(part) {
-    if (typeof part.text === "string")
-        return part.text;
-    if (typeof part.thinking === "string")
-        return part.thinking;
-    if (part.text && typeof part.text === "object") {
-        const maybeText = part.text.text;
+    const text = part.text;
+    const thinking = part.thinking;
+    if (typeof text === "string")
+        return text;
+    if (typeof thinking === "string")
+        return thinking;
+    if (text && typeof text === "object") {
+        const maybeText = text.text;
         if (typeof maybeText === "string")
             return maybeText;
     }
-    if (part.thinking && typeof part.thinking === "object") {
-        const maybeText = part.thinking.text ?? part.thinking.thinking;
+    if (thinking && typeof thinking === "object") {
+        const maybeText = thinking.text ?? thinking.thinking;
         if (typeof maybeText === "string")
             return maybeText;
     }
@@ -924,12 +953,13 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
             filtered.push(item);
             continue;
         }
-        if (isToolBlock(item)) {
+        const itemRecord = item;
+        if (isToolBlock(itemRecord)) {
             if (!isClaudeModel) {
                 filtered.push(item);
                 continue;
             }
-            const sanitizedToolBlock = { ...item };
+            const sanitizedToolBlock = { ...itemRecord };
             delete sanitizedToolBlock.signature;
             delete sanitizedToolBlock.thoughtSignature;
             delete sanitizedToolBlock.thought_signature;
@@ -937,16 +967,16 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
             filtered.push(sanitizedToolBlock);
             continue;
         }
-        const isThinking = isThinkingPart(item);
-        const hasSignature = hasSignatureField(item);
+        const isThinking = isThinkingPart(itemRecord);
+        const hasSignature = hasSignatureField(itemRecord);
         if (!isThinking && !hasSignature) {
             filtered.push(item);
             continue;
         }
         if (isClaudeModel && (isThinking || hasSignature)) {
-            const thinkingText = getThinkingText(item) || "";
+            const thinkingText = getThinkingText(itemRecord) || "";
             const sentinelPart = {
-                type: item.type === "redacted_thinking" ? "redacted_thinking" : "thinking",
+                type: itemRecord.type === "redacted_thinking" ? "redacted_thinking" : "thinking",
                 thinking: thinkingText,
                 signature: SKIP_THOUGHT_SIGNATURE,
             };
@@ -960,38 +990,38 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
         // its own signatures which are long but invalid for Antigravity.
         if (isLastAssistantMessage && (isThinking || hasSignature)) {
             // First check if it's our cached signature
-            if (isOurCachedSignature(item, sessionId, getCachedSignatureFn)) {
-                const sanitized = sanitizeThinkingPart(item);
+            if (isOurCachedSignature(itemRecord, sessionId, getCachedSignatureFn)) {
+                const sanitized = sanitizeThinkingPart(itemRecord);
                 if (sanitized)
                     filtered.push(sanitized);
                 continue;
             }
             // Not our signature (or no signature) - inject sentinel
-            const thinkingText = getThinkingText(item) || "";
-            const existingSignature = item.signature || item.thoughtSignature;
+            const thinkingText = getThinkingText(itemRecord) || "";
+            const existingSignature = itemRecord.signature || itemRecord.thoughtSignature;
             const signatureInfo = existingSignature ? `foreign signature (${String(existingSignature).length} chars)` : "no signature";
             log.debug(`Injecting sentinel for last-message thinking block with ${signatureInfo}`);
             const sentinelPart = {
-                type: item.type || "thinking",
+                type: itemRecord.type || "thinking",
                 thinking: thinkingText,
                 signature: SKIP_THOUGHT_SIGNATURE,
             };
             filtered.push(sentinelPart);
             continue;
         }
-        if (isOurCachedSignature(item, sessionId, getCachedSignatureFn)) {
-            const sanitized = sanitizeThinkingPart(item);
+        if (isOurCachedSignature(itemRecord, sessionId, getCachedSignatureFn)) {
+            const sanitized = sanitizeThinkingPart(itemRecord);
             if (sanitized)
                 filtered.push(sanitized);
             continue;
         }
         if (sessionId && getCachedSignatureFn) {
-            const text = getThinkingText(item);
-            if (text) {
-                const cachedSignature = getCachedSignatureFn(sessionId, text);
+            const textContent = getThinkingText(itemRecord);
+            if (textContent) {
+                const cachedSignature = getCachedSignatureFn(sessionId, textContent);
                 if (cachedSignature && cachedSignature.length >= 50) {
-                    const restoredPart = { ...item };
-                    if (item.thought === true) {
+                    const restoredPart = { ...itemRecord };
+                    if (itemRecord.thought === true) {
                         restoredPart.thoughtSignature = cachedSignature;
                     }
                     else {
@@ -1029,11 +1059,12 @@ export function filterUnsignedThinkingBlocks(contents, sessionId, getCachedSigna
                 : filteredParts;
             return { ...content, parts: trimmedParts };
         }
-        if (Array.isArray(content.content)) {
+        const contentAsAny = content;
+        if (Array.isArray(contentAsAny.content)) {
             const isAssistantRole = content.role === "assistant";
             const isLastAssistantContent = idx === lastAssistantIdx ||
                 (isAssistantRole && idx === findLastAssistantIndex(contents, "assistant"));
-            const filteredContent = filterContentArray(content.content, sessionId, getCachedSignatureFn, isClaudeModel, isLastAssistantContent);
+            const filteredContent = filterContentArray(contentAsAny.content, sessionId, getCachedSignatureFn, isClaudeModel, isLastAssistantContent);
             const trimmedContent = isAssistantRole && !isClaudeModel
                 ? removeTrailingThinkingBlocks(filteredContent, sessionId, getCachedSignatureFn)
                 : filteredContent;
@@ -1109,9 +1140,9 @@ function transformGeminiCandidate(candidate) {
         }
         // Handle Gemini-style: thought: true
         if (part.thought === true) {
-            const thinkingText = part.text || "";
+            const thinkingText = getThinkingText(part);
             thinkingTexts.push(thinkingText);
-            const transformed = { ...part, type: "reasoning" };
+            const transformed = { ...part, type: "reasoning", text: thinkingText };
             if (part.cache_control)
                 transformed.cache_control = part.cache_control;
             // Convert signature to providerMetadata format for OpenCode
@@ -1127,7 +1158,7 @@ function transformGeminiCandidate(candidate) {
         }
         // Handle Anthropic-style in candidates: type: "thinking"
         if (part.type === "thinking") {
-            const thinkingText = part.thinking || part.text || "";
+            const thinkingText = getThinkingText(part);
             thinkingTexts.push(thinkingText);
             const transformed = {
                 ...part,
@@ -1199,7 +1230,7 @@ export function transformThinkingParts(response) {
         const transformedContent = [];
         for (const block of resp.content) {
             if (block && typeof block === "object" && block.type === "thinking") {
-                const thinkingText = block.thinking || block.text || "";
+                const thinkingText = getThinkingText(block);
                 reasoningTexts.push(thinkingText);
                 const transformed = {
                     ...block,
@@ -1327,7 +1358,7 @@ export function rewriteAntigravityPreviewAccessError(body, status, requestedMode
     if (!needsPreviewAccessOverride(status, body, requestedModel)) {
         return null;
     }
-    const error = body.error ?? {};
+    const error = (body.error ?? {});
     const trimmedMessage = typeof error.message === "string" ? error.message.trim() : "";
     const messagePrefix = trimmedMessage.length > 0
         ? trimmedMessage
@@ -1349,7 +1380,7 @@ function needsPreviewAccessOverride(status, body, requestedModel) {
         return true;
     }
     const errorMessage = typeof body.error?.message === "string" ? body.error.message : "";
-    return isAntigravityModel(errorMessage);
+    return isAntigravityModel(errorMessage || undefined);
 }
 function isAntigravityModel(target) {
     if (!target) {
@@ -1575,13 +1606,18 @@ export function recursivelyParseJsonStrings(obj, skipParseKeys = SKIP_PARSE_KEYS
         return obj;
     }
     const stripped = obj.trim();
-    // Check if string contains control character escape sequences
-    // that need unescaping (\\n, \\t but NOT \\" or \\\\)
-    const hasControlCharEscapes = obj.includes("\\n") || obj.includes("\\t");
+    // Check if string contains control character escape sequences that need unescaping
+    // (e.g. \n, \t, \r, \b, \f, \uXXXX)
+    const hasControlCharEscapes = /\\[nrtbf]/.test(obj) || /\\u[0-9a-fA-F]{4}/.test(obj);
     const hasIntentionalEscapes = obj.includes('\\"') || obj.includes("\\\\");
     if (hasControlCharEscapes && !hasIntentionalEscapes) {
-        const unescaped = safeJsonParse(`"${obj}"`, null);
-        if (unescaped !== null) {
+        // Robust unescaping by wrapping in a JSON object property.
+        // We must escape literal double quotes and real control characters first.
+        const escaped = obj
+            .replace(/"/g, '\\"')
+            .replace(/[\u0000-\u001f]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
+        const unescaped = safeJsonParse(`{"v":"${escaped}"}`, null)?.v;
+        if (unescaped !== undefined && unescaped !== null) {
             return unescaped;
         }
     }
@@ -1658,7 +1694,7 @@ export function fixToolResponseGrouping(contents) {
         const role = content.role;
         const parts = content.parts || [];
         // Check if this is a tool response message
-        const responseParts = parts.filter((p) => p?.functionResponse);
+        const responseParts = parts.filter((p) => !!p?.functionResponse);
         if (responseParts.length > 0) {
             // Collect responses by ID (skip duplicates)
             for (const resp of responseParts) {
@@ -1686,7 +1722,7 @@ export function fixToolResponseGrouping(contents) {
         }
         if (role === "model") {
             // Check for function calls in this model message
-            const funcCalls = parts.filter((p) => p?.functionCall);
+            const funcCalls = parts.filter((p) => !!p?.functionCall);
             newContents.push(content);
             if (funcCalls.length > 0) {
                 const callIds = funcCalls
@@ -1748,9 +1784,11 @@ export function fixToolResponseGrouping(contents) {
                     const orphanResp = collectedResponses.get(matchedId);
                     collectedResponses.delete(matchedId);
                     // Fix the ID and name to match expected
-                    orphanResp.functionResponse.id = expectedId;
-                    if (orphanResp.functionResponse.name === "unknown_function" && expectedName) {
-                        orphanResp.functionResponse.name = expectedName;
+                    if (orphanResp.functionResponse) {
+                        orphanResp.functionResponse.id = expectedId;
+                        if (orphanResp.functionResponse.name === "unknown_function" && expectedName) {
+                            orphanResp.functionResponse.name = expectedName;
+                        }
                     }
                     log.debug("Auto-repaired tool ID mismatch", {
                         mappedFrom: matchedId,
@@ -2059,7 +2097,7 @@ export function injectParameterSignatures(tools, promptTemplate = "\n\n⚠️ ST
             if (decl.description?.includes("STRICT PARAMETERS:")) {
                 return decl;
             }
-            const schema = decl.parameters || decl.parametersJsonSchema;
+            const schema = (decl.parameters || decl.parametersJsonSchema);
             if (!schema)
                 return decl;
             const required = schema.required ?? [];
@@ -2262,7 +2300,7 @@ export function createSyntheticErrorResponse(errorMessage, requestedModel = "unk
     // Build Claude SSE events that represent a complete message with error text
     const events = [];
     // 1. message_start event
-    events.push(`event: message_start
+    events.push(`event: message_start
 data: ${JSON.stringify({
         type: "message_start",
         message: {
@@ -2275,48 +2313,48 @@ data: ${JSON.stringify({
             stop_sequence: null,
             usage: { input_tokens: 0, output_tokens: 0 },
         },
-    })}
-
+    })}
+
 `);
     // 2. content_block_start event
-    events.push(`event: content_block_start
+    events.push(`event: content_block_start
 data: ${JSON.stringify({
         type: "content_block_start",
         index: 0,
         content_block: { type: "text", text: "" },
-    })}
-
+    })}
+
 `);
     // 3. content_block_delta event with the error message
-    events.push(`event: content_block_delta
+    events.push(`event: content_block_delta
 data: ${JSON.stringify({
         type: "content_block_delta",
         index: 0,
         delta: { type: "text_delta", text: errorMessage },
-    })}
-
+    })}
+
 `);
     // 4. content_block_stop event
-    events.push(`event: content_block_stop
+    events.push(`event: content_block_stop
 data: ${JSON.stringify({
         type: "content_block_stop",
         index: 0,
-    })}
-
+    })}
+
 `);
     // 5. message_delta event (end_turn)
-    events.push(`event: message_delta
+    events.push(`event: message_delta
 data: ${JSON.stringify({
         type: "message_delta",
         delta: { stop_reason: "end_turn", stop_sequence: null },
         usage: { output_tokens: Math.ceil(errorMessage.length / 4) },
-    })}
-
+    })}
+
 `);
     // 6. message_stop event
-    events.push(`event: message_stop
-data: ${JSON.stringify({ type: "message_stop" })}
-
+    events.push(`event: message_stop
+data: ${JSON.stringify({ type: "message_stop" })}
+
 `);
     const body = events.join("");
     return new Response(body, {