@jsonstudio/llms 0.6.1397 → 0.6.1402

package/dist/conversion/shared/gemini-tool-utils.js

@@ -2,545 +2,145 @@ import { jsonClone } from '../hub/types/json.js';
 function isPlainRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
-const GEMINI_FUNCTION_NAME_SAFE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-export function isGeminiFunctionNameSafe(name) {
-    return typeof name === 'string' && GEMINI_FUNCTION_NAME_SAFE.test(name);
-}
-export function sanitizeGeminiFunctionName(name, options) {
-    const raw = typeof name === 'string' ? name : '';
-    const maxLen = typeof options?.maxLen === 'number' && Number.isFinite(options.maxLen) && options.maxLen > 8
-        ? Math.floor(options.maxLen)
-        : 64;
-    // Preserve existing underscores (many tool namespaces use double-underscores as separators).
-    // Only replace invalid characters.
-    const replaced = raw.replace(/[^A-Za-z0-9_]/g, '_');
-    const prefixed = /^[A-Za-z_]/.test(replaced) ? replaced : `_${replaced}`;
-    const sliced = prefixed.length > maxLen ? prefixed.slice(0, maxLen) : prefixed;
-    return sliced || '_tool';
-}
-// Align with opencode-antigravity-auth gcli2api-style schema transform (toGeminiSchema):
-// Gemini/Antigravity strict protobuf-backed validation rejects these JSON Schema keywords.
-const UNSUPPORTED_KEYWORDS = new Set([
-    'additionalProperties',
-    '$schema',
-    '$id',
-    '$comment',
-    '$ref',
-    '$defs',
-    'definitions',
-    'const',
-    'contentMediaType',
-    'contentEncoding',
-    'if',
-    'then',
-    'else',
-    'not',
-    'patternProperties',
-    'unevaluatedProperties',
-    'unevaluatedItems',
-    'dependentRequired',
-    'dependentSchemas',
-    'propertyNames',
-    'minContains',
-    'maxContains'
-]);
-const EMPTY_SCHEMA_PLACEHOLDER_NAME = '_placeholder';
-const EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION = 'Placeholder. Always pass true.';
-function appendDescriptionHint(schema, hint) {
-    const existing = typeof schema.description === 'string' ? schema.description : '';
-    const description = existing ? `${existing} (${hint})` : hint;
-    return { ...schema, description };
-}
-function convertRefsToHints(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => convertRefsToHints(entry));
-    }
-    const record = schema;
-    if (typeof record.$ref === 'string') {
-        const refVal = record.$ref;
-        const defName = refVal.includes('/') ? refVal.split('/').pop() : refVal;
-        const hint = `See: ${defName || refVal}`;
-        const base = { type: 'object' };
-        if (typeof record.description === 'string' && record.description.trim()) {
-            base.description = `${record.description} (${hint})`;
-        }
-        else {
-            base.description = hint;
+function pickBestSchemaVariant(variants) {
+    if (!Array.isArray(variants) || variants.length === 0) {
+        return { type: 'object', properties: {} };
+    }
+    const score = (value) => {
+        if (!isPlainRecord(value)) {
+            return 0;
+        }
+        const type = typeof value.type === 'string' ? value.type.trim().toLowerCase() : '';
+        // Prefer 'string' to maximize compatibility (can carry arbitrary serialized content),
+        // then object/array, then primitives.
+        if (type === 'string')
+            return 100;
+        if (type === 'object')
+            return 80;
+        if (type === 'array')
+            return 60;
+        if (type === 'integer' || type === 'number' || type === 'boolean')
+            return 50;
+        return 10;
+    };
+    let best = variants[0];
+    let bestScore = score(best);
+    for (const candidate of variants.slice(1)) {
+        const candidateScore = score(candidate);
+        if (candidateScore > bestScore) {
+            best = candidate;
+            bestScore = candidateScore;
         }
-        return base;
-    }
-    const out = {};
-    for (const [key, value] of Object.entries(record)) {
-        out[key] = convertRefsToHints(value);
     }
-    return out;
+    return best;
 }
-function convertConstToEnum(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
+function normalizeSchemaTypes(value) {
+    if (!value || typeof value !== 'object') {
+        return value;
     }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => convertConstToEnum(entry));
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeSchemaTypes(entry));
     }
-    const record = schema;
+    const record = value;
     const out = {};
-    for (const [key, value] of Object.entries(record)) {
-        if (key === 'const' && record.enum === undefined) {
-            out.enum = [convertConstToEnum(value)];
+    for (const [key, val] of Object.entries(record)) {
+        if (key === 'type' && typeof val === 'string') {
+            out[key] = val.toUpperCase();
             continue;
         }
-        out[key] = convertConstToEnum(value);
-    }
-    return out;
-}
-function addEnumHints(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => addEnumHints(entry));
-    }
-    const record = schema;
-    let out = { ...record };
-    if (Array.isArray(record.enum) && record.enum.length > 1 && record.enum.length <= 10) {
-        const vals = record.enum.map((v) => String(v)).join(', ');
-        out = appendDescriptionHint(out, `Allowed: ${vals}`);
-    }
-    for (const [key, value] of Object.entries(out)) {
-        if (key === 'enum')
+        if ((key === 'properties' || key === 'items') && val && typeof val === 'object') {
+            out[key] = normalizeSchemaTypes(val);
             continue;
-        if (value && typeof value === 'object') {
-            out[key] = addEnumHints(value);
         }
-    }
-    return out;
-}
-function addAdditionalPropertiesHints(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => addAdditionalPropertiesHints(entry));
-    }
-    const record = schema;
-    let out = { ...record };
-    if (record.additionalProperties === false) {
-        out = appendDescriptionHint(out, 'No extra properties allowed');
-    }
-    for (const [key, value] of Object.entries(out)) {
-        if (key === 'additionalProperties')
+        if ((key === 'anyOf' || key === 'oneOf' || key === 'allOf') && Array.isArray(val)) {
+            out[key] = val.map((entry) => normalizeSchemaTypes(entry));
             continue;
-        if (value && typeof value === 'object') {
-            out[key] = addAdditionalPropertiesHints(value);
         }
+        out[key] = normalizeSchemaTypes(val);
     }
     return out;
 }
-// Note: we intentionally do not rewrite schemas into description hints (unlike earlier variants),
-// because Gemini/Cloud Code may compare tool schemas across turns; keep transformation minimal and deterministic.
-function mergeAllOf(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => mergeAllOf(entry));
+function cloneParameters(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
     }
-    const record = schema;
-    let out = { ...record };
-    const allOf = out.allOf;
-    if (Array.isArray(allOf) && allOf.length > 0) {
-        const merged = {};
-        const mergedRequired = [];
-        for (const item of allOf) {
-            if (!isPlainRecord(item))
-                continue;
-            if (isPlainRecord(item.properties)) {
-                merged.properties = { ...merged.properties, ...item.properties };
-            }
-            if (Array.isArray(item.required)) {
-                for (const req of item.required) {
-                    if (typeof req === 'string' && !mergedRequired.includes(req)) {
-                        mergedRequired.push(req);
-                    }
-                }
-            }
-            for (const [key, value] of Object.entries(item)) {
-                if (key === 'properties' || key === 'required')
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneParameters(entry));
+    }
+    if (isPlainRecord(value)) {
+        // Normalize JSON Schema const → enum to improve compatibility with functionDeclarations.parameters.
+        // Some upstreams reject `const` but accept `enum`.
+        if (Object.prototype.hasOwnProperty.call(value, 'const') && !Object.prototype.hasOwnProperty.call(value, 'enum')) {
+            const cloned = {};
+            for (const [key, entry] of Object.entries(value)) {
+                if (key === 'const') {
+                    cloned.enum = [cloneParameters(entry)];
                     continue;
-                if (merged[key] === undefined)
-                    merged[key] = value;
-            }
-        }
-        delete out.allOf;
-        if (merged.properties) {
-            out.properties = { ...(isPlainRecord(out.properties) ? out.properties : {}), ...merged.properties };
-        }
-        if (mergedRequired.length > 0) {
-            const existingRequired = Array.isArray(out.required) ? out.required.filter((r) => typeof r === 'string') : [];
-            out.required = Array.from(new Set([...existingRequired, ...mergedRequired]));
-        }
-        for (const [key, value] of Object.entries(merged)) {
-            if (key === 'properties' || key === 'required')
-                continue;
-            if (out[key] === undefined)
-                out[key] = value;
-        }
-    }
-    for (const [key, value] of Object.entries(out)) {
-        if (value && typeof value === 'object') {
-            out[key] = mergeAllOf(value);
-        }
-    }
-    return out;
-}
-function tryMergeEnumFromUnion(options) {
-    if (!Array.isArray(options) || options.length === 0)
-        return null;
-    const enumValues = [];
-    for (const option of options) {
-        if (!isPlainRecord(option))
-            return null;
-        if (option.const !== undefined) {
-            enumValues.push(option.const);
-            continue;
-        }
-        if (Array.isArray(option.enum) && option.enum.length > 0) {
-            enumValues.push(...option.enum);
-            continue;
-        }
-        if (option.properties || option.items || option.anyOf || option.oneOf || option.allOf) {
-            return null;
-        }
-        if (typeof option.type === 'string' && option.type) {
-            return null;
-        }
-        return null;
-    }
-    return enumValues.length > 0 ? enumValues : null;
-}
-function scoreSchemaOption(schema) {
-    if (!isPlainRecord(schema))
-        return { score: 0, typeName: 'unknown' };
-    const type = typeof schema.type === 'string' ? schema.type.toLowerCase() : '';
-    // Prefer 'string' to maximize compatibility (can carry arbitrary serialized content),
-    // then object/array, then primitives. This mirrors our historical Gemini tool behavior
-    // and avoids breaking tools expecting string args (e.g. cmd/command).
-    if (type === 'string')
-        return { score: 4, typeName: 'string' };
-    if (type === 'object' || schema.properties)
-        return { score: 3, typeName: 'object' };
-    if (type === 'array' || schema.items)
-        return { score: 2, typeName: 'array' };
-    if (type && type !== 'null')
-        return { score: 1, typeName: type };
-    return { score: 0, typeName: type || 'null' };
-}
-function flattenAnyOfOneOf(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => flattenAnyOfOneOf(entry));
-    }
-    let out = { ...schema };
-    for (const unionKey of ['anyOf', 'oneOf']) {
-        const options = out[unionKey];
-        if (Array.isArray(options) && options.length > 0) {
-            const parentDesc = typeof out.description === 'string' ? out.description : '';
-            const mergedEnum = tryMergeEnumFromUnion(options);
-            if (mergedEnum) {
-                const next = { ...out };
-                delete next[unionKey];
-                next.type = 'string';
-                next.enum = mergedEnum;
-                if (parentDesc)
-                    next.description = parentDesc;
-                out = next;
-                continue;
-            }
-            let bestIdx = 0;
-            let bestScore = -1;
-            const allTypes = [];
-            for (let i = 0; i < options.length; i++) {
-                const { score, typeName } = scoreSchemaOption(options[i]);
-                allTypes.push(typeName);
-                if (score > bestScore) {
-                    bestScore = score;
-                    bestIdx = i;
-                }
-            }
-            let selected = flattenAnyOfOneOf(options[bestIdx]) || { type: 'string' };
-            if (isPlainRecord(selected)) {
-                let selectedRecord = selected;
-                if (parentDesc) {
-                    const childDesc = typeof selectedRecord.description === 'string' ? selectedRecord.description : '';
-                    selectedRecord = childDesc && childDesc !== parentDesc
-                        ? { ...selectedRecord, description: `${parentDesc} (${childDesc})` }
-                        : childDesc
-                            ? selectedRecord
-                            : { ...selectedRecord, description: parentDesc };
-                }
-                const uniqueTypes = Array.from(new Set(allTypes.filter(Boolean)));
-                if (uniqueTypes.length > 1) {
-                    selectedRecord = appendDescriptionHint(selectedRecord, `Accepts: ${uniqueTypes.join(' | ')}`);
-                }
-                const next = { ...out };
-                delete next[unionKey];
-                delete next.description;
-                out = { ...next, ...selectedRecord };
-            }
-            else {
-                delete out[unionKey];
-            }
-        }
-    }
-    for (const [key, value] of Object.entries(out)) {
-        if (value && typeof value === 'object') {
-            out[key] = flattenAnyOfOneOf(value);
-        }
-    }
-    return out;
-}
-function flattenTypeArrays(schema, nullableFields, currentPath) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry, idx) => flattenTypeArrays(entry, nullableFields, `${currentPath || ''}[${idx}]`));
-    }
-    let out = { ...schema };
-    const localNullableFields = nullableFields || new Map();
-    if (Array.isArray(out.type)) {
-        const types = out.type.filter((t) => typeof t === 'string' && t.trim().length > 0);
-        const hasNull = types.some((t) => t === 'null');
-        const nonNull = types.filter((t) => t !== 'null');
-        const first = nonNull.length > 0 ? nonNull[0] : 'string';
-        out.type = first;
-        if (nonNull.length > 1) {
-            out = appendDescriptionHint(out, `Accepts: ${Array.from(new Set(nonNull)).join(' | ')}`);
-        }
-        if (hasNull) {
-            out = appendDescriptionHint(out, 'nullable');
-        }
-    }
-    if (isPlainRecord(out.properties)) {
-        const nextProps = {};
-        for (const [propKey, propValue] of Object.entries(out.properties)) {
-            const propPath = currentPath ? `${currentPath}.properties.${propKey}` : `properties.${propKey}`;
-            const processed = flattenTypeArrays(propValue, localNullableFields, propPath);
-            nextProps[propKey] = processed;
-            if (isPlainRecord(processed) &&
-                typeof processed.description === 'string' &&
-                processed.description.includes('nullable')) {
-                const objectPath = currentPath || '';
-                const existing = localNullableFields.get(objectPath) || [];
-                existing.push(propKey);
-                localNullableFields.set(objectPath, existing);
-            }
-        }
-        out.properties = nextProps;
-    }
-    // Remove nullable fields from required array (root-level cleanup, aligned with opencode).
-    if (Array.isArray(out.required) && !nullableFields) {
-        const nullableAtRoot = localNullableFields.get(currentPath || '') || [];
-        if (nullableAtRoot.length > 0) {
-            const nextRequired = out.required.filter((r) => typeof r === 'string' && !nullableAtRoot.includes(r));
-            out.required = nextRequired;
-            if (nextRequired.length === 0) {
-                delete out.required;
-            }
-        }
-    }
-    for (const [key, value] of Object.entries(out)) {
-        if (key === 'properties')
-            continue;
-        if (value && typeof value === 'object') {
-            out[key] = flattenTypeArrays(value, localNullableFields, `${currentPath || ''}.${key}`);
-        }
-    }
-    return out;
-}
-function removeUnsupportedKeywords(schema, insideProperties = false) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => removeUnsupportedKeywords(entry, false));
-    }
-    const record = schema;
-    const out = {};
-    for (const [key, value] of Object.entries(record)) {
-        if (!insideProperties && UNSUPPORTED_KEYWORDS.has(key)) {
-            continue;
-        }
-        if (value && typeof value === 'object') {
-            if (key === 'properties' && isPlainRecord(value)) {
-                const propsOut = {};
-                for (const [propName, propSchema] of Object.entries(value)) {
-                    propsOut[propName] = removeUnsupportedKeywords(propSchema, false);
-                }
-                out[key] = propsOut;
-            }
-            else {
-                out[key] = removeUnsupportedKeywords(value, false);
-            }
-        }
-        else {
-            out[key] = value;
-        }
-    }
-    return out;
-}
-function cleanupRequiredFields(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => cleanupRequiredFields(entry));
-    }
-    let out = { ...schema };
-    if (Array.isArray(out.required) && isPlainRecord(out.properties)) {
-        const props = out.properties;
-        const valid = out.required.filter((req) => typeof req === 'string' && Object.prototype.hasOwnProperty.call(props, req));
-        if (valid.length === 0) {
-            delete out.required;
-        }
-        else if (valid.length !== out.required.length) {
-            out.required = valid;
-        }
-    }
-    for (const [key, value] of Object.entries(out)) {
-        if (value && typeof value === 'object') {
-            out[key] = cleanupRequiredFields(value);
-        }
-    }
-    return out;
-}
-function addEmptySchemaPlaceholder(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => addEmptySchemaPlaceholder(entry));
-    }
-    let out = { ...schema };
-    const typeRaw = typeof out.type === 'string' ? out.type.toLowerCase() : '';
-    const isObject = typeRaw === 'object' || isPlainRecord(out.properties);
-    if (isObject) {
-        const hasProps = isPlainRecord(out.properties) && Object.keys(out.properties).length > 0;
-        if (!hasProps) {
-            out.type = 'object';
-            out.properties = {
-                [EMPTY_SCHEMA_PLACEHOLDER_NAME]: {
-                    type: 'boolean',
-                    description: EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION
                 }
-            };
-            out.required = [EMPTY_SCHEMA_PLACEHOLDER_NAME];
-        }
-    }
-    for (const [key, value] of Object.entries(out)) {
-        if (value && typeof value === 'object') {
-            out[key] = addEmptySchemaPlaceholder(value);
-        }
-    }
-    return out;
-}
-function cleanJSONSchemaForAntigravity(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-    let out = schema;
-    // Keep this helper for backward compatibility in other call sites, but avoid
-    // aggressive rewriting that can destabilize schema comparison across turns.
-    out = removeUnsupportedKeywords(out);
-    out = cleanupRequiredFields(out);
-    return out;
-}
-function toGeminiSchema(schema) {
-    if (schema === null || typeof schema === 'string' || typeof schema === 'number' || typeof schema === 'boolean') {
-        return schema;
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((entry) => toGeminiSchema(entry));
-    }
-    if (!isPlainRecord(schema)) {
-        return schema;
-    }
-    const input = schema;
-    const out = {};
-    const propertyNames = new Set();
-    if (isPlainRecord(input.properties)) {
-        for (const key of Object.keys(input.properties)) {
-            propertyNames.add(key);
-        }
-    }
-    for (const [key, value] of Object.entries(input)) {
-        if (UNSUPPORTED_KEYWORDS.has(key)) {
-            continue;
-        }
-        if (key === 'type' && typeof value === 'string') {
-            out[key] = value.toUpperCase();
-            continue;
-        }
-        if (key === 'properties' && isPlainRecord(value)) {
-            const props = {};
-            for (const [propName, propSchema] of Object.entries(value)) {
-                props[propName] = toGeminiSchema(propSchema);
+                cloned[key] = cloneParameters(entry);
             }
-            out[key] = props;
-            continue;
-        }
-        if (key === 'items' && value && typeof value === 'object') {
-            out[key] = toGeminiSchema(value);
-            continue;
-        }
-        if ((key === 'anyOf' || key === 'oneOf' || key === 'allOf') && Array.isArray(value)) {
-            out[key] = value.map((item) => toGeminiSchema(item));
-            continue;
-        }
-        if (key === 'enum' && Array.isArray(value)) {
-            out[key] = value;
-            continue;
-        }
-        if ((key === 'default' || key === 'examples') && value !== undefined) {
-            out[key] = value;
-            continue;
-        }
-        if (key === 'required' && Array.isArray(value)) {
-            if (propertyNames.size > 0) {
-                const validRequired = value.filter((entry) => typeof entry === 'string' && propertyNames.has(entry));
-                // Filter required array to only include properties that exist.
-                if (validRequired.length > 0) {
-                    out[key] = validRequired;
-                }
+            return cloned;
+        }
+        // Gemini function_declarations.parameters only support a subset of JSON Schema.
+        // Additionally, recent Antigravity/Gemini backends may produce MALFORMED_FUNCTION_CALL
+        // when schemas include combinators (oneOf/anyOf/allOf). Prefer a safe single-variant schema.
+        const combinator = Array.isArray(value.oneOf)
+            ? 'oneOf'
+            : Array.isArray(value.anyOf)
+                ? 'anyOf'
+                : Array.isArray(value.allOf)
+                    ? 'allOf'
+                    : undefined;
+        if (combinator) {
+            const variants = value[combinator];
+            const chosen = pickBestSchemaVariant(Array.isArray(variants) ? variants : []);
+            const simplified = cloneParameters(chosen);
+            // Preserve description if present on the wrapper node.
+            if (isPlainRecord(simplified) &&
+                typeof value.description === 'string' &&
+                typeof simplified.description !== 'string') {
+                simplified.description = String(value.description);
             }
-            else {
-                out[key] = value;
+            return simplified;
+        }
+        const cloned = {};
+        for (const [key, entry] of Object.entries(value)) {
+            // Gemini function_declarations.parameters only support a subset of JSON Schema.
+            // Drop meta/unsupported fields that cause INVALID_ARGUMENT, such as $schema/exclusiveMinimum/propertyNames.
+            if (typeof key === 'string') {
+                if (key.startsWith('$'))
+                    continue;
+                if (key === 'const')
+                    continue;
+                if (key === 'default' || key === 'examples' || key === 'example' || key === 'title')
+                    continue;
+                if (key === 'deprecated' || key === 'readOnly' || key === 'writeOnly')
+                    continue;
+                if (key === 'patternProperties' || key === 'dependentRequired' || key === 'dependentSchemas')
+                    continue;
+                if (key === 'unevaluatedProperties' || key === 'unevaluatedItems')
+                    continue;
+                if (key === 'contains' || key === 'minContains' || key === 'maxContains')
+                    continue;
+                if (key === 'contentEncoding' || key === 'contentMediaType' || key === 'contentSchema')
+                    continue;
+                if (key === 'if' || key === 'then' || key === 'else' || key === 'not')
+                    continue;
+                if (key === 'exclusiveMinimum' || key === 'exclusiveMaximum' || key === 'propertyNames')
+                    continue;
+                // Keep Gemini tool schemas mostly permissive to avoid upstream MALFORMED_FUNCTION_CALL on strict validation.
+                // Preserve `required` for Gemini validation (align with gcli2api), but still drop additionalProperties.
+                if (key === 'additionalProperties')
+                    continue;
+                // Combinators are handled at the node level above.
+                if (key === 'oneOf' || key === 'anyOf' || key === 'allOf')
+                    continue;
             }
-            continue;
+            cloned[key] = cloneParameters(entry);
         }
-        out[key] = value;
-    }
-    if (out.type === 'ARRAY' && !('items' in out)) {
-        out.items = { type: 'STRING' };
+        return cloned;
     }
-    return out;
-}
-function cloneParameters(value, mode = 'default') {
-    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        return value;
-    }
-    const cloned = jsonClone(value);
-    if (mode === 'antigravity') {
-        // gcli2api-style: minimal, deterministic transform (no schema hint rewriting).
-        return toGeminiSchema(cloned);
-    }
-    // Default Gemini: avoid aggressive schema rewriting (keep original shape where possible).
-    return convertConstToEnum(cloned);
+    return { type: 'object', properties: {} };
 }
 function declarationToBridge(declaration) {
     if (!declaration || typeof declaration !== 'object') {
@@ -552,7 +152,7 @@ function declarationToBridge(declaration) {
         return null;
     }
     const description = typeof def.description === 'string' ? def.description : undefined;
-    const parameters = cloneParameters(def.parameters ?? { type: 'object', properties: {} }, 'default');
+    const parameters = cloneParameters(def.parameters ?? { type: 'object', properties: {} });
     return {
         type: 'function',
         function: {
@@ -568,7 +168,7 @@ function legacyToolToBridge(entry) {
         return null;
     }
     const description = typeof entry.description === 'string' ? entry.description : undefined;
-    const parameters = cloneParameters(entry.parameters ?? { type: 'object', properties: {} }, 'default');
+    const parameters = cloneParameters(entry.parameters ?? { type: 'object', properties: {} });
     return {
         type: 'function',
         function: {
@@ -625,16 +225,15 @@ export function buildGeminiToolsFromBridge(defs, options) {
     // Keep all function declarations in a single tool group to match gcli2api snapshots
     // and avoid backend-specific limits on the number of tool groups.
     const functionDeclarations = [];
+    const normalizeToolName = (name) => mode === 'antigravity' ? String(name || '').replace(/-/g, '_') : String(name || '');
     const applyFixups = (name, parameters) => {
         if (!parameters || typeof parameters !== 'object' || Array.isArray(parameters)) {
             return parameters;
         }
-        if (mode !== 'antigravity') {
-            return parameters;
-        }
         const params = parameters;
         const propsRaw = params.properties;
         const props = isPlainRecord(propsRaw) ? propsRaw : {};
+        const isAntigravity = mode === 'antigravity';
         const lowered = String(name || '').trim().toLowerCase();
         if (lowered === 'exec_command') {
             // Keep Gemini tool schema aligned with both historical Codex and our runtime tool signature:
@@ -646,20 +245,39 @@ export function buildGeminiToolsFromBridge(defs, options) {
             // is disabled (toolConfig.mode=NONE). Force these fields to simple STRING.
             // For Gemini wire, prefer `command` as the canonical key (gcli2api-style).
             // The internal tool governor normalizes `command` → `cmd` before execution.
-            try {
-                if (Object.prototype.hasOwnProperty.call(props, 'cmd')) {
-                    delete props.cmd;
+            if (isAntigravity) {
+                try {
+                    if (Object.prototype.hasOwnProperty.call(props, 'cmd')) {
+                        delete props.cmd;
+                    }
                 }
+                catch {
+                    // ignore
+                }
+                props.command = {
+                    type: 'STRING',
+                    description: 'Shell command to execute.'
+                };
+                // Keep workdir simple (avoid anyOf string|null patterns).
+                props.workdir = { type: 'STRING', description: 'Working directory.' };
             }
-            catch {
-                // ignore
+            else {
+                if (!Object.prototype.hasOwnProperty.call(props, 'cmd') && Object.prototype.hasOwnProperty.call(props, 'command')) {
+                    props.cmd = props.command;
+                }
+                if (!Object.prototype.hasOwnProperty.call(props, 'command') && Object.prototype.hasOwnProperty.call(props, 'cmd')) {
+                    props.command = props.cmd;
+                }
+                if (!Object.prototype.hasOwnProperty.call(props, 'cmd')) {
+                    props.cmd = { type: 'string' };
+                }
+                if (!Object.prototype.hasOwnProperty.call(props, 'command')) {
+                    props.command = { type: 'string' };
+                }
+                if (!Object.prototype.hasOwnProperty.call(props, 'workdir')) {
+                    props.workdir = { type: 'string' };
+                }
             }
-            props.command = {
-                type: 'STRING',
-                description: 'Shell command to execute.'
-            };
-            // Keep workdir simple (avoid anyOf string|null patterns).
-            props.workdir = { type: 'STRING', description: 'Working directory.' };
             params.properties = props;
             // Avoid hard required keys for Gemini: the model may emit either alias (cmd/command),
             // and "required" mismatch surfaces as MALFORMED_FUNCTION_CALL (empty reply) upstream.
@@ -680,10 +298,10 @@ export function buildGeminiToolsFromBridge(defs, options) {
                 props.text = props.chars;
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'session_id')) {
-                props.session_id = { type: 'NUMBER' };
+                props.session_id = { type: isAntigravity ? 'NUMBER' : 'number' };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'chars')) {
-                props.chars = { type: 'STRING' };
+                props.chars = { type: isAntigravity ? 'STRING' : 'string' };
             }
             params.properties = props;
             try {
@@ -701,25 +319,25 @@ export function buildGeminiToolsFromBridge(defs, options) {
             // - input/instructions/text: historical aliases containing patch text
             if (!Object.prototype.hasOwnProperty.call(props, 'patch')) {
                 props.patch = {
-                    type: 'STRING',
+                    type: isAntigravity ? 'STRING' : 'string',
                     description: 'Patch text (*** Begin Patch / *** End Patch or GNU unified diff).'
                 };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'input')) {
                 props.input = {
-                    type: 'STRING',
+                    type: isAntigravity ? 'STRING' : 'string',
                     description: 'Alias of patch (patch text). Prefer patch.'
                 };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'instructions')) {
                 props.instructions = {
-                    type: 'STRING',
+                    type: isAntigravity ? 'STRING' : 'string',
                     description: 'Alias of patch (patch text). Prefer patch.'
                 };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'text')) {
                 props.text = {
-                    type: 'STRING',
+                    type: isAntigravity ? 'STRING' : 'string',
                     description: 'Alias of patch (patch text). Prefer patch.'
                 };
             }
@@ -765,16 +383,20 @@ export function buildGeminiToolsFromBridge(defs, options) {
         if (!name) {
             return;
         }
+        const finalName = normalizeToolName(name);
         const description = typeof fnNode?.description === 'string'
             ? fnNode.description
             : typeof def.description === 'string'
                 ? def.description
                 : undefined;
-        const parameters = applyFixups(name, cloneParameters(fnNode?.parameters ?? def.parameters ?? { type: 'object', properties: {} }, mode));
+        const parameters = applyFixups(finalName, cloneParameters(fnNode?.parameters ?? def.parameters ?? { type: 'object', properties: {} }));
+        const normalizedParameters = mode === 'antigravity'
+            ? normalizeSchemaTypes(parameters)
+            : parameters;
         functionDeclarations.push({
-            name,
-            description: rewriteDescription(name, description),
-            parameters
+            name: finalName,
+            description: rewriteDescription(finalName, description),
+            parameters: normalizedParameters
         });
     });
     if (!functionDeclarations.length) {