@cortexkit/opencode-antigravity-auth 1.1.0 → 2.0.0

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

@@ -1,10 +1,9 @@
-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";
-const log = createLogger("request-helpers");
-const ANTIGRAVITY_PREVIEW_LINK = "https://goo.gle/enable-preview-features"; // TODO: Update to Antigravity link if available
+import { EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION, EMPTY_SCHEMA_PLACEHOLDER_NAME, } from '../constants';
+import { getKeepThinking } from './config';
+import { processImageData } from './image-saver';
+import { createLogger } from './logger';
+const log = createLogger('request-helpers');
+const ANTIGRAVITY_PREVIEW_LINK = 'https://goo.gle/enable-preview-features'; // TODO: Update to Antigravity link if available
 // ============================================================================
 // JSON SCHEMA CLEANING FOR ANTIGRAVITY API
 // Ported from CLIProxyAPI's CleanJSONSchemaForAntigravity (gemini_schema.go)
@@ -14,26 +13,41 @@ const ANTIGRAVITY_PREVIEW_LINK = "https://goo.gle/enable-preview-features"; // T
  * Claude/Gemini reject these in VALIDATED mode.
  */
 const UNSUPPORTED_CONSTRAINTS = [
-    "minLength", "maxLength", "exclusiveMinimum", "exclusiveMaximum",
-    "pattern", "minItems", "maxItems", "format",
-    "default", "examples",
+    'minLength',
+    'maxLength',
+    'exclusiveMinimum',
+    'exclusiveMaximum',
+    'pattern',
+    'minItems',
+    'maxItems',
+    'format',
+    'default',
+    'examples',
 ];
 /**
  * Keywords that should be removed after hint extraction.
  */
 const UNSUPPORTED_KEYWORDS = [
     ...UNSUPPORTED_CONSTRAINTS,
-    "$schema", "$defs", "definitions", "const", "$ref", "additionalProperties",
-    "propertyNames", "title", "$id", "$comment",
+    '$schema',
+    '$defs',
+    'definitions',
+    'const',
+    '$ref',
+    'additionalProperties',
+    'propertyNames',
+    'title',
+    '$id',
+    '$comment',
 ];
 /**
  * Appends a hint to a schema's description field.
  */
 function appendDescriptionHint(schema, hint) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
-    const existing = typeof schema.description === "string" ? schema.description : "";
+    const existing = typeof schema.description === 'string' ? schema.description : '';
     const newDescription = existing ? `${existing} (${hint})` : hint;
     return { ...schema, description: newDescription };
 }
@@ -42,20 +56,20 @@ function appendDescriptionHint(schema, hint) {
  * $ref: "#/$defs/Foo" → { type: "object", description: "See: Foo" }
  */
 function convertRefsToHints(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => convertRefsToHints(item));
+        return schema.map((item) => convertRefsToHints(item));
     }
     // If this object has $ref, replace it with a hint
-    if (typeof schema.$ref === "string") {
+    if (typeof schema.$ref === 'string') {
         const refVal = schema.$ref;
-        const defName = refVal.includes("/") ? refVal.split("/").pop() : refVal;
+        const defName = refVal.includes('/') ? refVal.split('/').pop() : refVal;
         const hint = `See: ${defName}`;
-        const existingDesc = typeof schema.description === "string" ? schema.description : "";
+        const existingDesc = typeof schema.description === 'string' ? schema.description : '';
         const newDescription = existingDesc ? `${existingDesc} (${hint})` : hint;
-        return { type: "object", description: newDescription };
+        return { type: 'object', description: newDescription };
     }
     // Recursively process all properties
     const result = {};
@@ -69,15 +83,15 @@ function convertRefsToHints(schema) {
  * { const: "foo" } → { enum: ["foo"] }
  */
 function convertConstToEnum(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => convertConstToEnum(item));
+        return schema.map((item) => convertConstToEnum(item));
     }
     const result = {};
     for (const [key, value] of Object.entries(schema)) {
-        if (key === "const" && !schema.enum) {
+        if (key === 'const' && !schema.enum) {
             result.enum = [value];
         }
         else {
@@ -91,21 +105,23 @@ function convertConstToEnum(schema) {
  * { enum: ["a", "b", "c"] } → adds "(Allowed: a, b, c)" to description
  */
 function addEnumHints(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => addEnumHints(item));
+        return schema.map((item) => addEnumHints(item));
     }
     let result = { ...schema };
     // Add enum hint if enum has 2-10 items
-    if (Array.isArray(result.enum) && result.enum.length > 1 && result.enum.length <= 10) {
-        const vals = result.enum.map((v) => String(v)).join(", ");
+    if (Array.isArray(result.enum) &&
+        result.enum.length > 1 &&
+        result.enum.length <= 10) {
+        const vals = result.enum.map((v) => String(v)).join(', ');
         result = appendDescriptionHint(result, `Allowed: ${vals}`);
     }
     // Recursively process nested objects
     for (const [key, value] of Object.entries(result)) {
-        if (key !== "enum" && typeof value === "object" && value !== null) {
+        if (key !== 'enum' && typeof value === 'object' && value !== null) {
             result[key] = addEnumHints(value);
         }
     }
@@ -116,19 +132,21 @@ function addEnumHints(schema) {
  * { additionalProperties: false } → adds "(No extra properties allowed)" to description
  */
 function addAdditionalPropertiesHints(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => addAdditionalPropertiesHints(item));
+        return schema.map((item) => addAdditionalPropertiesHints(item));
     }
     let result = { ...schema };
     if (result.additionalProperties === false) {
-        result = appendDescriptionHint(result, "No extra properties allowed");
+        result = appendDescriptionHint(result, 'No extra properties allowed');
     }
     // Recursively process nested objects
     for (const [key, value] of Object.entries(result)) {
-        if (key !== "additionalProperties" && typeof value === "object" && value !== null) {
+        if (key !== 'additionalProperties' &&
+            typeof value === 'object' &&
+            value !== null) {
             result[key] = addAdditionalPropertiesHints(value);
         }
     }
@@ -139,22 +157,23 @@ function addAdditionalPropertiesHints(schema) {
  * { minLength: 1, maxLength: 100 } → adds "(minLength: 1) (maxLength: 100)" to description
  */
 function moveConstraintsToDescription(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => moveConstraintsToDescription(item));
+        return schema.map((item) => moveConstraintsToDescription(item));
     }
     let result = { ...schema };
     // Move constraint values to description
     for (const constraint of UNSUPPORTED_CONSTRAINTS) {
-        if (result[constraint] !== undefined && typeof result[constraint] !== "object") {
+        if (result[constraint] !== undefined &&
+            typeof result[constraint] !== 'object') {
             result = appendDescriptionHint(result, `${constraint}: ${result[constraint]}`);
         }
     }
     // Recursively process nested objects
     for (const [key, value] of Object.entries(result)) {
-        if (typeof value === "object" && value !== null) {
+        if (typeof value === 'object' && value !== null) {
             result[key] = moveConstraintsToDescription(value);
         }
     }
@@ -166,22 +185,22 @@ function moveConstraintsToDescription(schema) {
  * → { properties: { a: ..., b: ... } }
  */
 function mergeAllOf(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => mergeAllOf(item));
+        return schema.map((item) => mergeAllOf(item));
     }
-    let result = { ...schema };
+    const result = { ...schema };
     // If this object has allOf, merge its contents
     if (Array.isArray(result.allOf)) {
         const merged = {};
         const mergedRequired = [];
         for (const item of result.allOf) {
-            if (!item || typeof item !== "object")
+            if (!item || typeof item !== 'object')
                 continue;
             // Merge properties
-            if (item.properties && typeof item.properties === "object") {
+            if (item.properties && typeof item.properties === 'object') {
                 merged.properties = { ...merged.properties, ...item.properties };
             }
             // Merge required arrays
@@ -194,7 +213,9 @@ function mergeAllOf(schema) {
             }
             // Copy other fields from allOf items
             for (const [key, value] of Object.entries(item)) {
-                if (key !== "properties" && key !== "required" && merged[key] === undefined) {
+                if (key !== 'properties' &&
+                    key !== 'required' &&
+                    merged[key] === undefined) {
                     merged[key] = value;
                 }
             }
@@ -204,12 +225,16 @@ function mergeAllOf(schema) {
             result.properties = { ...result.properties, ...merged.properties };
         }
         if (mergedRequired.length > 0) {
-            const existingRequired = Array.isArray(result.required) ? result.required : [];
+            const existingRequired = Array.isArray(result.required)
+                ? result.required
+                : [];
             result.required = Array.from(new Set([...existingRequired, ...mergedRequired]));
         }
         // Copy other merged fields
         for (const [key, value] of Object.entries(merged)) {
-            if (key !== "properties" && key !== "required" && result[key] === undefined) {
+            if (key !== 'properties' &&
+                key !== 'required' &&
+                result[key] === undefined) {
                 result[key] = value;
             }
         }
@@ -217,7 +242,7 @@ function mergeAllOf(schema) {
     }
     // Recursively process nested objects
     for (const [key, value] of Object.entries(result)) {
-        if (typeof value === "object" && value !== null) {
+        if (typeof value === 'object' && value !== null) {
             result[key] = mergeAllOf(value);
         }
     }
@@ -228,24 +253,24 @@ function mergeAllOf(schema) {
  * Higher score = more preferred.
  */
 function scoreSchemaOption(schema) {
-    if (!schema || typeof schema !== "object") {
-        return { score: 0, typeName: "unknown" };
+    if (!schema || typeof schema !== 'object') {
+        return { score: 0, typeName: 'unknown' };
     }
     const type = schema.type;
     // Object or has properties = highest priority
-    if (type === "object" || schema.properties) {
-        return { score: 3, typeName: "object" };
+    if (type === 'object' || schema.properties) {
+        return { score: 3, typeName: 'object' };
     }
     // Array or has items = second priority
-    if (type === "array" || schema.items) {
-        return { score: 2, typeName: "array" };
+    if (type === 'array' || schema.items) {
+        return { score: 2, typeName: 'array' };
     }
     // Any other non-null type
-    if (type && type !== "null") {
+    if (type && type !== 'null') {
         return { score: 1, typeName: type };
     }
     // Null or no type
-    return { score: 0, typeName: type || "null" };
+    return { score: 0, typeName: type || 'null' };
 }
 /**
  * Checks if an anyOf/oneOf array represents enum choices.
@@ -262,7 +287,7 @@ function tryMergeEnumFromUnion(options) {
     }
     const enumValues = [];
     for (const option of options) {
-        if (!option || typeof option !== "object") {
+        if (!option || typeof option !== 'object') {
             return null;
         }
         // Check for const value
@@ -283,7 +308,11 @@ function tryMergeEnumFromUnion(options) {
             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) {
+        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
@@ -304,18 +333,18 @@ function tryMergeEnumFromUnion(options) {
  * → { type: "string", enum: ["a", "b"] }
  */
 function flattenAnyOfOneOf(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => flattenAnyOfOneOf(item));
+        return schema.map((item) => flattenAnyOfOneOf(item));
     }
     let result = { ...schema };
     // Process anyOf or oneOf
-    for (const unionKey of ["anyOf", "oneOf"]) {
+    for (const unionKey of ['anyOf', 'oneOf']) {
         if (Array.isArray(result[unionKey]) && result[unionKey].length > 0) {
             const options = result[unionKey];
-            const parentDesc = typeof result.description === "string" ? result.description : "";
+            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);
@@ -324,7 +353,7 @@ function flattenAnyOfOneOf(schema) {
                 const { [unionKey]: _, ...rest } = result;
                 result = {
                     ...rest,
-                    type: "string",
+                    type: 'string',
                     enum: mergedEnum,
                 };
                 // Preserve parent description
@@ -349,12 +378,15 @@ function flattenAnyOfOneOf(schema) {
                 }
             }
             // Select the best option and flatten it recursively
-            let selected = flattenAnyOfOneOf(options[bestIdx]) || { type: "string" };
+            let selected = flattenAnyOfOneOf(options[bestIdx]) || { type: 'string' };
             // Preserve parent description
             if (parentDesc) {
-                const childDesc = typeof selected.description === "string" ? selected.description : "";
+                const childDesc = typeof selected.description === 'string' ? selected.description : '';
                 if (childDesc && childDesc !== parentDesc) {
-                    selected = { ...selected, description: `${parentDesc} (${childDesc})` };
+                    selected = {
+                        ...selected,
+                        description: `${parentDesc} (${childDesc})`,
+                    };
                 }
                 else if (!childDesc) {
                     selected = { ...selected, description: parentDesc };
@@ -362,7 +394,7 @@ function flattenAnyOfOneOf(schema) {
             }
             if (allTypes.length > 1) {
                 const uniqueTypes = Array.from(new Set(allTypes));
-                const hint = `Accepts: ${uniqueTypes.join(" | ")}`;
+                const hint = `Accepts: ${uniqueTypes.join(' | ')}`;
                 selected = appendDescriptionHint(selected, hint);
             }
             // Replace result with selected schema, preserving other fields
@@ -372,7 +404,7 @@ function flattenAnyOfOneOf(schema) {
     }
     // Recursively process nested objects
     for (const [key, value] of Object.entries(result)) {
-        if (typeof value === "object" && value !== null) {
+        if (typeof value === 'object' && value !== null) {
             result[key] = flattenAnyOfOneOf(value);
         }
     }
@@ -383,43 +415,46 @@ function flattenAnyOfOneOf(schema) {
  * { type: ["string", "null"] } → { type: "string", description: "(nullable)" }
  */
 function flattenTypeArrays(schema, nullableFields, currentPath) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map((item, idx) => flattenTypeArrays(item, nullableFields, `${currentPath || ""}[${idx}]`));
+        return schema.map((item, idx) => flattenTypeArrays(item, nullableFields, `${currentPath || ''}[${idx}]`));
     }
     let result = { ...schema };
     const localNullableFields = nullableFields || new Map();
     // Handle type array
     if (Array.isArray(result.type)) {
         const types = result.type;
-        const hasNull = types.includes("null");
-        const nonNullTypes = types.filter(t => t !== "null" && t);
+        const hasNull = types.includes('null');
+        const nonNullTypes = types.filter((t) => t !== 'null' && t);
         // Select first non-null type, or "string" as fallback
-        const firstType = nonNullTypes.length > 0 ? nonNullTypes[0] : "string";
+        const firstType = nonNullTypes.length > 0 ? nonNullTypes[0] : 'string';
         result.type = firstType;
         // Add hint for multiple types
         if (nonNullTypes.length > 1) {
-            result = appendDescriptionHint(result, `Accepts: ${nonNullTypes.join(" | ")}`);
+            result = appendDescriptionHint(result, `Accepts: ${nonNullTypes.join(' | ')}`);
         }
         // Add nullable hint
         if (hasNull) {
-            result = appendDescriptionHint(result, "nullable");
+            result = appendDescriptionHint(result, 'nullable');
         }
     }
     // Recursively process properties
-    if (result.properties && typeof result.properties === "object") {
+    if (result.properties && typeof result.properties === 'object') {
         const newProps = {};
         for (const [propKey, propValue] of Object.entries(result.properties)) {
-            const propPath = currentPath ? `${currentPath}.properties.${propKey}` : `properties.${propKey}`;
+            const propPath = currentPath
+                ? `${currentPath}.properties.${propKey}`
+                : `properties.${propKey}`;
             const processed = flattenTypeArrays(propValue, localNullableFields, propPath);
             newProps[propKey] = processed;
             // Track nullable fields for required array cleanup
-            if (processed && typeof processed === "object" &&
-                typeof processed.description === "string" &&
-                processed.description.includes("nullable")) {
-                const objectPath = currentPath || "";
+            if (processed &&
+                typeof processed === 'object' &&
+                typeof processed.description === 'string' &&
+                processed.description.includes('nullable')) {
+                const objectPath = currentPath || '';
                 const existing = localNullableFields.get(objectPath) || [];
                 existing.push(propKey);
                 localNullableFields.set(objectPath, existing);
@@ -430,7 +465,7 @@ function flattenTypeArrays(schema, nullableFields, currentPath) {
     // Remove nullable fields from required array
     if (Array.isArray(result.required) && !nullableFields) {
         // Only at root level, filter out nullable fields
-        const nullableAtRoot = localNullableFields.get("") || [];
+        const nullableAtRoot = localNullableFields.get('') || [];
         if (nullableAtRoot.length > 0) {
             result.required = result.required.filter((r) => !nullableAtRoot.includes(r));
             if (result.required.length === 0) {
@@ -440,8 +475,8 @@ function flattenTypeArrays(schema, nullableFields, currentPath) {
     }
     // Recursively process other nested objects
     for (const [key, value] of Object.entries(result)) {
-        if (key !== "properties" && typeof value === "object" && value !== null) {
-            result[key] = flattenTypeArrays(value, localNullableFields, `${currentPath || ""}.${key}`);
+        if (key !== 'properties' && typeof value === 'object' && value !== null) {
+            result[key] = flattenTypeArrays(value, localNullableFields, `${currentPath || ''}.${key}`);
         }
     }
     return result;
@@ -451,19 +486,20 @@ function flattenTypeArrays(schema, nullableFields, currentPath) {
  * @param insideProperties - When true, keys are property NAMES (preserve); when false, keys are JSON Schema keywords (filter).
  */
 function removeUnsupportedKeywords(schema, insideProperties = false) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => removeUnsupportedKeywords(item, false));
+        return schema.map((item) => removeUnsupportedKeywords(item, false));
     }
     const result = {};
     for (const [key, value] of Object.entries(schema)) {
-        if (!insideProperties && UNSUPPORTED_KEYWORDS.includes(key)) {
+        if (!insideProperties &&
+            UNSUPPORTED_KEYWORDS.includes(key)) {
             continue;
         }
-        if (typeof value === "object" && value !== null) {
-            if (key === "properties") {
+        if (typeof value === 'object' && value !== null) {
+            if (key === 'properties') {
                 const propertiesResult = {};
                 for (const [propName, propSchema] of Object.entries(value)) {
                     propertiesResult[propName] = removeUnsupportedKeywords(propSchema, false);
@@ -484,16 +520,18 @@ function removeUnsupportedKeywords(schema, insideProperties = false) {
  * Phase 3b: Cleans up required fields - removes entries that don't exist in properties.
  */
 function cleanupRequiredFields(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => cleanupRequiredFields(item));
+        return schema.map((item) => cleanupRequiredFields(item));
     }
-    let result = { ...schema };
+    const result = { ...schema };
     // Clean up required array if properties exist
-    if (Array.isArray(result.required) && result.properties && typeof result.properties === "object") {
-        const validRequired = result.required.filter((req) => Object.prototype.hasOwnProperty.call(result.properties, req));
+    if (Array.isArray(result.required) &&
+        result.properties &&
+        typeof result.properties === 'object') {
+        const validRequired = result.required.filter((req) => Object.hasOwn(result.properties, req));
         if (validRequired.length === 0) {
             delete result.required;
         }
@@ -503,7 +541,7 @@ function cleanupRequiredFields(schema) {
     }
     // Recursively process nested objects
     for (const [key, value] of Object.entries(result)) {
-        if (typeof value === "object" && value !== null) {
+        if (typeof value === 'object' && value !== null) {
             result[key] = cleanupRequiredFields(value);
         }
     }
@@ -514,23 +552,23 @@ function cleanupRequiredFields(schema) {
  * Claude VALIDATED mode requires at least one property.
  */
 function addEmptySchemaPlaceholder(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     if (Array.isArray(schema)) {
-        return schema.map(item => addEmptySchemaPlaceholder(item));
+        return schema.map((item) => addEmptySchemaPlaceholder(item));
     }
-    let result = { ...schema };
+    const result = { ...schema };
     // Check if this is an empty object schema
-    const isObjectType = result.type === "object";
+    const isObjectType = result.type === 'object';
     if (isObjectType) {
         const hasProperties = result.properties &&
-            typeof result.properties === "object" &&
+            typeof result.properties === 'object' &&
             Object.keys(result.properties).length > 0;
         if (!hasProperties) {
             result.properties = {
                 [EMPTY_SCHEMA_PLACEHOLDER_NAME]: {
-                    type: "boolean",
+                    type: 'boolean',
                     description: EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION,
                 },
             };
@@ -539,7 +577,7 @@ function addEmptySchemaPlaceholder(schema) {
     }
     // Recursively process nested objects
     for (const [key, value] of Object.entries(result)) {
-        if (typeof value === "object" && value !== null) {
+        if (typeof value === 'object' && value !== null) {
             result[key] = addEmptySchemaPlaceholder(value);
         }
     }
@@ -552,7 +590,7 @@ function addEmptySchemaPlaceholder(schema) {
  * Ported from CLIProxyAPI's CleanJSONSchemaForAntigravity (gemini_schema.go)
  */
 export function cleanJSONSchemaForAntigravity(schema) {
-    if (!schema || typeof schema !== "object") {
+    if (!schema || typeof schema !== 'object') {
         return schema;
     }
     let result = schema;
@@ -584,33 +622,37 @@ export const DEFAULT_THINKING_BUDGET = 16000;
  */
 export function isThinkingCapableModel(modelName) {
     const lowerModel = modelName.toLowerCase();
-    return lowerModel.includes("thinking")
-        || lowerModel.includes("gemini-3")
-        || lowerModel.includes("opus");
+    return (lowerModel.includes('thinking') ||
+        lowerModel.includes('gemini-3') ||
+        lowerModel.includes('opus'));
 }
 /**
  * Extracts thinking configuration from various possible request locations.
  * Supports both Gemini-style thinkingConfig and Anthropic-style thinking options.
  */
 export function extractThinkingConfig(requestPayload, rawGenerationConfig, extraBody) {
-    const thinkingConfig = rawGenerationConfig?.thinkingConfig
-        ?? extraBody?.thinkingConfig
-        ?? requestPayload.thinkingConfig;
-    if (thinkingConfig && typeof thinkingConfig === "object") {
+    const thinkingConfig = rawGenerationConfig?.thinkingConfig ??
+        extraBody?.thinkingConfig ??
+        requestPayload.thinkingConfig;
+    if (thinkingConfig && typeof thinkingConfig === 'object') {
         const config = thinkingConfig;
         return {
             includeThoughts: Boolean(config.includeThoughts),
-            thinkingBudget: typeof config.thinkingBudget === "number" ? config.thinkingBudget : DEFAULT_THINKING_BUDGET,
+            thinkingBudget: typeof config.thinkingBudget === 'number'
+                ? config.thinkingBudget
+                : DEFAULT_THINKING_BUDGET,
         };
     }
     // Convert Anthropic-style "thinking" option: { type: "enabled", budgetTokens: N }
     const anthropicThinking = extraBody?.thinking ?? requestPayload.thinking;
-    if (anthropicThinking && typeof anthropicThinking === "object") {
+    if (anthropicThinking && typeof anthropicThinking === 'object') {
         const thinking = anthropicThinking;
-        if (thinking.type === "enabled" || thinking.budgetTokens) {
+        if (thinking.type === 'enabled' || thinking.budgetTokens) {
             return {
                 includeThoughts: true,
-                thinkingBudget: typeof thinking.budgetTokens === "number" ? thinking.budgetTokens : DEFAULT_THINKING_BUDGET,
+                thinkingBudget: typeof thinking.budgetTokens === 'number'
+                    ? thinking.budgetTokens
+                    : DEFAULT_THINKING_BUDGET,
             };
         }
     }
@@ -632,42 +674,54 @@ export function extractThinkingConfig(requestPayload, rawGenerationConfig, extra
 export function extractVariantThinkingConfig(providerOptions, generationConfig) {
     const result = {};
     // Primary path: extract from providerOptions.google
-    const google = (providerOptions?.google);
+    const google = providerOptions?.google;
     if (google) {
         // Gemini 3 native format: { google: { thinkingLevel: "high", includeThoughts: true } }
         // thinkingLevel takes priority over thinkingBudget - they are mutually exclusive
-        if (typeof google.thinkingLevel === "string") {
+        if (typeof google.thinkingLevel === 'string') {
             result.thinkingLevel = google.thinkingLevel;
-            result.includeThoughts = typeof google.includeThoughts === "boolean" ? google.includeThoughts : undefined;
+            result.includeThoughts =
+                typeof google.includeThoughts === 'boolean'
+                    ? google.includeThoughts
+                    : undefined;
         }
-        else if (google.thinkingConfig && typeof google.thinkingConfig === "object") {
+        else if (google.thinkingConfig &&
+            typeof google.thinkingConfig === 'object') {
             // Budget-based format (Claude/Gemini 2.5): { google: { thinkingConfig: { thinkingBudget } } }
             // Only used when thinkingLevel is not present
             const tc = google.thinkingConfig;
-            if (typeof tc.thinkingBudget === "number") {
+            if (typeof tc.thinkingBudget === 'number') {
                 result.thinkingBudget = tc.thinkingBudget;
             }
         }
         // Extract Google Search config
-        if (google.googleSearch && typeof google.googleSearch === "object") {
+        if (google.googleSearch && typeof google.googleSearch === 'object') {
             const search = google.googleSearch;
             result.googleSearch = {
-                mode: search.mode === 'auto' || search.mode === 'off' ? search.mode : undefined,
+                mode: search.mode === 'auto' || search.mode === 'off'
+                    ? search.mode
+                    : undefined,
                 threshold: typeof search.threshold === 'number' ? search.threshold : undefined,
             };
         }
     }
     // Fallback: OpenCode may pass thinking config in generationConfig
     // instead of providerOptions (common when using model variants)
-    if (result.thinkingBudget === undefined && !result.thinkingLevel && generationConfig) {
-        if (generationConfig.thinkingConfig && typeof generationConfig.thinkingConfig === "object") {
+    if (result.thinkingBudget === undefined &&
+        !result.thinkingLevel &&
+        generationConfig) {
+        if (generationConfig.thinkingConfig &&
+            typeof generationConfig.thinkingConfig === 'object') {
             const tc = generationConfig.thinkingConfig;
-            if (typeof tc.thinkingLevel === "string") {
+            if (typeof tc.thinkingLevel === 'string') {
                 // Gemini 3 native format sent via generationConfig
                 result.thinkingLevel = tc.thinkingLevel;
-                result.includeThoughts = typeof tc.includeThoughts === "boolean" ? tc.includeThoughts : undefined;
+                result.includeThoughts =
+                    typeof tc.includeThoughts === 'boolean'
+                        ? tc.includeThoughts
+                        : undefined;
             }
-            else if (typeof tc.thinkingBudget === "number") {
+            else if (typeof tc.thinkingBudget === 'number') {
                 result.thinkingBudget = tc.thinkingBudget;
             }
         }
@@ -691,11 +745,11 @@ export function resolveThinkingConfig(userConfig, isThinkingModel, _isClaudeMode
  * Checks if a part is a thinking/reasoning block (Anthropic or Gemini style).
  */
 function isThinkingPart(part) {
-    return part.type === "thinking"
-        || part.type === "redacted_thinking"
-        || part.type === "reasoning"
-        || part.thinking !== undefined
-        || part.thought === true;
+    return (part.type === 'thinking' ||
+        part.type === 'redacted_thinking' ||
+        part.type === 'reasoning' ||
+        part.thinking !== undefined ||
+        part.thought === true);
 }
 /**
  * Checks if a part has a signature field (thinking block signature).
@@ -713,15 +767,15 @@ function hasSignatureField(part) {
  * - Gemini: { functionCall }, { functionResponse }
  */
 function isToolBlock(part) {
-    return part.type === "tool_use"
-        || part.type === "tool_result"
-        || part.tool_use_id !== undefined
-        || part.tool_call_id !== undefined
-        || part.tool_result !== undefined
-        || part.tool_use !== undefined
-        || part.toolUse !== undefined
-        || part.functionCall !== undefined
-        || part.functionResponse !== undefined;
+    return (part.type === 'tool_use' ||
+        part.type === 'tool_result' ||
+        part.tool_use_id !== undefined ||
+        part.tool_call_id !== undefined ||
+        part.tool_result !== undefined ||
+        part.tool_use !== undefined ||
+        part.toolUse !== undefined ||
+        part.functionCall !== undefined ||
+        part.functionResponse !== undefined);
 }
 /**
  * Unconditionally strips ALL thinking/reasoning blocks from a content array.
@@ -729,8 +783,8 @@ function isToolBlock(part) {
  * Claude will generate fresh thinking for each turn.
  */
 function stripAllThinkingBlocks(contentArray) {
-    return contentArray.map(item => {
-        if (!item || typeof item !== "object")
+    return contentArray.map((item) => {
+        if (!item || typeof item !== 'object')
             return item;
         if (isToolBlock(item))
             return item;
@@ -739,7 +793,7 @@ function stripAllThinkingBlocks(contentArray) {
             const cc = item.cache_control;
             // Use plain empty text part — thinking-format sentinels get converted by the proxy
             // into Claude thinking blocks missing the required `thinking` field.
-            const sentinel = { text: "." };
+            const sentinel = { text: '.' };
             if (cc)
                 sentinel.cache_control = cc;
             return sentinel;
@@ -763,7 +817,7 @@ function removeTrailingThinkingBlocks(contentArray, sessionId, getCachedSignatur
             break;
         // Replace with sentinel instead of popping — preserves array length
         const cc = part?.cache_control;
-        const sentinel = { text: "." };
+        const sentinel = { text: '.' };
         if (cc)
             sentinel.cache_control = cc;
         result[i] = sentinel;
@@ -776,14 +830,14 @@ function removeTrailingThinkingBlocks(contentArray, sessionId, getCachedSignatur
  */
 function hasValidSignature(part) {
     const signature = part.thought === true ? part.thoughtSignature : part.signature;
-    return typeof signature === "string" && signature.length >= 50;
+    return typeof signature === 'string' && signature.length >= 50;
 }
 /**
  * Gets the signature from a thinking part, if present.
  */
 function getSignature(part) {
     const signature = part.thought === true ? part.thoughtSignature : part.signature;
-    return typeof signature === "string" ? signature : undefined;
+    return typeof signature === 'string' ? signature : undefined;
 }
 /**
  * Checks if a thinking part's signature was generated by our plugin (exists in our cache).
@@ -809,21 +863,21 @@ function isOurCachedSignature(part, sessionId, getCachedSignatureFn) {
  * Gets the text content from a thinking part.
  */
 function getThinkingText(part) {
-    if (typeof part.text === "string")
+    if (typeof part.text === 'string')
         return part.text;
-    if (typeof part.thinking === "string")
+    if (typeof part.thinking === 'string')
         return part.thinking;
-    if (part.text && typeof part.text === "object") {
+    if (part.text && typeof part.text === 'object') {
         const maybeText = part.text.text;
-        if (typeof maybeText === "string")
+        if (typeof maybeText === 'string')
             return maybeText;
     }
-    if (part.thinking && typeof part.thinking === "object") {
+    if (part.thinking && typeof part.thinking === 'object') {
         const maybeText = part.thinking.text ?? part.thinking.thinking;
-        if (typeof maybeText === "string")
+        if (typeof maybeText === 'string')
             return maybeText;
     }
-    return "";
+    return '';
 }
 /**
  * Recursively strips cache_control and providerOptions from any object.
@@ -832,13 +886,13 @@ function getThinkingText(part) {
 function stripCacheControlRecursively(obj) {
     if (obj === null || obj === undefined)
         return obj;
-    if (typeof obj !== "object")
+    if (typeof obj !== 'object')
         return obj;
     if (Array.isArray(obj))
-        return obj.map(item => stripCacheControlRecursively(item));
+        return obj.map((item) => stripCacheControlRecursively(item));
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
-        if (key === "cache_control" || key === "providerOptions")
+        if (key === 'cache_control' || key === 'providerOptions')
             continue;
         result[key] = stripCacheControlRecursively(value);
     }
@@ -853,16 +907,16 @@ function sanitizeThinkingPart(part) {
     // Gemini-style thought blocks: { thought: true, text, thoughtSignature }
     if (part.thought === true) {
         let textContent = part.text;
-        if (typeof textContent === "object" && textContent !== null) {
+        if (typeof textContent === 'object' && textContent !== null) {
             const maybeText = textContent.text;
-            textContent = typeof maybeText === "string" ? maybeText : undefined;
+            textContent = typeof maybeText === 'string' ? maybeText : undefined;
         }
-        const hasContent = typeof textContent === "string" && textContent.trim().length > 0;
+        const hasContent = typeof textContent === 'string' && textContent.trim().length > 0;
         if (!hasContent && !part.thoughtSignature) {
             return null;
         }
         const sanitized = { thought: true };
-        sanitized.text = typeof textContent === "string" ? textContent : "";
+        sanitized.text = typeof textContent === 'string' ? textContent : '';
         if (part.thoughtSignature !== undefined)
             sanitized.thoughtSignature = part.thoughtSignature;
         if (part.cache_control !== undefined)
@@ -870,18 +924,25 @@ function sanitizeThinkingPart(part) {
         return sanitized;
     }
     // Anthropic-style thinking/redacted_thinking blocks: { type: "thinking"|"redacted_thinking", thinking, signature }
-    if (part.type === "thinking" || part.type === "redacted_thinking" || part.thinking !== undefined) {
+    if (part.type === 'thinking' ||
+        part.type === 'redacted_thinking' ||
+        part.thinking !== undefined) {
         let thinkingContent = part.thinking ?? part.text;
-        if (thinkingContent !== undefined && typeof thinkingContent === "object" && thinkingContent !== null) {
+        if (thinkingContent !== undefined &&
+            typeof thinkingContent === 'object' &&
+            thinkingContent !== null) {
             const maybeText = thinkingContent.text ?? thinkingContent.thinking;
-            thinkingContent = typeof maybeText === "string" ? maybeText : undefined;
+            thinkingContent = typeof maybeText === 'string' ? maybeText : undefined;
         }
-        const hasContent = typeof thinkingContent === "string" && thinkingContent.trim().length > 0;
+        const hasContent = typeof thinkingContent === 'string' && thinkingContent.trim().length > 0;
         if (!hasContent && !part.signature) {
             return null;
         }
-        const sanitized = { type: part.type === "redacted_thinking" ? "redacted_thinking" : "thinking" };
-        sanitized.thinking = typeof thinkingContent === "string" ? thinkingContent : "";
+        const sanitized = {
+            type: part.type === 'redacted_thinking' ? 'redacted_thinking' : 'thinking',
+        };
+        sanitized.thinking =
+            typeof thinkingContent === 'string' ? thinkingContent : '';
         if (part.signature !== undefined)
             sanitized.signature = part.signature;
         if (part.cache_control !== undefined)
@@ -889,18 +950,18 @@ function sanitizeThinkingPart(part) {
         return sanitized;
     }
     // Reasoning blocks (OpenCode format): { type: "reasoning", text, signature }
-    if (part.type === "reasoning") {
+    if (part.type === 'reasoning') {
         let textContent = part.text;
-        if (typeof textContent === "object" && textContent !== null) {
+        if (typeof textContent === 'object' && textContent !== null) {
             const maybeText = textContent.text;
-            textContent = typeof maybeText === "string" ? maybeText : undefined;
+            textContent = typeof maybeText === 'string' ? maybeText : undefined;
         }
-        const hasContent = typeof textContent === "string" && textContent.trim().length > 0;
+        const hasContent = typeof textContent === 'string' && textContent.trim().length > 0;
         if (!hasContent && !part.signature) {
             return null;
         }
-        const sanitized = { type: "reasoning" };
-        sanitized.text = typeof textContent === "string" ? textContent : "";
+        const sanitized = { type: 'reasoning' };
+        sanitized.text = typeof textContent === 'string' ? textContent : '';
         if (part.signature !== undefined)
             sanitized.signature = part.signature;
         if (part.cache_control !== undefined)
@@ -914,7 +975,7 @@ function sanitizeThinkingPart(part) {
 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) {
+        if (content && typeof content === 'object' && content.role === roleValue) {
             return i;
         }
     }
@@ -928,7 +989,7 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
     }
     const filtered = [];
     for (const item of contentArray) {
-        if (!item || typeof item !== "object") {
+        if (!item || typeof item !== 'object') {
             filtered.push(item);
             continue;
         }
@@ -954,7 +1015,7 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
         if (isClaudeModel && (isThinking || hasSignature)) {
             // Use plain empty text part — thinking-format sentinels get converted by the proxy
             // into Claude thinking blocks with missing required fields
-            const sentinel = { text: "." };
+            const sentinel = { text: '.' };
             if (item.cache_control)
                 sentinel.cache_control = item.cache_control;
             filtered.push(sentinel);
@@ -974,7 +1035,7 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
                 }
                 else {
                     // sanitizeThinkingPart returned null — use sentinel to preserve array length
-                    const sentinel = { text: "." };
+                    const sentinel = { text: '.' };
                     if (item.cache_control)
                         sentinel.cache_control = item.cache_control;
                     filtered.push(sentinel);
@@ -983,9 +1044,11 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
             }
             // Not our signature (or no signature) - use plain empty text sentinel      // Thinking-format sentinels get converted by the proxy into Claude thinking blocks with missing required fields
             const existingSignature = item.signature || item.thoughtSignature;
-            const signatureInfo = existingSignature ? `foreign signature (${String(existingSignature).length} chars)` : "no signature";
+            const signatureInfo = existingSignature
+                ? `foreign signature (${String(existingSignature).length} chars)`
+                : 'no signature';
             log.debug(`Injecting plain text sentinel for last-message thinking block with ${signatureInfo}`);
-            const sentinel = { text: "." };
+            const sentinel = { text: '.' };
             if (item.cache_control)
                 sentinel.cache_control = item.cache_control;
             filtered.push(sentinel);
@@ -998,7 +1061,7 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
             }
             else {
                 // sanitizeThinkingPart returned null — use sentinel to preserve array length
-                const sentinel = { text: "." };
+                const sentinel = { text: '.' };
                 if (item.cache_control)
                     sentinel.cache_control = item.cache_control;
                 filtered.push(sentinel);
@@ -1012,9 +1075,11 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
                 if (cachedSignature && cachedSignature.length >= 50) {
                     const restoredPart = { ...item };
                     if (item.thought === true) {
+                        ;
                         restoredPart.thoughtSignature = cachedSignature;
                     }
                     else {
+                        ;
                         restoredPart.signature = cachedSignature;
                     }
                     const sanitized = sanitizeThinkingPart(restoredPart);
@@ -1023,7 +1088,7 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
                     }
                     else {
                         // sanitizeThinkingPart returned null — use sentinel to preserve array length
-                        const sentinel = { text: "." };
+                        const sentinel = { text: '.' };
                         if (item.cache_control)
                             sentinel.cache_control = item.cache_control;
                         filtered.push(sentinel);
@@ -1034,7 +1099,7 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
         }
         // Catch-all: thinking/signature part that didn't match any branch above
         // Use sentinel instead of silently dropping to preserve array length
-        const sentinel = { text: "." };
+        const sentinel = { text: '.' };
         if (item.cache_control)
             sentinel.cache_control = item.cache_control;
         filtered.push(sentinel);
@@ -1050,23 +1115,24 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isCla
  * @param getCachedSignatureFn - Optional function to retrieve cached signatures
  */
 export function filterUnsignedThinkingBlocks(contents, sessionId, getCachedSignatureFn, isClaudeModel) {
-    const lastAssistantIdx = findLastAssistantIndex(contents, "model");
+    const lastAssistantIdx = findLastAssistantIndex(contents, 'model');
     return contents.map((content, idx) => {
-        if (!content || typeof content !== "object") {
+        if (!content || typeof content !== 'object') {
             return content;
         }
         const isLastAssistant = idx === lastAssistantIdx;
         if (Array.isArray(content.parts)) {
             const filteredParts = filterContentArray(content.parts, sessionId, getCachedSignatureFn, isClaudeModel, isLastAssistant);
-            const trimmedParts = content.role === "model" && !isClaudeModel
+            const trimmedParts = content.role === 'model' && !isClaudeModel
                 ? removeTrailingThinkingBlocks(filteredParts, sessionId, getCachedSignatureFn)
                 : filteredParts;
             return { ...content, parts: trimmedParts };
         }
         if (Array.isArray(content.content)) {
-            const isAssistantRole = content.role === "assistant";
+            const isAssistantRole = content.role === 'assistant';
             const isLastAssistantContent = idx === lastAssistantIdx ||
-                (isAssistantRole && idx === findLastAssistantIndex(contents, "assistant"));
+                (isAssistantRole &&
+                    idx === findLastAssistantIndex(contents, 'assistant'));
             const filteredContent = filterContentArray(content.content, sessionId, getCachedSignatureFn, isClaudeModel, isLastAssistantContent);
             const trimmedContent = isAssistantRole && !isClaudeModel
                 ? removeTrailingThinkingBlocks(filteredContent, sessionId, getCachedSignatureFn)
@@ -1080,13 +1146,13 @@ export function filterUnsignedThinkingBlocks(contents, sessionId, getCachedSigna
  * Filters thinking blocks from Anthropic-style messages[] payloads using cached signatures.
  */
 export function filterMessagesThinkingBlocks(messages, sessionId, getCachedSignatureFn, isClaudeModel) {
-    const lastAssistantIdx = findLastAssistantIndex(messages, "assistant");
+    const lastAssistantIdx = findLastAssistantIndex(messages, 'assistant');
     return messages.map((message, idx) => {
-        if (!message || typeof message !== "object") {
+        if (!message || typeof message !== 'object') {
             return message;
         }
         if (Array.isArray(message.content)) {
-            const isAssistantRole = message.role === "assistant";
+            const isAssistantRole = message.role === 'assistant';
             const isLastAssistant = isAssistantRole && idx === lastAssistantIdx;
             const filteredContent = filterContentArray(message.content, sessionId, getCachedSignatureFn, isClaudeModel, isLastAssistant);
             const trimmedContent = isAssistantRole && !isClaudeModel
@@ -1100,7 +1166,7 @@ export function filterMessagesThinkingBlocks(messages, sessionId, getCachedSigna
 export function deepFilterThinkingBlocks(payload, sessionId, getCachedSignatureFn, isClaudeModel) {
     const visited = new WeakSet();
     const walk = (value) => {
-        if (!value || typeof value !== "object") {
+        if (!value || typeof value !== 'object') {
             return;
         }
         if (visited.has(value)) {
@@ -1108,7 +1174,9 @@ export function deepFilterThinkingBlocks(payload, sessionId, getCachedSignatureF
         }
         visited.add(value);
         if (Array.isArray(value)) {
-            value.forEach((item) => walk(item));
+            value.forEach((item) => {
+                walk(item);
+            });
             return;
         }
         const obj = value;
@@ -1118,7 +1186,9 @@ export function deepFilterThinkingBlocks(payload, sessionId, getCachedSignatureF
         if (Array.isArray(obj.messages)) {
             obj.messages = filterMessagesThinkingBlocks(obj.messages, sessionId, getCachedSignatureFn, isClaudeModel);
         }
-        Object.keys(obj).forEach((key) => walk(obj[key]));
+        Object.keys(obj).forEach((key) => {
+            walk(obj[key]);
+        });
     };
     walk(payload);
     return payload;
@@ -1129,47 +1199,53 @@ export function deepFilterThinkingBlocks(payload, sessionId, getCachedSignatureF
  * Claude responses through Antigravity may use candidates structure with Anthropic-style parts.
  */
 function transformGeminiCandidate(candidate) {
-    if (!candidate || typeof candidate !== "object") {
+    if (!candidate || typeof candidate !== 'object') {
         return candidate;
     }
     const content = candidate.content;
-    if (!content || typeof content !== "object" || !Array.isArray(content.parts)) {
+    if (!content ||
+        typeof content !== 'object' ||
+        !Array.isArray(content.parts)) {
         return candidate;
     }
     const thinkingTexts = [];
     const transformedParts = content.parts.map((part) => {
-        if (!part || typeof part !== "object") {
+        if (!part || typeof part !== 'object') {
             return part;
         }
         // Handle Gemini-style: thought: true
         if (part.thought === true) {
-            const thinkingText = typeof part.text === "string" ? part.text : "";
+            const thinkingText = typeof part.text === 'string' ? part.text : '';
             thinkingTexts.push(thinkingText);
             // Clean object — NO spread to prevent thinking: <object> leaking into output
             const transformed = {
-                type: "reasoning",
+                type: 'reasoning',
                 text: thinkingText,
                 thought: true,
             };
             const sig = part.thoughtSignature || part.signature;
-            if (typeof sig === "string" && sig)
+            if (typeof sig === 'string' && sig)
                 transformed.thoughtSignature = sig;
             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 = typeof part.thinking === "string" ? part.thinking : typeof part.text === "string" ? part.text : "";
+        if (part.type === 'thinking') {
+            const thinkingText = typeof part.thinking === 'string'
+                ? part.thinking
+                : typeof part.text === 'string'
+                    ? part.text
+                    : '';
             thinkingTexts.push(thinkingText);
             // Clean object — NO spread to prevent thinking: <object> leaking into output
             const transformed = {
-                type: "reasoning",
+                type: 'reasoning',
                 text: thinkingText,
                 thought: true,
             };
             const sig = part.thoughtSignature || part.signature;
-            if (typeof sig === "string" && sig)
+            if (typeof sig === 'string' && sig)
                 transformed.thoughtSignature = sig;
             if (part.cache_control)
                 transformed.cache_control = part.cache_control;
@@ -1206,7 +1282,9 @@ function transformGeminiCandidate(candidate) {
     return {
         ...candidate,
         content: { ...content, parts: transformedParts },
-        ...(thinkingTexts.length > 0 ? { reasoning_content: thinkingTexts.join("\n\n") } : {}),
+        ...(thinkingTexts.length > 0
+            ? { reasoning_content: thinkingTexts.join('\n\n') }
+            : {}),
     };
 }
 /**
@@ -1215,7 +1293,7 @@ function transformGeminiCandidate(candidate) {
  * Also extracts reasoning_content for Anthropic-style responses.
  */
 export function transformThinkingParts(response) {
-    if (!response || typeof response !== "object") {
+    if (!response || typeof response !== 'object') {
         return response;
     }
     const resp = response;
@@ -1225,17 +1303,23 @@ export function transformThinkingParts(response) {
     if (Array.isArray(resp.content)) {
         const transformedContent = [];
         for (const block of resp.content) {
-            if (block && typeof block === "object" && block.type === "thinking") {
-                const thinkingText = typeof block.thinking === "string" ? block.thinking : typeof block.text === "string" ? block.text : "";
+            if (block &&
+                typeof block === 'object' &&
+                block.type === 'thinking') {
+                const thinkingText = typeof block.thinking === 'string'
+                    ? block.thinking
+                    : typeof block.text === 'string'
+                        ? block.text
+                        : '';
                 reasoningTexts.push(thinkingText);
                 // Clean object — NO spread to prevent thinking: <object> leaking into output
                 const transformed = {
-                    type: "reasoning",
+                    type: 'reasoning',
                     text: thinkingText,
                     thought: true,
                 };
                 const sig = block.thoughtSignature || block.signature;
-                if (typeof sig === "string" && sig)
+                if (typeof sig === 'string' && sig)
                     transformed.thoughtSignature = sig;
                 if (block.cache_control)
                     transformed.cache_control = block.cache_control;
@@ -1253,7 +1337,7 @@ export function transformThinkingParts(response) {
     }
     // Add reasoning_content if we found any thinking blocks (for Anthropic-style)
     if (reasoningTexts.length > 0 && !result.reasoning_content) {
-        result.reasoning_content = reasoningTexts.join("\n\n");
+        result.reasoning_content = reasoningTexts.join('\n\n');
     }
     return result;
 }
@@ -1261,17 +1345,22 @@ export function transformThinkingParts(response) {
  * Ensures thinkingConfig is valid: includeThoughts only allowed when budget > 0.
  */
 export function normalizeThinkingConfig(config) {
-    if (!config || typeof config !== "object") {
+    if (!config || typeof config !== 'object') {
         return undefined;
     }
     const record = config;
     const budgetRaw = record.thinkingBudget ?? record.thinking_budget;
     const includeRaw = record.includeThoughts ?? record.include_thoughts;
-    const thinkingBudget = typeof budgetRaw === "number" && Number.isFinite(budgetRaw) ? budgetRaw : undefined;
-    const includeThoughts = typeof includeRaw === "boolean" ? includeRaw : undefined;
+    const thinkingBudget = typeof budgetRaw === 'number' && Number.isFinite(budgetRaw)
+        ? budgetRaw
+        : undefined;
+    const includeThoughts = typeof includeRaw === 'boolean' ? includeRaw : undefined;
     const enableThinking = thinkingBudget !== undefined && thinkingBudget > 0;
-    const finalInclude = enableThinking ? includeThoughts ?? false : false;
-    if (!enableThinking && finalInclude === false && thinkingBudget === undefined && includeThoughts === undefined) {
+    const finalInclude = enableThinking ? (includeThoughts ?? false) : false;
+    if (!enableThinking &&
+        finalInclude === false &&
+        thinkingBudget === undefined &&
+        includeThoughts === undefined) {
         return undefined;
     }
     const normalized = {};
@@ -1290,13 +1379,13 @@ export function parseAntigravityApiBody(rawText) {
     try {
         const parsed = JSON.parse(rawText);
         if (Array.isArray(parsed)) {
-            const firstObject = parsed.find((item) => typeof item === "object" && item !== null);
-            if (firstObject && typeof firstObject === "object") {
+            const firstObject = parsed.find((item) => typeof item === 'object' && item !== null);
+            if (firstObject && typeof firstObject === 'object') {
                 return firstObject;
             }
             return null;
         }
-        if (parsed && typeof parsed === "object") {
+        if (parsed && typeof parsed === 'object') {
             return parsed;
         }
         return null;
@@ -1309,14 +1398,14 @@ export function parseAntigravityApiBody(rawText) {
  * Extracts usageMetadata from a response object, guarding types.
  */
 export function extractUsageMetadata(body) {
-    const usage = (body.response && typeof body.response === "object"
+    const usage = (body.response && typeof body.response === 'object'
         ? body.response.usageMetadata
         : undefined);
-    if (!usage || typeof usage !== "object") {
+    if (!usage || typeof usage !== 'object') {
         return null;
     }
     const asRecord = usage;
-    const toNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+    const toNumber = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
     return {
         totalTokenCount: toNumber(asRecord.totalTokenCount),
         promptTokenCount: toNumber(asRecord.promptTokenCount),
@@ -1329,9 +1418,9 @@ export function extractUsageMetadata(body) {
  * Walks SSE lines to find a usage-bearing response chunk.
  */
 export function extractUsageFromSsePayload(payload) {
-    const lines = payload.split("\n");
+    const lines = payload.split('\n');
     for (const line of lines) {
-        if (!line.startsWith("data:")) {
+        if (!line.startsWith('data:')) {
             continue;
         }
         const jsonText = line.slice(5).trim();
@@ -1340,16 +1429,16 @@ export function extractUsageFromSsePayload(payload) {
         }
         try {
             const parsed = JSON.parse(jsonText);
-            if (parsed && typeof parsed === "object") {
-                const usage = extractUsageMetadata({ response: parsed.response });
+            if (parsed && typeof parsed === 'object') {
+                const usage = extractUsageMetadata({
+                    response: parsed.response,
+                });
                 if (usage) {
                     return usage;
                 }
             }
         }
-        catch {
-            continue;
-        }
+        catch { }
     }
     return null;
 }
@@ -1361,10 +1450,10 @@ export function rewriteAntigravityPreviewAccessError(body, status, requestedMode
         return null;
     }
     const error = body.error ?? {};
-    const trimmedMessage = typeof error.message === "string" ? error.message.trim() : "";
+    const trimmedMessage = typeof error.message === 'string' ? error.message.trim() : '';
     const messagePrefix = trimmedMessage.length > 0
         ? trimmedMessage
-        : "Antigravity preview features are not enabled for this account.";
+        : 'Antigravity preview features are not enabled for this account.';
     const enhancedMessage = `${messagePrefix} Request preview access at ${ANTIGRAVITY_PREVIEW_LINK} before using this model.`;
     return {
         ...body,
@@ -1381,7 +1470,7 @@ function needsPreviewAccessOverride(status, body, requestedModel) {
     if (isAntigravityModel(requestedModel)) {
         return true;
     }
-    const errorMessage = typeof body.error?.message === "string" ? body.error.message : "";
+    const errorMessage = typeof body.error?.message === 'string' ? body.error.message : '';
     return isAntigravityModel(errorMessage);
 }
 function isAntigravityModel(target) {
@@ -1389,7 +1478,9 @@ function isAntigravityModel(target) {
         return false;
     }
     // Check for Antigravity models instead of Gemini 3
-    return /antigravity/i.test(target) || /opus/i.test(target) || /claude/i.test(target);
+    return (/antigravity/i.test(target) ||
+        /opus/i.test(target) ||
+        /claude/i.test(target));
 }
 // ============================================================================
 // EMPTY RESPONSE DETECTION (Ported from LLM-API-Key-Proxy)
@@ -1406,7 +1497,7 @@ function isAntigravityModel(target) {
  * @returns true if the response is empty
  */
 export function isEmptyResponseBody(text) {
-    if (!text || !text.trim()) {
+    if (!text?.trim()) {
         return true;
     }
     try {
@@ -1423,7 +1514,7 @@ export function isEmptyResponseBody(text) {
             }
             // Check for empty parts in content
             const content = firstCandidate.content;
-            if (!content || typeof content !== "object") {
+            if (!content || typeof content !== 'object') {
                 return true;
             }
             const parts = content.parts;
@@ -1432,13 +1523,13 @@ export function isEmptyResponseBody(text) {
             }
             // Check if all parts are empty (no text, no functionCall)
             const hasContent = parts.some((part) => {
-                if (!part || typeof part !== "object")
+                if (!part || typeof part !== 'object')
                     return false;
-                if (typeof part.text === "string" && part.text.length > 0)
+                if (typeof part.text === 'string' && part.text.length > 0)
                     return true;
                 if (part.functionCall)
                     return true;
-                if (part.thought === true && typeof part.text === "string")
+                if (part.thought === true && typeof part.text === 'string')
                     return true;
                 return false;
             });
@@ -1461,14 +1552,16 @@ export function isEmptyResponseBody(text) {
                 return true;
             }
             // Check if message has content or tool_calls
-            if (!message.content && !message.tool_calls && !message.reasoning_content) {
+            if (!message.content &&
+                !message.tool_calls &&
+                !message.reasoning_content) {
                 return true;
             }
         }
         // Check response wrapper (Antigravity envelope)
         if (parsed.response !== undefined) {
             const response = parsed.response;
-            if (!response || typeof response !== "object") {
+            if (!response || typeof response !== 'object') {
                 return true;
             }
             return isEmptyResponseBody(JSON.stringify(response));
@@ -1482,7 +1575,7 @@ export function isEmptyResponseBody(text) {
 }
 export function createStreamingChunkCounter() {
     let count = 0;
-    let hasRealContent = false;
+    const hasRealContent = false;
     return {
         increment: () => {
             count++;
@@ -1498,11 +1591,11 @@ export function createStreamingChunkCounter() {
  * @returns true if the line contains content worth counting
  */
 export function isMeaningfulSseLine(line) {
-    if (!line.startsWith("data: ")) {
+    if (!line.startsWith('data: ')) {
         return false;
     }
     const data = line.slice(6).trim();
-    if (data === "[DONE]") {
+    if (data === '[DONE]') {
         return false;
     }
     if (!data) {
@@ -1516,7 +1609,7 @@ export function isMeaningfulSseLine(line) {
                 const parts = candidate?.content?.parts;
                 if (Array.isArray(parts) && parts.length > 0) {
                     for (const part of parts) {
-                        if (typeof part?.text === "string" && part.text.length > 0)
+                        if (typeof part?.text === 'string' && part.text.length > 0)
                             return true;
                         if (part?.functionCall)
                             return true;
@@ -1557,29 +1650,29 @@ export function isMeaningfulSseLine(line) {
  */
 // Keys whose string values should NOT be parsed as JSON - they contain literal text content
 const SKIP_PARSE_KEYS = new Set([
-    "oldString",
-    "newString",
-    "content",
-    "filePath",
-    "path",
-    "text",
-    "code",
-    "source",
-    "data",
-    "body",
-    "message",
-    "prompt",
-    "input",
-    "output",
-    "result",
-    "value",
-    "query",
-    "pattern",
-    "replacement",
-    "template",
-    "script",
-    "command",
-    "snippet",
+    'oldString',
+    'newString',
+    'content',
+    'filePath',
+    'path',
+    'text',
+    'code',
+    'source',
+    'data',
+    'body',
+    'message',
+    'prompt',
+    'input',
+    'output',
+    'result',
+    'value',
+    'query',
+    'pattern',
+    'replacement',
+    'template',
+    'script',
+    'command',
+    'snippet',
 ]);
 export function recursivelyParseJsonStrings(obj, skipParseKeys = SKIP_PARSE_KEYS, currentKey) {
     if (obj === null || obj === undefined) {
@@ -1588,14 +1681,14 @@ export function recursivelyParseJsonStrings(obj, skipParseKeys = SKIP_PARSE_KEYS
     if (Array.isArray(obj)) {
         return obj.map((item) => recursivelyParseJsonStrings(item, skipParseKeys));
     }
-    if (typeof obj === "object") {
+    if (typeof obj === 'object') {
         const result = {};
         for (const [key, value] of Object.entries(obj)) {
             result[key] = recursivelyParseJsonStrings(value, skipParseKeys, key);
         }
         return result;
     }
-    if (typeof obj !== "string") {
+    if (typeof obj !== 'string') {
         return obj;
     }
     if (currentKey && skipParseKeys.has(currentKey)) {
@@ -1604,8 +1697,8 @@ export function recursivelyParseJsonStrings(obj, skipParseKeys = SKIP_PARSE_KEYS
     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");
-    const hasIntentionalEscapes = obj.includes('\\"') || obj.includes("\\\\");
+    const hasControlCharEscapes = obj.includes('\\n') || obj.includes('\\t');
+    const hasIntentionalEscapes = obj.includes('\\"') || obj.includes('\\\\');
     if (hasControlCharEscapes && !hasIntentionalEscapes) {
         try {
             // Use JSON.parse with quotes to unescape the string
@@ -1616,10 +1709,10 @@ export function recursivelyParseJsonStrings(obj, skipParseKeys = SKIP_PARSE_KEYS
         }
     }
     // Check if it looks like JSON (starts with { or [)
-    if (stripped && (stripped[0] === "{" || stripped[0] === "[")) {
+    if (stripped && (stripped[0] === '{' || stripped[0] === '[')) {
         // Try standard parsing first
-        if ((stripped.startsWith("{") && stripped.endsWith("}")) ||
-            (stripped.startsWith("[") && stripped.endsWith("]"))) {
+        if ((stripped.startsWith('{') && stripped.endsWith('}')) ||
+            (stripped.startsWith('[') && stripped.endsWith(']'))) {
             try {
                 const parsed = JSON.parse(obj);
                 return recursivelyParseJsonStrings(parsed);
@@ -1629,13 +1722,13 @@ export function recursivelyParseJsonStrings(obj, skipParseKeys = SKIP_PARSE_KEYS
             }
         }
         // Handle malformed JSON: array that doesn't end with ]
-        if (stripped.startsWith("[") && !stripped.endsWith("]")) {
+        if (stripped.startsWith('[') && !stripped.endsWith(']')) {
             try {
-                const lastBracket = stripped.lastIndexOf("]");
+                const lastBracket = stripped.lastIndexOf(']');
                 if (lastBracket > 0) {
                     const cleaned = stripped.slice(0, lastBracket + 1);
                     const parsed = JSON.parse(cleaned);
-                    log.debug("Auto-corrected malformed JSON array", {
+                    log.debug('Auto-corrected malformed JSON array', {
                         truncatedChars: stripped.length - cleaned.length,
                     });
                     return recursivelyParseJsonStrings(parsed);
@@ -1646,13 +1739,13 @@ export function recursivelyParseJsonStrings(obj, skipParseKeys = SKIP_PARSE_KEYS
             }
         }
         // Handle malformed JSON: object that doesn't end with }
-        if (stripped.startsWith("{") && !stripped.endsWith("}")) {
+        if (stripped.startsWith('{') && !stripped.endsWith('}')) {
             try {
-                const lastBrace = stripped.lastIndexOf("}");
+                const lastBrace = stripped.lastIndexOf('}');
                 if (lastBrace > 0) {
                     const cleaned = stripped.slice(0, lastBrace + 1);
                     const parsed = JSON.parse(cleaned);
-                    log.debug("Auto-corrected malformed JSON object", {
+                    log.debug('Auto-corrected malformed JSON object', {
                         truncatedChars: stripped.length - cleaned.length,
                     });
                     return recursivelyParseJsonStrings(parsed);
@@ -1701,7 +1794,7 @@ export function fixToolResponseGrouping(contents) {
         if (responseParts.length > 0) {
             // Collect responses by ID (skip duplicates)
             for (const resp of responseParts) {
-                const respId = resp.functionResponse?.id || "";
+                const respId = resp.functionResponse?.id || '';
                 if (respId && !collectedResponses.has(respId)) {
                     collectedResponses.set(respId, resp);
                 }
@@ -1709,30 +1802,29 @@ export function fixToolResponseGrouping(contents) {
             // Try to satisfy the most recent pending group
             for (let i = pendingGroups.length - 1; i >= 0; i--) {
                 const group = pendingGroups[i];
-                if (group.ids.every(id => collectedResponses.has(id))) {
+                if (group.ids.every((id) => collectedResponses.has(id))) {
                     // All IDs found - build the response group
-                    const groupResponses = group.ids.map(id => {
+                    const groupResponses = group.ids.map((id) => {
                         const resp = collectedResponses.get(id);
                         collectedResponses.delete(id);
                         return resp;
                     });
-                    newContents.push({ parts: groupResponses, role: "user" });
+                    newContents.push({ parts: groupResponses, role: 'user' });
                     pendingGroups.splice(i, 1);
                     break; // Only satisfy one group at a time
                 }
             }
             continue; // Don't add the original response message
         }
-        if (role === "model") {
+        if (role === 'model') {
             // Check for function calls in this model message
             const funcCalls = parts.filter((p) => p?.functionCall);
             newContents.push(content);
             if (funcCalls.length > 0) {
                 const callIds = funcCalls
-                    .map((fc) => fc.functionCall?.id || "")
+                    .map((fc) => fc.functionCall?.id || '')
                     .filter(Boolean);
-                const funcNames = funcCalls
-                    .map((fc) => fc.functionCall?.name || "");
+                const funcNames = funcCalls.map((fc) => fc.functionCall?.name || '');
                 if (callIds.length > 0) {
                     pendingGroups.push({
                         ids: callIds,
@@ -1753,7 +1845,7 @@ export function fixToolResponseGrouping(contents) {
         const groupResponses = [];
         for (let i = 0; i < group.ids.length; i++) {
             const expectedId = group.ids[i];
-            const expectedName = group.funcNames[i] || "";
+            const expectedName = group.funcNames[i] || '';
             if (collectedResponses.has(expectedId)) {
                 // Direct ID match - ideal case
                 groupResponses.push(collectedResponses.get(expectedId));
@@ -1764,7 +1856,7 @@ export function fixToolResponseGrouping(contents) {
                 let matchedId = null;
                 // Pass 1: Match by function name
                 for (const [orphanId, orphanResp] of collectedResponses) {
-                    const orphanName = orphanResp.functionResponse?.name || "";
+                    const orphanName = orphanResp.functionResponse?.name || '';
                     if (orphanName === expectedName) {
                         matchedId = orphanId;
                         break;
@@ -1773,7 +1865,7 @@ export function fixToolResponseGrouping(contents) {
                 // Pass 2: Match "unknown_function" orphans
                 if (!matchedId) {
                     for (const [orphanId, orphanResp] of collectedResponses) {
-                        if (orphanResp.functionResponse?.name === "unknown_function") {
+                        if (orphanResp.functionResponse?.name === 'unknown_function') {
                             matchedId = orphanId;
                             break;
                         }
@@ -1788,10 +1880,11 @@ export function fixToolResponseGrouping(contents) {
                     collectedResponses.delete(matchedId);
                     // Fix the ID and name to match expected
                     orphanResp.functionResponse.id = expectedId;
-                    if (orphanResp.functionResponse.name === "unknown_function" && expectedName) {
+                    if (orphanResp.functionResponse.name === 'unknown_function' &&
+                        expectedName) {
                         orphanResp.functionResponse.name = expectedName;
                     }
-                    log.debug("Auto-repaired tool ID mismatch", {
+                    log.debug('Auto-repaired tool ID mismatch', {
                         mappedFrom: matchedId,
                         mappedTo: expectedId,
                         functionName: expectedName,
@@ -1803,18 +1896,18 @@ export function fixToolResponseGrouping(contents) {
                 // No responses available - create placeholder
                 const placeholder = {
                     functionResponse: {
-                        name: expectedName || "unknown_function",
+                        name: expectedName || 'unknown_function',
                         response: {
                             result: {
-                                error: "Tool response was lost during context processing. " +
-                                    "This is a recovered placeholder.",
+                                error: 'Tool response was lost during context processing. ' +
+                                    'This is a recovered placeholder.',
                                 recovered: true,
                             },
                         },
                         id: expectedId,
                     },
                 };
-                log.debug("Created placeholder response for missing tool", {
+                log.debug('Created placeholder response for missing tool', {
                     id: expectedId,
                     name: expectedName,
                 });
@@ -1825,7 +1918,7 @@ export function fixToolResponseGrouping(contents) {
             // Insert at correct position (after the model message that made the calls)
             newContents.splice(group.insertAfterIdx + 1, 0, {
                 parts: groupResponses,
-                role: "user",
+                role: 'user',
             });
         }
     }
@@ -1853,8 +1946,8 @@ export function detectToolIdMismatches(contents) {
     }
     const expectedSet = new Set(expectedIds);
     const foundSet = new Set(foundIds);
-    const missingIds = expectedIds.filter(id => !foundSet.has(id));
-    const orphanIds = foundIds.filter(id => !expectedSet.has(id));
+    const missingIds = expectedIds.filter((id) => !foundSet.has(id));
+    const orphanIds = foundIds.filter((id) => !expectedSet.has(id));
     return {
         hasMismatches: missingIds.length > 0 || orphanIds.length > 0,
         expectedIds,
@@ -1876,10 +1969,10 @@ export function findOrphanedToolUseIds(messages) {
     for (const msg of messages) {
         if (Array.isArray(msg.content)) {
             for (const block of msg.content) {
-                if (block.type === "tool_use" && block.id) {
+                if (block.type === 'tool_use' && block.id) {
                     toolUseIds.add(block.id);
                 }
-                if (block.type === "tool_result" && block.tool_use_id) {
+                if (block.type === 'tool_result' && block.tool_use_id) {
                     toolResultIds.add(block.tool_use_id);
                 }
             }
@@ -1906,10 +1999,13 @@ export function fixClaudeToolPairing(messages) {
     const toolUseMap = new Map();
     for (let i = 0; i < messages.length; i++) {
         const msg = messages[i];
-        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        if (msg.role === 'assistant' && Array.isArray(msg.content)) {
             for (const block of msg.content) {
-                if (block.type === "tool_use" && block.id) {
-                    toolUseMap.set(block.id, { name: block.name || `tool-${toolUseMap.size}`, msgIndex: i });
+                if (block.type === 'tool_use' && block.id) {
+                    toolUseMap.set(block.id, {
+                        name: block.name || `tool-${toolUseMap.size}`,
+                        msgIndex: i,
+                    });
                 }
             }
         }
@@ -1917,9 +2013,9 @@ export function fixClaudeToolPairing(messages) {
     // 2. Collect all tool_result IDs from user messages
     const toolResultIds = new Set();
     for (const msg of messages) {
-        if (msg.role === "user" && Array.isArray(msg.content)) {
+        if (msg.role === 'user' && Array.isArray(msg.content)) {
             for (const block of msg.content) {
-                if (block.type === "tool_result" && block.tool_use_id) {
+                if (block.type === 'tool_result' && block.tool_use_id) {
                     toolResultIds.add(block.tool_use_id);
                 }
             }
@@ -1950,10 +2046,10 @@ export function fixClaudeToolPairing(messages) {
         if (orphansForMsg && orphansForMsg.length > 0) {
             // Check if next message is user with tool_result - if so, merge into it
             const nextMsg = messages[i + 1];
-            if (nextMsg?.role === "user" && Array.isArray(nextMsg.content)) {
+            if (nextMsg?.role === 'user' && Array.isArray(nextMsg.content)) {
                 // Will be handled when we push nextMsg - add to its content
                 const placeholders = orphansForMsg.map((o) => ({
-                    type: "tool_result",
+                    type: 'tool_result',
                     tool_use_id: o.id,
                     content: `[Tool "${o.name}" execution was cancelled or failed]`,
                     is_error: true,
@@ -1964,9 +2060,9 @@ export function fixClaudeToolPairing(messages) {
             else {
                 // Inject new user message with placeholder tool_results
                 result.push({
-                    role: "user",
+                    role: 'user',
                     content: orphansForMsg.map((o) => ({
-                        type: "tool_result",
+                        type: 'tool_result',
                         tool_use_id: o.id,
                         content: `[Tool "${o.name}" execution was cancelled or failed]`,
                         is_error: true,
@@ -1984,17 +2080,19 @@ export function fixClaudeToolPairing(messages) {
 function removeOrphanedToolUse(messages, orphanIds) {
     return messages
         .map((msg) => {
-        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        if (msg.role === 'assistant' && Array.isArray(msg.content)) {
             return {
                 ...msg,
-                content: msg.content.filter((block) => block.type !== "tool_use" || !orphanIds.has(block.id)),
+                content: msg.content.filter((block) => block.type !== 'tool_use' || !orphanIds.has(block.id)),
             };
         }
         return msg;
     })
         .filter((msg) => 
     // Remove empty assistant messages
-    !(msg.role === "assistant" && Array.isArray(msg.content) && msg.content.length === 0));
+    !(msg.role === 'assistant' &&
+        Array.isArray(msg.content) &&
+        msg.content.length === 0));
 }
 /**
  * Validate and fix tool pairing with fallback nuclear option.
@@ -2005,7 +2103,7 @@ export function validateAndFixClaudeToolPairing(messages) {
         return messages;
     }
     // First: Try gentle fix (inject placeholder tool_results)
-    let fixed = fixClaudeToolPairing(messages);
+    const fixed = fixClaudeToolPairing(messages);
     // Second: Validate - find any remaining orphans
     const orphanIds = findOrphanedToolUseIds(fixed);
     if (orphanIds.size === 0) {
@@ -2013,7 +2111,7 @@ export function validateAndFixClaudeToolPairing(messages) {
     }
     // Third: Nuclear option - remove orphaned tool_use entirely
     // This should rarely happen, but provides defense in depth
-    console.warn("[antigravity] fixClaudeToolPairing left orphans, applying nuclear option", {
+    console.warn('[antigravity] fixClaudeToolPairing left orphans, applying nuclear option', {
         orphanIds: [...orphanIds],
     });
     return removeOrphanedToolUse(fixed, orphanIds);
@@ -2026,12 +2124,12 @@ export function validateAndFixClaudeToolPairing(messages) {
  * Port of LLM-API-Key-Proxy's _format_type_hint()
  */
 function formatTypeHint(propData, depth = 0) {
-    const type = propData.type ?? "unknown";
+    const type = propData.type ?? 'unknown';
     // Handle enum values
     if (propData.enum && Array.isArray(propData.enum)) {
         const enumVals = propData.enum;
         if (enumVals.length <= 5) {
-            return `string ENUM[${enumVals.map(v => JSON.stringify(v)).join(", ")}]`;
+            return `string ENUM[${enumVals.map((v) => JSON.stringify(v)).join(', ')}]`;
         }
         return `string ENUM[${enumVals.length} options]`;
     }
@@ -2039,37 +2137,37 @@ function formatTypeHint(propData, depth = 0) {
     if (propData.const !== undefined) {
         return `string CONST=${JSON.stringify(propData.const)}`;
     }
-    if (type === "array") {
+    if (type === 'array') {
         const items = propData.items;
-        if (items && typeof items === "object") {
-            const itemType = items.type ?? "unknown";
-            if (itemType === "object") {
+        if (items && typeof items === 'object') {
+            const itemType = items.type ?? 'unknown';
+            if (itemType === 'object') {
                 const nestedProps = items.properties;
                 const nestedReq = items.required ?? [];
                 if (nestedProps && depth < 1) {
                     const nestedList = Object.entries(nestedProps).map(([n, d]) => {
-                        const t = d.type ?? "unknown";
-                        const req = nestedReq.includes(n) ? " REQUIRED" : "";
+                        const t = d.type ?? 'unknown';
+                        const req = nestedReq.includes(n) ? ' REQUIRED' : '';
                         return `${n}: ${t}${req}`;
                     });
-                    return `ARRAY_OF_OBJECTS[${nestedList.join(", ")}]`;
+                    return `ARRAY_OF_OBJECTS[${nestedList.join(', ')}]`;
                 }
-                return "ARRAY_OF_OBJECTS";
+                return 'ARRAY_OF_OBJECTS';
             }
             return `ARRAY_OF_${itemType.toUpperCase()}`;
         }
-        return "ARRAY";
+        return 'ARRAY';
     }
-    if (type === "object") {
+    if (type === 'object') {
         const nestedProps = propData.properties;
         const nestedReq = propData.required ?? [];
         if (nestedProps && depth < 1) {
             const nestedList = Object.entries(nestedProps).map(([n, d]) => {
-                const t = d.type ?? "unknown";
-                const req = nestedReq.includes(n) ? " REQUIRED" : "";
+                const t = d.type ?? 'unknown';
+                const req = nestedReq.includes(n) ? ' REQUIRED' : '';
                 return `${n}: ${t}${req}`;
             });
-            return `object{${nestedList.join(", ")}}`;
+            return `object{${nestedList.join(', ')}}`;
         }
     }
     return type;
@@ -2086,7 +2184,7 @@ function formatTypeHint(propData, depth = 0) {
  * @param promptTemplate - Template for the signature (default: "\\n\\nSTRICT PARAMETERS: {params}.")
  * @returns Modified tools array with signatures injected
  */
-export function injectParameterSignatures(tools, promptTemplate = "\n\n⚠️ STRICT PARAMETERS: {params}.") {
+export function injectParameterSignatures(tools, promptTemplate = '\n\n⚠️ STRICT PARAMETERS: {params}.') {
     if (!tools || !Array.isArray(tools))
         return tools;
     return tools.map((tool) => {
@@ -2095,7 +2193,7 @@ export function injectParameterSignatures(tools, promptTemplate = "\n\n⚠️ ST
             return tool;
         const newDeclarations = declarations.map((decl) => {
             // Skip if signature already injected (avoids duplicate injection)
-            if (decl.description?.includes("STRICT PARAMETERS:")) {
+            if (decl.description?.includes('STRICT PARAMETERS:')) {
                 return decl;
             }
             const schema = decl.parameters || decl.parametersJsonSchema;
@@ -2108,12 +2206,12 @@ export function injectParameterSignatures(tools, promptTemplate = "\n\n⚠️ ST
             const paramList = Object.entries(properties).map(([propName, propData]) => {
                 const typeHint = formatTypeHint(propData);
                 const isRequired = required.includes(propName);
-                return `${propName} (${typeHint}${isRequired ? ", REQUIRED" : ""})`;
+                return `${propName} (${typeHint}${isRequired ? ', REQUIRED' : ''})`;
             });
-            const sigStr = promptTemplate.replace("{params}", paramList.join(", "));
+            const sigStr = promptTemplate.replace('{params}', paramList.join(', '));
             return {
                 ...decl,
-                description: (decl.description || "") + sigStr,
+                description: (decl.description || '') + sigStr,
             };
         });
         return { ...tool, functionDeclarations: newDeclarations };
@@ -2131,36 +2229,37 @@ export function injectToolHardeningInstruction(payload, instructionText) {
         return;
     // Skip if instruction already present (avoids duplicate injection)
     const existing = payload.systemInstruction;
-    if (existing && typeof existing === "object" && "parts" in existing) {
+    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"))) {
+        if (Array.isArray(parts) &&
+            parts.some((p) => p.text?.includes('CRITICAL TOOL USAGE INSTRUCTIONS'))) {
             return;
         }
     }
     const instructionPart = { text: instructionText };
     if (payload.systemInstruction) {
-        if (existing && typeof existing === "object" && "parts" in existing) {
+        if (existing && typeof existing === 'object' && 'parts' in existing) {
             const parts = existing.parts;
             if (Array.isArray(parts)) {
                 parts.push(instructionPart);
             }
         }
-        else if (typeof existing === "string") {
+        else if (typeof existing === 'string') {
             payload.systemInstruction = {
-                role: "user",
+                role: 'user',
                 parts: [{ text: existing }, instructionPart],
             };
         }
         else {
             payload.systemInstruction = {
-                role: "user",
+                role: 'user',
                 parts: [instructionPart],
             };
         }
     }
     else {
         payload.systemInstruction = {
-            role: "user",
+            role: 'user',
             parts: [instructionPart],
         };
     }
@@ -2187,12 +2286,12 @@ export function assignToolIdsToContents(contents) {
             return content;
         }
         const newParts = content.parts.map((part) => {
-            if (part && typeof part === "object" && part.functionCall) {
+            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 nameKey = typeof call.name === 'string' ? call.name : `tool-${toolCallCounter}`;
                 const queue = pendingCallIdsByName.get(nameKey) || [];
                 queue.push(call.id);
                 pendingCallIdsByName.set(nameKey, queue);
@@ -2221,9 +2320,9 @@ export function matchResponseIdsToContents(contents, pendingCallIdsByName) {
             return content;
         }
         const newParts = content.parts.map((part) => {
-            if (part && typeof part === "object" && part.functionResponse) {
+            if (part && typeof part === 'object' && part.functionResponse) {
                 const resp = { ...part.functionResponse };
-                if (!resp.id && typeof resp.name === "string") {
+                if (!resp.id && typeof resp.name === 'string') {
                     const queue = pendingCallIdsByName.get(resp.name);
                     if (queue && queue.length > 0) {
                         resp.id = queue.shift();
@@ -2264,7 +2363,7 @@ export function applyToolPairingFixes(payload, isClaude) {
         // Third pass: fix orphan recovery
         payload.contents = fixToolResponseGrouping(contentsWithMatchedIds);
         contentsFixed = true;
-        log.debug("Applied tool pairing fixes to contents[]", {
+        log.debug('Applied tool pairing fixes to contents[]', {
             originalLength: payload.contents.length,
         });
     }
@@ -2272,7 +2371,7 @@ export function applyToolPairingFixes(payload, isClaude) {
     if (Array.isArray(payload.messages)) {
         payload.messages = validateAndFixClaudeToolPairing(payload.messages);
         messagesFixed = true;
-        log.debug("Applied tool pairing fixes to messages[]", {
+        log.debug('Applied tool pairing fixes to messages[]', {
             originalLength: payload.messages.length,
         });
     }
@@ -2297,10 +2396,10 @@ export function createSyntheticTextResponse(text, extraHeaders = {}) {
         candidates: [
             {
                 content: {
-                    role: "model",
+                    role: 'model',
                     parts: [{ text }],
                 },
-                finishReason: "STOP",
+                finishReason: 'STOP',
             },
         ],
         usageMetadata: {
@@ -2312,17 +2411,17 @@ export function createSyntheticTextResponse(text, extraHeaders = {}) {
     return new Response(`data: ${JSON.stringify(event)}\n\n`, {
         status: 200,
         headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Antigravity-Synthetic": "true",
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'X-Antigravity-Synthetic': 'true',
             ...extraHeaders,
         },
     });
 }
-export function createSyntheticErrorResponse(errorMessage, _requestedModel = "unknown") {
+export function createSyntheticErrorResponse(errorMessage, _requestedModel = 'unknown') {
     return createSyntheticTextResponse(errorMessage, {
-        "X-Antigravity-Error-Type": "synthetic_error",
+        'X-Antigravity-Error-Type': 'synthetic_error',
     });
 }
 //# sourceMappingURL=request-helpers.js.map