@jsonstudio/llms 0.6.1164 → 0.6.1354

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

@@ -2,90 +2,545 @@ import { jsonClone } from '../hub/types/json.js';
 function isPlainRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
-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;
+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;
         }
+        return base;
     }
-    return best;
+    const out = {};
+    for (const [key, value] of Object.entries(record)) {
+        out[key] = convertRefsToHints(value);
+    }
+    return out;
 }
-function cloneParameters(value) {
-    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        return value;
+function convertConstToEnum(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map((entry) => convertConstToEnum(entry));
+    }
+    const record = schema;
+    const out = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (key === 'const' && record.enum === undefined) {
+            out.enum = [convertConstToEnum(value)];
+            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')
+            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')
+            continue;
+        if (value && typeof value === 'object') {
+            out[key] = addAdditionalPropertiesHints(value);
+        }
+    }
+    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(value)) {
-        return value.map((entry) => cloneParameters(entry));
-    }
-    if (isPlainRecord(value)) {
-        // 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);
+    if (Array.isArray(schema)) {
+        return schema.map((entry) => mergeAllOf(entry));
+    }
+    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 };
             }
-            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 === 'exclusiveMinimum' || key === 'exclusiveMaximum' || key === 'propertyNames')
-                    continue;
-                // Keep Gemini tool schemas mostly permissive to avoid upstream MALFORMED_FUNCTION_CALL on strict validation.
-                // We selectively re-introduce safe required fields for critical tools in `buildGeminiToolsFromBridge`.
-                if (key === 'required' || key === 'additionalProperties')
-                    continue;
-                // Combinators are handled at the node level above.
-                if (key === 'oneOf' || key === 'anyOf' || key === 'allOf')
+            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')
                     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];
             }
-            cloned[key] = cloneParameters(entry);
         }
-        return cloned;
     }
-    return { type: 'object', properties: {} };
+    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);
+            }
+            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;
+                }
+            }
+            else {
+                out[key] = value;
+            }
+            continue;
+        }
+        out[key] = value;
+    }
+    if (out.type === 'ARRAY' && !('items' in out)) {
+        out.items = { type: 'STRING' };
+    }
+    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);
 }
 function declarationToBridge(declaration) {
     if (!declaration || typeof declaration !== 'object') {
@@ -97,7 +552,7 @@ function declarationToBridge(declaration) {
         return null;
     }
     const description = typeof def.description === 'string' ? def.description : undefined;
-    const parameters = cloneParameters(def.parameters ?? { type: 'object', properties: {} });
+    const parameters = cloneParameters(def.parameters ?? { type: 'object', properties: {} }, 'default');
     return {
         type: 'function',
         function: {
@@ -113,7 +568,7 @@ function legacyToolToBridge(entry) {
         return null;
     }
     const description = typeof entry.description === 'string' ? entry.description : undefined;
-    const parameters = cloneParameters(entry.parameters ?? { type: 'object', properties: {} });
+    const parameters = cloneParameters(entry.parameters ?? { type: 'object', properties: {} }, 'default');
     return {
         type: 'function',
         function: {
@@ -161,15 +616,22 @@ export function prepareGeminiToolsForBridge(rawTools, missing) {
     });
     return defs.length ? defs : undefined;
 }
-export function buildGeminiToolsFromBridge(defs) {
+export function buildGeminiToolsFromBridge(defs, options) {
     if (!defs || !defs.length) {
         return undefined;
     }
-    const tools = [];
+    const mode = options?.mode === 'antigravity' ? 'antigravity' : 'default';
+    // Cloud Code Assist / Gemini CLI is sensitive to tool array shape.
+    // 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 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 : {};
@@ -179,21 +641,25 @@ export function buildGeminiToolsFromBridge(defs) {
             // - Codex CLI: { cmd, workdir }
             // - Some history: { command, workdir }
             // Strict Gemini validation (and/or tool selection) is sensitive to schema/arg drift.
-            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' };
+            // NOTE: Some upstream tool schemas encode cmd/command as `oneOf` (string|array),
+            // which Antigravity/Gemini can reject with MALFORMED_FUNCTION_CALL even when tool calling
+            // 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 (!Object.prototype.hasOwnProperty.call(props, 'workdir')) {
-                props.workdir = { type: 'string' };
+            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.' };
             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.
@@ -214,10 +680,10 @@ export function buildGeminiToolsFromBridge(defs) {
                 props.text = props.chars;
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'session_id')) {
-                props.session_id = { type: 'number' };
+                props.session_id = { type: 'NUMBER' };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'chars')) {
-                props.chars = { type: 'string' };
+                props.chars = { type: 'STRING' };
             }
             params.properties = props;
             try {
@@ -235,25 +701,25 @@ export function buildGeminiToolsFromBridge(defs) {
             // - input/instructions/text: historical aliases containing patch text
             if (!Object.prototype.hasOwnProperty.call(props, 'patch')) {
                 props.patch = {
-                    type: 'string',
+                    type: 'STRING',
                     description: 'Patch text (*** Begin Patch / *** End Patch or GNU unified diff).'
                 };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'input')) {
                 props.input = {
-                    type: 'string',
+                    type: 'STRING',
                     description: 'Alias of patch (patch text). Prefer patch.'
                 };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'instructions')) {
                 props.instructions = {
-                    type: 'string',
+                    type: 'STRING',
                     description: 'Alias of patch (patch text). Prefer patch.'
                 };
             }
             if (!Object.prototype.hasOwnProperty.call(props, 'text')) {
                 props.text = {
-                    type: 'string',
+                    type: 'STRING',
                     description: 'Alias of patch (patch text). Prefer patch.'
                 };
             }
@@ -269,6 +735,9 @@ export function buildGeminiToolsFromBridge(defs) {
         return params;
     };
     const rewriteDescription = (name, description) => {
+        if (mode !== 'antigravity') {
+            return description;
+        }
         const lowered = String(name || '').trim().toLowerCase();
         if (lowered === 'apply_patch') {
             return ('Edit files by providing patch text in `patch` (string). ' +
@@ -301,16 +770,19 @@ export function buildGeminiToolsFromBridge(defs) {
             : typeof def.description === 'string'
                 ? def.description
                 : undefined;
-        const parameters = applyFixups(name, cloneParameters(fnNode?.parameters ?? def.parameters ?? { type: 'object', properties: {} }));
-        tools.push({
-            functionDeclarations: [
-                {
-                    name,
-                    description: rewriteDescription(name, description),
-                    parameters
-                }
-            ]
+        const parameters = applyFixups(name, cloneParameters(fnNode?.parameters ?? def.parameters ?? { type: 'object', properties: {} }, mode));
+        functionDeclarations.push({
+            name,
+            description: rewriteDescription(name, description),
+            parameters
         });
     });
-    return tools.length ? tools : undefined;
+    if (!functionDeclarations.length) {
+        return undefined;
+    }
+    return [
+        {
+            functionDeclarations
+        }
+    ];
 }