@cortexkit/opencode-antigravity-auth 3.0.1 → 3.0.3

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

@@ -1,3 +1,4 @@
+import { toGeminiSchema } from '@cortexkit/antigravity-auth-core';
 import { EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION, EMPTY_SCHEMA_PLACEHOLDER_NAME, } from '../constants';
 import { getKeepThinking } from './config';
 import { processImageData } from './image-saver';
@@ -8,38 +9,6 @@ const ANTIGRAVITY_PREVIEW_LINK = 'https://goo.gle/enable-preview-features'; // T
 // JSON SCHEMA CLEANING FOR ANTIGRAVITY API
 // Ported from CLIProxyAPI's CleanJSONSchemaForAntigravity (gemini_schema.go)
 // ============================================================================
-/**
- * Unsupported constraint keywords that should be moved to description hints.
- * Claude/Gemini reject these in VALIDATED mode.
- */
-const UNSUPPORTED_CONSTRAINTS = [
-    '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',
-];
 /**
  * Appends a hint to a schema's description field.
  */
@@ -78,28 +47,6 @@ function convertRefsToHints(schema) {
     }
     return result;
 }
-/**
- * Phase 1b: Converts const to enum.
- * { const: "foo" } → { enum: ["foo"] }
- */
-function convertConstToEnum(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((item) => convertConstToEnum(item));
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(schema)) {
-        if (key === 'const' && !schema.enum) {
-            result.enum = [value];
-        }
-        else {
-            result[key] = convertConstToEnum(value);
-        }
-    }
-    return result;
-}
 /**
  * Phase 1c: Adds enum hints to description.
  * { enum: ["a", "b", "c"] } → adds "(Allowed: a, b, c)" to description
@@ -114,6 +61,7 @@ function addEnumHints(schema) {
     let result = { ...schema };
     // Add enum hint if enum has 2-10 items
     if (Array.isArray(result.enum) &&
+        result.enum.every((value) => typeof value === 'string') &&
         result.enum.length > 1 &&
         result.enum.length <= 10) {
         const vals = result.enum.map((v) => String(v)).join(', ');
@@ -127,289 +75,6 @@ function addEnumHints(schema) {
     }
     return result;
 }
-/**
- * Phase 1d: Adds additionalProperties hints.
- * { additionalProperties: false } → adds "(No extra properties allowed)" to description
- */
-function addAdditionalPropertiesHints(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((item) => addAdditionalPropertiesHints(item));
-    }
-    let result = { ...schema };
-    if (result.additionalProperties === false) {
-        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) {
-            result[key] = addAdditionalPropertiesHints(value);
-        }
-    }
-    return result;
-}
-/**
- * Phase 1e: Moves unsupported constraints to description hints.
- * { minLength: 1, maxLength: 100 } → adds "(minLength: 1) (maxLength: 100)" to description
- */
-function moveConstraintsToDescription(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        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') {
-            result = appendDescriptionHint(result, `${constraint}: ${result[constraint]}`);
-        }
-    }
-    // Recursively process nested objects
-    for (const [key, value] of Object.entries(result)) {
-        if (typeof value === 'object' && value !== null) {
-            result[key] = moveConstraintsToDescription(value);
-        }
-    }
-    return result;
-}
-/**
- * Phase 2a: Merges allOf schemas into a single object.
- * { allOf: [{ properties: { a: ... } }, { properties: { b: ... } }] }
- * → { properties: { a: ..., b: ... } }
- */
-function mergeAllOf(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((item) => mergeAllOf(item));
-    }
-    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')
-                continue;
-            // Merge properties
-            if (item.properties && typeof item.properties === 'object') {
-                merged.properties = { ...merged.properties, ...item.properties };
-            }
-            // Merge required arrays
-            if (Array.isArray(item.required)) {
-                for (const req of item.required) {
-                    if (!mergedRequired.includes(req)) {
-                        mergedRequired.push(req);
-                    }
-                }
-            }
-            // Copy other fields from allOf items
-            for (const [key, value] of Object.entries(item)) {
-                if (key !== 'properties' &&
-                    key !== 'required' &&
-                    merged[key] === undefined) {
-                    merged[key] = value;
-                }
-            }
-        }
-        // Apply merged content to result
-        if (merged.properties) {
-            result.properties = { ...result.properties, ...merged.properties };
-        }
-        if (mergedRequired.length > 0) {
-            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) {
-                result[key] = value;
-            }
-        }
-        delete result.allOf;
-    }
-    // Recursively process nested objects
-    for (const [key, value] of Object.entries(result)) {
-        if (typeof value === 'object' && value !== null) {
-            result[key] = mergeAllOf(value);
-        }
-    }
-    return result;
-}
-/**
- * Scores a schema option for selection in anyOf/oneOf flattening.
- * Higher score = more preferred.
- */
-function scoreSchemaOption(schema) {
-    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' };
-    }
-    // Array or has items = second priority
-    if (type === 'array' || schema.items) {
-        return { score: 2, typeName: 'array' };
-    }
-    // Any other non-null type
-    if (type && type !== 'null') {
-        return { score: 1, typeName: type };
-    }
-    // Null or no type
-    return { score: 0, typeName: type || 'null' };
-}
-/**
- * Checks if an anyOf/oneOf array represents enum choices.
- * Returns the merged enum values if so, otherwise null.
- *
- * Handles patterns like:
- * - anyOf: [{ const: "a" }, { const: "b" }]
- * - anyOf: [{ enum: ["a"] }, { enum: ["b"] }]
- * - anyOf: [{ type: "string", const: "a" }, { type: "string", const: "b" }]
- */
-function tryMergeEnumFromUnion(options) {
-    if (!Array.isArray(options) || options.length === 0) {
-        return null;
-    }
-    const enumValues = [];
-    for (const option of options) {
-        if (!option || typeof option !== 'object') {
-            return null;
-        }
-        // Check for const value
-        if (option.const !== undefined) {
-            enumValues.push(String(option.const));
-            continue;
-        }
-        // Check for single-value enum
-        if (Array.isArray(option.enum) && option.enum.length === 1) {
-            enumValues.push(String(option.enum[0]));
-            continue;
-        }
-        // Check for multi-value enum (merge all values)
-        if (Array.isArray(option.enum) && option.enum.length > 0) {
-            for (const val of option.enum) {
-                enumValues.push(String(val));
-            }
-            continue;
-        }
-        // If option has complex structure (properties, items, etc.), it's not a simple enum
-        if (option.properties ||
-            option.items ||
-            option.anyOf ||
-            option.oneOf ||
-            option.allOf) {
-            return null;
-        }
-        // If option has only type (no const/enum), it's not an enum pattern
-        if (option.type && !option.const && !option.enum) {
-            return null;
-        }
-    }
-    // Only return if we found actual enum values
-    return enumValues.length > 0 ? enumValues : null;
-}
-/**
- * Phase 2b: Flattens anyOf/oneOf to the best option with type hints.
- * { anyOf: [{ type: "string" }, { type: "number" }] }
- * → { type: "string", description: "(Accepts: string | number)" }
- *
- * Special handling for enum patterns:
- * { anyOf: [{ const: "a" }, { const: "b" }] }
- * → { type: "string", enum: ["a", "b"] }
- */
-function flattenAnyOfOneOf(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((item) => flattenAnyOfOneOf(item));
-    }
-    let result = { ...schema };
-    // Process anyOf or 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 : '';
-            // First, check if this is an enum pattern (anyOf with const/enum values)
-            // This is crucial for tools like WebFetch where format: anyOf[{const:"text"},{const:"markdown"},{const:"html"}]
-            const mergedEnum = tryMergeEnumFromUnion(options);
-            if (mergedEnum !== null) {
-                // This is an enum pattern - merge all values into a single enum
-                const { [unionKey]: _, ...rest } = result;
-                result = {
-                    ...rest,
-                    type: 'string',
-                    enum: mergedEnum,
-                };
-                // Preserve parent description
-                if (parentDesc) {
-                    result.description = parentDesc;
-                }
-                continue;
-            }
-            // Not an enum pattern - use standard flattening logic
-            // Score each option and find the best
-            let bestIdx = 0;
-            let bestScore = -1;
-            const allTypes = [];
-            for (let i = 0; i < options.length; i++) {
-                const { score, typeName } = scoreSchemaOption(options[i]);
-                if (typeName) {
-                    allTypes.push(typeName);
-                }
-                if (score > bestScore) {
-                    bestScore = score;
-                    bestIdx = i;
-                }
-            }
-            // Select the best option and flatten it recursively
-            let selected = flattenAnyOfOneOf(options[bestIdx]) || { type: 'string' };
-            // Preserve parent description
-            if (parentDesc) {
-                const childDesc = typeof selected.description === 'string' ? selected.description : '';
-                if (childDesc && childDesc !== parentDesc) {
-                    selected = {
-                        ...selected,
-                        description: `${parentDesc} (${childDesc})`,
-                    };
-                }
-                else if (!childDesc) {
-                    selected = { ...selected, description: parentDesc };
-                }
-            }
-            if (allTypes.length > 1) {
-                const uniqueTypes = Array.from(new Set(allTypes));
-                const hint = `Accepts: ${uniqueTypes.join(' | ')}`;
-                selected = appendDescriptionHint(selected, hint);
-            }
-            // Replace result with selected schema, preserving other fields
-            const { [unionKey]: _, description: __, ...rest } = result;
-            result = { ...rest, ...selected };
-        }
-    }
-    // Recursively process nested objects
-    for (const [key, value] of Object.entries(result)) {
-        if (typeof value === 'object' && value !== null) {
-            result[key] = flattenAnyOfOneOf(value);
-        }
-    }
-    return result;
-}
 /**
  * Phase 2c: Flattens type arrays to single type with nullable hint.
  * { type: ["string", "null"] } → { type: "string", description: "(nullable)" }
@@ -481,72 +146,6 @@ function flattenTypeArrays(schema, nullableFields, currentPath) {
     }
     return result;
 }
-/**
- * Phase 3: Removes unsupported keywords after hints have been extracted.
- * @param insideProperties - When true, keys are property NAMES (preserve); when false, keys are JSON Schema keywords (filter).
- */
-function removeUnsupportedKeywords(schema, insideProperties = false) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((item) => removeUnsupportedKeywords(item, false));
-    }
-    const result = {};
-    for (const [key, value] of Object.entries(schema)) {
-        if (!insideProperties &&
-            UNSUPPORTED_KEYWORDS.includes(key)) {
-            continue;
-        }
-        if (typeof value === 'object' && value !== null) {
-            if (key === 'properties') {
-                const propertiesResult = {};
-                for (const [propName, propSchema] of Object.entries(value)) {
-                    propertiesResult[propName] = removeUnsupportedKeywords(propSchema, false);
-                }
-                result[key] = propertiesResult;
-            }
-            else {
-                result[key] = removeUnsupportedKeywords(value, false);
-            }
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-/**
- * Phase 3b: Cleans up required fields - removes entries that don't exist in properties.
- */
-function cleanupRequiredFields(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((item) => cleanupRequiredFields(item));
-    }
-    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.hasOwn(result.properties, req));
-        if (validRequired.length === 0) {
-            delete result.required;
-        }
-        else if (validRequired.length !== result.required.length) {
-            result.required = validRequired;
-        }
-    }
-    // Recursively process nested objects
-    for (const [key, value] of Object.entries(result)) {
-        if (typeof value === 'object' && value !== null) {
-            result[key] = cleanupRequiredFields(value);
-        }
-    }
-    return result;
-}
 /**
  * Phase 4: Adds placeholder property for empty object schemas.
  * Claude VALIDATED mode requires at least one property.
@@ -593,23 +192,17 @@ export function cleanJSONSchemaForAntigravity(schema) {
     if (!schema || typeof schema !== 'object') {
         return schema;
     }
-    let result = schema;
-    // Phase 1: Convert and add hints
-    result = convertRefsToHints(result);
-    result = convertConstToEnum(result);
+    // Claude requests run with VALIDATED function calling, whose schema validation
+    // rejects empty object parameters, unresolved $refs and type arrays. Replace
+    // $refs with description hints, choose one type from each type array, and give
+    // empty objects a placeholder property. The shared converter's Claude option
+    // then flattens unions and moves scalar constraints (lengths, pattern, format,
+    // default) into descriptions, which this validation also refuses.
+    let result = convertRefsToHints(schema);
     result = addEnumHints(result);
-    result = addAdditionalPropertiesHints(result);
-    result = moveConstraintsToDescription(result);
-    // Phase 2: Flatten complex structures
-    result = mergeAllOf(result);
-    result = flattenAnyOfOneOf(result);
     result = flattenTypeArrays(result);
-    // Phase 3: Cleanup
-    result = removeUnsupportedKeywords(result);
-    result = cleanupRequiredFields(result);
-    // Phase 4: Add placeholder for empty object schemas
     result = addEmptySchemaPlaceholder(result);
-    return result;
+    return toGeminiSchema(result, { claudeValidated: true });
 }
 /**
  * Default token budget for thinking/reasoning. 16000 tokens provides sufficient