@jsonstudio/llms 0.6.1164 → 0.6.1354

package/dist/conversion/hub/operation-table/semantic-mappers/gemini-mapper.js

@@ -2,8 +2,9 @@ import { isJsonObject, jsonClone } from '../../types/json.js';
 import { buildOpenAIChatFromGeminiRequest } from '../../../codecs/gemini-openai-codec.js';
 import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../../shared/metadata-passthrough.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../../../shared/tool-mapping.js';
-import { prepareGeminiToolsForBridge, buildGeminiToolsFromBridge } from '../../../shared/gemini-tool-utils.js';
+import { prepareGeminiToolsForBridge, buildGeminiToolsFromBridge, sanitizeGeminiFunctionName } from '../../../shared/gemini-tool-utils.js';
 import { ensureProtocolState, getProtocolState } from '../../../shared/protocol-state.js';
+import { sanitizeReasoningTaggedText } from '../../../shared/reasoning-utils.js';
 import { applyClaudeThinkingToolSchemaCompat } from '../../../compat/actions/claude-thinking-tools.js';
 const GENERATION_CONFIG_KEYS = [
     { source: 'temperature', target: 'temperature' },
@@ -16,7 +17,21 @@ const GENERATION_CONFIG_KEYS = [
 ];
 const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 const PASSTHROUGH_PARAMETERS = ['tool_choice'];
-const DUMMY_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+// Align with ../gcli2api/src/converter/gemini_fix.py (mode="antigravity"): the systemInstruction prefix is a single
+// text segment wrapped in an [ignore] directive, then any user-provided system parts follow as-is.
+const ANTIGRAVITY_SYSTEM_INSTRUCTION = 'Please ignore the following [ignore]You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.**Absolute paths only****Proactiveness**[/ignore]';
+const ANTIGRAVITY_DEFAULT_SAFETY_SETTINGS = [
+    { category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_NONE' },
+    { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' },
+    { category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_NONE' },
+    { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_NONE' },
+    { category: 'HARM_CATEGORY_CIVIC_INTEGRITY', threshold: 'BLOCK_NONE' },
+    { category: 'HARM_CATEGORY_IMAGE_HATE', threshold: 'BLOCK_NONE' },
+    { category: 'HARM_CATEGORY_IMAGE_DANGEROUS_CONTENT', threshold: 'BLOCK_NONE' },
+    { category: 'HARM_CATEGORY_IMAGE_HARASSMENT', threshold: 'BLOCK_NONE' },
+    { category: 'HARM_CATEGORY_IMAGE_SEXUALLY_EXPLICIT', threshold: 'BLOCK_NONE' },
+    { category: 'HARM_CATEGORY_JAILBREAK', threshold: 'BLOCK_NONE' }
+];
 function coerceThoughtSignature(value) {
     if (typeof value === 'string' && value.trim().length) {
         return value.trim();
@@ -199,16 +214,19 @@ function selectAntigravityClaudeThinkingMessages(messages) {
     }
     return [messages[lastUserIndex]];
 }
-function buildFunctionResponseEntry(output) {
+function buildFunctionResponseEntry(output, options) {
     const parsedPayload = safeParseJson(output.content);
     const normalizedPayload = ensureFunctionResponsePayload(cloneAsJsonValue(parsedPayload));
+    const includeCallId = options?.includeCallId === true;
     const part = {
         functionResponse: {
             name: output.name || 'tool',
-            id: output.tool_call_id,
             response: normalizedPayload
         }
     };
+    if (includeCallId) {
+        part.functionResponse.id = output.tool_call_id;
+    }
     return { role: 'user', parts: [part] };
 }
 function collectSystemSegments(systemInstruction) {
@@ -255,10 +273,10 @@ function collectParameters(payload) {
     }
     return Object.keys(params).length ? params : undefined;
 }
-function appendChatContentToGeminiParts(message, targetParts) {
+function appendChatContentToGeminiParts(message, targetParts, options) {
     const content = message.content;
     if (typeof content === 'string') {
-        const text = content.trim();
+        const text = (options?.stripReasoningTags ? sanitizeReasoningTaggedText(content) : content).trim();
         if (text.length) {
             targetParts.push({ text });
         }
@@ -272,22 +290,49 @@ function appendChatContentToGeminiParts(message, targetParts) {
         if (block == null)
             continue;
         if (typeof block === 'string') {
-            const text = block.trim();
+            const text = (options?.stripReasoningTags ? sanitizeReasoningTaggedText(block) : block).trim();
             if (text.length) {
                 targetParts.push({ text });
             }
             continue;
         }
         if (typeof block !== 'object') {
-            const text = String(block);
-            if (text.trim().length) {
-                targetParts.push({ text: text.trim() });
+            const raw = String(block);
+            const text = (options?.stripReasoningTags ? sanitizeReasoningTaggedText(raw) : raw).trim();
+            if (text.length) {
+                targetParts.push({ text });
             }
             continue;
         }
         const record = block;
         const rawType = record.type;
         const type = typeof rawType === 'string' ? rawType.toLowerCase() : '';
+        if (type === 'thinking' || type === 'reasoning' || type === 'redacted_thinking') {
+            const signature = typeof record.thoughtSignature === 'string'
+                ? String(record.thoughtSignature)
+                : typeof record.signature === 'string'
+                    ? String(record.signature)
+                    : typeof record.thought_signature === 'string'
+                        ? String(record.thought_signature)
+                        : '';
+            if (options?.dropUnsignedThinking && !signature.trim().length) {
+                continue;
+            }
+            const textValue = typeof record.text === 'string'
+                ? record.text
+                : typeof record.thinking === 'string'
+                    ? record.thinking
+                    : '';
+            const text = (options?.stripReasoningTags ? sanitizeReasoningTaggedText(textValue) : textValue).trim();
+            if (text.length) {
+                const part = { text };
+                if (signature.trim().length) {
+                    part.thoughtSignature = signature.trim();
+                }
+                targetParts.push(part);
+            }
+            continue;
+        }
         // Text-style blocks
         if (!type || type === 'text') {
             const textValue = typeof record.text === 'string'
@@ -295,7 +340,7 @@ function appendChatContentToGeminiParts(message, targetParts) {
                 : typeof record.content === 'string'
                     ? record.content
                     : '';
-            const text = textValue.trim();
+            const text = (options?.stripReasoningTags ? sanitizeReasoningTaggedText(textValue) : textValue).trim();
             if (text.length) {
                 targetParts.push({ text });
             }
@@ -376,21 +421,144 @@ function buildGeminiRequestFromChat(chat, metadata) {
     const isAnthropicEntry = entryEndpoint === '/v1/messages';
     const normalizedProviderId = typeof rawProviderId === 'string' ? rawProviderId.toLowerCase() : '';
     const providerIdPrefix = normalizedProviderId.split('.')[0];
+    const isAntigravityProvider = providerIdPrefix === 'antigravity';
     const isAntigravityClaudeThinking = providerIdPrefix === 'antigravity' &&
         typeof chat.parameters?.model === 'string' &&
         chat.parameters.model.includes('claude-sonnet-4-5-thinking');
-    // 保持对通用 gemini-cli 的保护（避免上游直接执行 functionCall），
-    // 但对于 antigravity.* 明确允许通过 Gemini functionCall 协议执行工具，
-    // 以便完整打通 tools → functionCall → functionResponse 链路。
-    const omitFunctionCallPartsForCli = providerIdPrefix === 'gemini-cli';
+    const keepReasoning = Boolean(chat.parameters?.keep_thinking) ||
+        Boolean(chat.parameters?.keep_reasoning);
+    const stripReasoningTags = isAntigravityProvider &&
+        typeof chat.parameters?.model === 'string' &&
+        chat.parameters.model.startsWith('claude-') &&
+        !keepReasoning;
+    // Cloud Code / Antigravity requires stable tool call IDs in context (maps to tool_use.id),
+    // while standard Gemini endpoints do not require (and may reject) extra id fields.
+    const includeToolCallIds = providerIdPrefix === 'antigravity';
+    // Function calling protocol:
+    // - Always include tool schemas for Gemini targets so the model can emit structured functionCall/functionResponse parts.
+    // - Antigravity additionally prefers stable tool call IDs in-context (handled via includeToolCallIds above).
+    const allowFunctionCallingProtocol = true;
+    const omitFunctionCallPartsForCli = false;
     const semanticsNode = readGeminiSemantics(chat);
     const systemTextBlocksFromSemantics = readSystemTextBlocksFromSemantics(chat);
     const bridgeDefs = chat.tools && chat.tools.length ? mapChatToolsToBridge(chat.tools) : undefined;
-    const toolSchemaKeys = bridgeDefs ? buildToolSchemaKeyMap(bridgeDefs) : new Map();
+    const geminiToolNameAliasMap = {};
+    const geminiToolNameToWireName = new Map();
+    const wireBridgeDefs = bridgeDefs && bridgeDefs.length
+        ? (() => {
+            const used = new Set();
+            const out = [];
+            for (const def of bridgeDefs) {
+                if (!def || typeof def !== 'object')
+                    continue;
+                const fnNode = def.function && typeof def.function === 'object'
+                    ? def.function
+                    : undefined;
+                const rawName = typeof fnNode?.name === 'string'
+                    ? fnNode.name
+                    : typeof def.name === 'string'
+                        ? String(def.name)
+                        : '';
+                const originalName = rawName.trim();
+                if (!originalName)
+                    continue;
+                const base = sanitizeGeminiFunctionName(originalName, { maxLen: 64 });
+                let wireName = base;
+                let suffix = 2;
+                while (used.has(wireName)) {
+                    const suffixText = `_${suffix++}`;
+                    const truncated = base.length + suffixText.length > 64 ? base.slice(0, Math.max(1, 64 - suffixText.length)) : base;
+                    wireName = `${truncated}${suffixText}`;
+                }
+                used.add(wireName);
+                geminiToolNameToWireName.set(originalName, wireName);
+                if (wireName !== originalName) {
+                    geminiToolNameAliasMap[wireName] = originalName;
+                }
+                const cloned = jsonClone(def);
+                if (cloned.function && typeof cloned.function === 'object') {
+                    cloned.function.name = wireName;
+                }
+                else if (typeof cloned.name === 'string') {
+                    cloned.name = wireName;
+                }
+                out.push(cloned);
+            }
+            return out.length ? out : undefined;
+        })()
+        : undefined;
+    if (Object.keys(geminiToolNameAliasMap).length) {
+        // Persist alias map on adapterContext as an internal-only carrier for response mapping.
+        // Some hub snapshots/stages do not retain chat.semantics, but AdapterContext reliably flows
+        // through request→response conversion.
+        try {
+            if (adapterContext && typeof adapterContext === 'object') {
+                adapterContext.geminiToolNameAliasMap = jsonClone(geminiToolNameAliasMap);
+            }
+        }
+        catch {
+            // best-effort
+        }
+        if (!chat.semantics || typeof chat.semantics !== 'object') {
+            chat.semantics = {};
+        }
+        if (!chat.semantics.tools || !isJsonObject(chat.semantics.tools)) {
+            chat.semantics.tools = {};
+        }
+        const toolsNode = chat.semantics.tools;
+        const existing = toolsNode.toolNameAliasMap;
+        const merged = {
+            ...(existing && isJsonObject(existing) ? existing : {}),
+            ...geminiToolNameAliasMap
+        };
+        toolsNode.toolNameAliasMap = merged;
+    }
+    const effectiveBridgeDefs = wireBridgeDefs ?? bridgeDefs;
+    const toolSchemaKeys = effectiveBridgeDefs ? buildToolSchemaKeyMap(effectiveBridgeDefs) : new Map();
+    const declaredToolNames = new Set();
+    if (effectiveBridgeDefs) {
+        for (const def of effectiveBridgeDefs) {
+            const fnNode = def && typeof def === 'object' && def.function && typeof def.function === 'object'
+                ? def.function
+                : undefined;
+            const name = typeof fnNode?.name === 'string'
+                ? fnNode.name
+                : typeof def?.name === 'string'
+                    ? String(def.name)
+                    : '';
+            if (name && name.trim()) {
+                declaredToolNames.add(name.trim());
+            }
+        }
+    }
+    const normalizeToolName = (raw) => {
+        if (typeof raw !== 'string')
+            return undefined;
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return undefined;
+        const lowered = trimmed.toLowerCase();
+        // Historical alias: some Codex / Gemini logs use "execute_command" while our canonical tool is "exec_command".
+        if (lowered === 'execute_command') {
+            const wire = geminiToolNameToWireName.get('exec_command');
+            if (wire && declaredToolNames.has(wire)) {
+                return wire;
+            }
+        }
+        const mapped = geminiToolNameToWireName.get(trimmed);
+        if (mapped && declaredToolNames.has(mapped)) {
+            return mapped;
+        }
+        if (declaredToolNames.has(trimmed)) {
+            return trimmed;
+        }
+        return trimmed;
+    };
     const sourceMessages = chat.messages;
     // 收集当前 ChatEnvelope 中 assistant/tool_calls 的 id，用于过滤孤立的 tool_result：
     // 只有在本轮对话中存在对应 tool_call 的 tool_result 才允许映射为 Gemini functionResponse。
     const assistantToolCallIds = new Set();
+    const assistantToolCallNameById = new Map();
     for (const msg of sourceMessages) {
         if (!msg || typeof msg !== 'object')
             continue;
@@ -403,6 +571,11 @@ function buildGeminiRequestFromChat(chat, metadata) {
             const id = typeof tc.id === 'string' ? tc.id.trim() : '';
             if (id) {
                 assistantToolCallIds.add(id);
+                const rawName = tc?.function?.name;
+                const normalizedName = normalizeToolName(rawName);
+                if (normalizedName && declaredToolNames.has(normalizedName)) {
+                    assistantToolCallNameById.set(id, normalizedName);
+                }
             }
         }
     }
@@ -412,10 +585,31 @@ function buildGeminiRequestFromChat(chat, metadata) {
         if (message.role === 'system')
             continue;
         if (message.role === 'tool') {
-            const toolOutput = convertToolMessageToOutput(message, assistantToolCallIds);
-            if (toolOutput) {
-                contents.push(buildFunctionResponseEntry(toolOutput));
-                emittedToolOutputs.add(toolOutput.tool_call_id);
+            if (allowFunctionCallingProtocol) {
+                const toolOutput = convertToolMessageToOutput(message, assistantToolCallIds);
+                if (toolOutput) {
+                    const resolvedName = normalizeToolName(toolOutput.name) ?? assistantToolCallNameById.get(toolOutput.tool_call_id);
+                    if (resolvedName && declaredToolNames.has(resolvedName)) {
+                        toolOutput.name = resolvedName;
+                        contents.push(buildFunctionResponseEntry(toolOutput, { includeCallId: includeToolCallIds }));
+                        emittedToolOutputs.add(toolOutput.tool_call_id);
+                    }
+                    else {
+                        const contentText = normalizeToolContent(message.content);
+                        const name = typeof (toolOutput.name || '') === 'string' && String(toolOutput.name).trim().length
+                            ? String(toolOutput.name).trim()
+                            : 'unknown';
+                        contents.push({ role: 'user', parts: [{ text: `[tool:${name}] ${contentText}` }] });
+                    }
+                }
+            }
+            else {
+                const name = typeof message.name === 'string' ? String(message.name).trim() : 'tool';
+                const contentText = normalizeToolContent(message.content);
+                contents.push({
+                    role: 'user',
+                    parts: [{ text: `[tool:${name}] ${contentText}` }]
+                });
             }
             continue;
         }
@@ -423,7 +617,10 @@ function buildGeminiRequestFromChat(chat, metadata) {
             role: mapChatRoleToGemini(message.role),
             parts: []
         };
-        appendChatContentToGeminiParts(message, entry.parts);
+        appendChatContentToGeminiParts(message, entry.parts, {
+            stripReasoningTags,
+            dropUnsignedThinking: isAntigravityClaudeThinking
+        });
         const toolCalls = Array.isArray(message.tool_calls)
             ? message.tool_calls
             : [];
@@ -434,9 +631,29 @@ function buildGeminiRequestFromChat(chat, metadata) {
                 continue;
             }
             const fn = tc.function || {};
-            const name = typeof fn.name === 'string' ? fn.name : undefined;
+            const nameRaw = fn.name;
+            const name = normalizeToolName(nameRaw);
             if (!name)
                 continue;
+            if (!declaredToolNames.has(name)) {
+                // Keep a textual trace so history remains intelligible, but do not emit an undeclared functionCall
+                // (Gemini / Antigravity backends may reject or behave unpredictably when tool calls do not match schemas).
+                let argsText = '';
+                if (typeof fn.arguments === 'string') {
+                    argsText = fn.arguments.trim();
+                }
+                else if (fn.arguments !== undefined) {
+                    try {
+                        argsText = JSON.stringify(fn.arguments);
+                    }
+                    catch {
+                        argsText = String(fn.arguments);
+                    }
+                }
+                const text = argsText ? `[tool_call_ignored:${String(nameRaw)}] ${argsText}` : `[tool_call_ignored:${String(nameRaw)}]`;
+                entry.parts.push({ text });
+                continue;
+            }
             let argsStruct;
             if (typeof fn.arguments === 'string') {
                 try {
@@ -458,12 +675,13 @@ function buildGeminiRequestFromChat(chat, metadata) {
             }
             const functionCall = { name, args: argsJson };
             const part = { functionCall };
-            if (typeof tc.id === 'string') {
-                part.functionCall.id = tc.id;
+            if (includeToolCallIds && typeof tc.id === 'string' && tc.id.trim().length) {
+                part.functionCall.id = String(tc.id).trim();
             }
-            const thoughtSignature = extractThoughtSignatureFromToolCall(tc) ?? DUMMY_THOUGHT_SIGNATURE;
-            if (thoughtSignature) {
-                part.thoughtSignature = thoughtSignature;
+            // gcli2api alignment: antigravity functionCall parts always include a thoughtSignature
+            // (Cloud Code Assist expects it even when no real signature exists).
+            if (isAntigravityProvider && !part.thoughtSignature) {
+                part.thoughtSignature = 'skip_thought_signature_validator';
             }
             entry.parts.push(part);
         }
@@ -472,38 +690,101 @@ function buildGeminiRequestFromChat(chat, metadata) {
         }
     }
     const toolOutputMap = new Map();
-    if (Array.isArray(chat.toolOutputs)) {
-        for (const entry of chat.toolOutputs) {
-            if (entry && typeof entry.tool_call_id === 'string' && entry.tool_call_id.trim().length) {
-                toolOutputMap.set(entry.tool_call_id.trim(), entry);
+    if (allowFunctionCallingProtocol) {
+        if (Array.isArray(chat.toolOutputs)) {
+            for (const entry of chat.toolOutputs) {
+                if (entry && typeof entry.tool_call_id === 'string' && entry.tool_call_id.trim().length) {
+                    toolOutputMap.set(entry.tool_call_id.trim(), entry);
+                }
             }
         }
-    }
-    if (toolOutputMap.size === 0) {
-        const syntheticOutputs = synthesizeToolOutputsFromMessages(chat.messages);
-        for (const output of syntheticOutputs) {
-            toolOutputMap.set(output.tool_call_id, output);
+        if (toolOutputMap.size === 0) {
+            const syntheticOutputs = synthesizeToolOutputsFromMessages(chat.messages);
+            for (const output of syntheticOutputs) {
+                toolOutputMap.set(output.tool_call_id, output);
+            }
         }
-    }
-    for (const output of toolOutputMap.values()) {
-        if (emittedToolOutputs.has(output.tool_call_id)) {
-            continue;
+        for (const output of toolOutputMap.values()) {
+            if (emittedToolOutputs.has(output.tool_call_id)) {
+                continue;
+            }
+            const resolvedName = normalizeToolName(output.name) ?? assistantToolCallNameById.get(output.tool_call_id);
+            if (resolvedName && declaredToolNames.has(resolvedName)) {
+                output.name = resolvedName;
+                contents.push(buildFunctionResponseEntry(output, { includeCallId: includeToolCallIds }));
+                emittedToolOutputs.add(output.tool_call_id);
+            }
         }
-        contents.push(buildFunctionResponseEntry(output));
-        emittedToolOutputs.add(output.tool_call_id);
     }
     const request = {
         model: chat.parameters?.model || 'models/gemini-pro',
         contents
     };
+    const cleanGeminiContents = (raw) => {
+        if (!Array.isArray(raw))
+            return [];
+        const out = [];
+        for (const entry of raw) {
+            if (!isJsonObject(entry))
+                continue;
+            const partsRaw = entry.parts;
+            if (!Array.isArray(partsRaw)) {
+                out.push(entry);
+                continue;
+            }
+            const nextParts = [];
+            for (const part of partsRaw) {
+                if (!isJsonObject(part))
+                    continue;
+                const hasValidValue = Object.entries(part).some(([key, value]) => {
+                    if (key === 'thought')
+                        return false;
+                    if (value === null || value === undefined)
+                        return false;
+                    if (typeof value === 'string')
+                        return value.length > 0;
+                    if (Array.isArray(value))
+                        return value.length > 0;
+                    if (typeof value === 'object')
+                        return Object.keys(value).length > 0;
+                    return true;
+                });
+                if (!hasValidValue)
+                    continue;
+                const cloned = jsonClone(part);
+                if (Object.prototype.hasOwnProperty.call(cloned, 'text')) {
+                    const textValue = cloned.text;
+                    if (Array.isArray(textValue)) {
+                        cloned.text = textValue.map((t) => String(t ?? '')).filter((t) => t).join(' ');
+                    }
+                    else if (typeof textValue === 'string') {
+                        cloned.text = textValue.replace(/\s+$/u, '');
+                    }
+                    else if (textValue !== undefined) {
+                        cloned.text = String(textValue);
+                    }
+                }
+                nextParts.push(cloned);
+            }
+            if (!nextParts.length)
+                continue;
+            const clonedEntry = jsonClone(entry);
+            clonedEntry.parts = nextParts;
+            out.push(clonedEntry);
+        }
+        return out;
+    };
+    // gcli2api normalize_gemini_request applies a strict parts cleanup pass.
+    // We do this early to reduce Antigravity/Gemini schema drift and avoid sending empty parts.
+    request.contents = cleanGeminiContents(request.contents);
     const geminiState = getProtocolState(metadata, 'gemini');
-    if (semanticsNode?.systemInstruction !== undefined) {
+    if (!isAntigravityProvider && semanticsNode?.systemInstruction !== undefined) {
         request.systemInstruction = jsonClone(semanticsNode.systemInstruction);
     }
-    else if (geminiState?.systemInstruction !== undefined) {
+    else if (!isAntigravityProvider && geminiState?.systemInstruction !== undefined) {
         request.systemInstruction = jsonClone(geminiState.systemInstruction);
     }
-    else {
+    else if (!isAntigravityProvider) {
         const fallbackSystemInstructions = systemTextBlocksFromSemantics;
         if (fallbackSystemInstructions && fallbackSystemInstructions.length) {
             const sysBlocks = fallbackSystemInstructions
@@ -514,8 +795,40 @@ function buildGeminiRequestFromChat(chat, metadata) {
             }
         }
     }
-    if (chat.tools && chat.tools.length) {
-        const geminiTools = buildGeminiToolsFromBridge(bridgeDefs);
+    if (isAntigravityProvider) {
+        const extraSegments = [];
+        const seen = new Set();
+        const pushSegment = (value) => {
+            const trimmed = typeof value === 'string' ? value.trim() : '';
+            if (!trimmed)
+                return;
+            if (seen.has(trimmed))
+                return;
+            seen.add(trimmed);
+            extraSegments.push(trimmed);
+        };
+        for (const seg of collectSystemSegments(semanticsNode?.systemInstruction)) {
+            pushSegment(seg);
+        }
+        for (const seg of collectSystemSegments(geminiState?.systemInstruction)) {
+            pushSegment(seg);
+        }
+        for (const seg of systemTextBlocksFromSemantics || []) {
+            if (typeof seg === 'string') {
+                pushSegment(seg);
+            }
+        }
+        // gcli2api antigravity normalization:
+        // - systemInstruction is a plain { parts: [...] } object (no role field)
+        // - the fixed Antigravity prefix is always the first part
+        request.systemInstruction = {
+            parts: [{ text: ANTIGRAVITY_SYSTEM_INSTRUCTION }, ...extraSegments.map((text) => ({ text }))]
+        };
+    }
+    if (allowFunctionCallingProtocol && chat.tools && chat.tools.length) {
+        const geminiTools = buildGeminiToolsFromBridge(effectiveBridgeDefs, {
+            mode: isAntigravityProvider ? 'antigravity' : 'default'
+        });
         if (geminiTools) {
             request.tools = geminiTools;
         }
@@ -532,9 +845,170 @@ function buildGeminiRequestFromChat(chat, metadata) {
     if (Object.keys(generationConfig).length) {
         request.generationConfig = generationConfig;
     }
-    if (semanticsNode?.safetySettings !== undefined) {
+    if (!isAntigravityProvider && semanticsNode?.safetySettings !== undefined) {
         request.safetySettings = jsonClone(semanticsNode.safetySettings);
     }
+    else if (isAntigravityProvider) {
+        // gcli2api alignment: Antigravity always sends a permissive safetySettings set.
+        request.safetySettings = jsonClone(ANTIGRAVITY_DEFAULT_SAFETY_SETTINGS);
+    }
+    if (isAntigravityProvider && isJsonObject(request.generationConfig)) {
+        // gcli2api alignment: when generationConfig is present, clamp the key parameters.
+        request.generationConfig.maxOutputTokens = 64000;
+        request.generationConfig.topK = 64;
+        // gcli2api alignment: Antigravity strips unsupported penalty fields (no-op for OpenAI-derived params,
+        // but it matters when users send direct Gemini generationConfig).
+        delete request.generationConfig.presencePenalty;
+        delete request.generationConfig.frequencyPenalty;
+    }
+    if (isAntigravityProvider && typeof request.model === 'string') {
+        // gcli2api antigravity: normalize model name variants for Claude routed via Antigravity.
+        const original = request.model;
+        const lowered = original.toLowerCase();
+        const withoutThinking = original.replace(/-thinking/giu, '');
+        let mapped = withoutThinking;
+        if (lowered.includes('opus')) {
+            mapped = 'claude-opus-4-5-thinking';
+        }
+        else if (lowered.includes('sonnet') || lowered.includes('haiku')) {
+            mapped = 'claude-sonnet-4-5-thinking';
+        }
+        else if (lowered.includes('claude')) {
+            mapped = 'claude-sonnet-4-5-thinking';
+        }
+        request.model = mapped;
+        // gcli2api antigravity: image generation request normalization.
+        // When model name indicates image generation, use the fixed base model and a minimal generationConfig,
+        // and drop systemInstruction/tools/toolConfig (Antigravity image endpoint is strict about schema).
+        const mappedLower = String(request.model || '').toLowerCase();
+        const isImageModel = mappedLower.includes('image');
+        if (isImageModel) {
+            const aspectSuffixes = [
+                ['-21x9', '21:9'],
+                ['-16x9', '16:9'],
+                ['-9x16', '9:16'],
+                ['-4x3', '4:3'],
+                ['-3x4', '3:4'],
+                ['-1x1', '1:1']
+            ];
+            const imageSize = mappedLower.includes('-4k') ? '4K' : mappedLower.includes('-2k') ? '2K' : undefined;
+            const aspectRatio = aspectSuffixes.find(([suffix]) => mappedLower.includes(suffix))?.[1];
+            const imageConfig = {};
+            if (aspectRatio)
+                imageConfig.aspectRatio = aspectRatio;
+            if (imageSize)
+                imageConfig.imageSize = imageSize;
+            request.model = 'gemini-3-pro-image';
+            request.generationConfig = {
+                candidateCount: 1,
+                imageConfig
+            };
+            delete request.systemInstruction;
+            delete request.tools;
+            delete request.toolConfig;
+        }
+        // gcli2api antigravity: default thinkingConfig for "thinking models" (pro/think).
+        // This matches normalize_gemini_request(mode="antigravity") where is_thinking_model(model) => true.
+        const isThinkingModel = !isImageModel && (lowered.includes('think') || lowered.includes('pro'));
+        if (isThinkingModel && (!request.generationConfig || !isJsonObject(request.generationConfig))) {
+            request.generationConfig = {};
+        }
+        const generationConfig = request.generationConfig;
+        if (isThinkingModel && isJsonObject(generationConfig)) {
+            const gc = generationConfig;
+            const thinkingConfig = isJsonObject(gc.thinkingConfig) ? gc.thinkingConfig : {};
+            const existingBudget = typeof thinkingConfig.thinkingBudget === 'number' ? thinkingConfig.thinkingBudget : undefined;
+            const shouldApply = existingBudget !== undefined ? existingBudget !== 0 : true;
+            if (shouldApply) {
+                if (typeof thinkingConfig.thinkingBudget !== 'number') {
+                    thinkingConfig.thinkingBudget = 1024;
+                }
+                if (Object.prototype.hasOwnProperty.call(thinkingConfig, 'thinkingLevel')) {
+                    delete thinkingConfig.thinkingLevel;
+                }
+                thinkingConfig.includeThoughts = true;
+                // For Claude routed via Antigravity:
+                // - when tool calls exist, gcli2api drops thinkingConfig to avoid upstream failures
+                // - otherwise, ensure the last model message begins with a thinking block signature
+                const isClaude = lowered.includes('claude');
+                if (isClaude) {
+                    const contentsArray = Array.isArray(request.contents) ? request.contents : [];
+                    const hasToolCalls = contentsArray.some((content) => {
+                        if (!isJsonObject(content))
+                            return false;
+                        const parts = content.parts;
+                        if (!Array.isArray(parts))
+                            return false;
+                        return parts.some((part) => isJsonObject(part) &&
+                            ('functionCall' in part || 'function_call' in part));
+                    });
+                    if (hasToolCalls) {
+                        delete gc.thinkingConfig;
+                    }
+                    else {
+                        for (let idx = contentsArray.length - 1; idx >= 0; idx--) {
+                            const content = contentsArray[idx];
+                            if (!isJsonObject(content))
+                                continue;
+                            if (content.role !== 'model')
+                                continue;
+                            const parts = content.parts;
+                            if (!Array.isArray(parts))
+                                continue;
+                            const first = parts[0];
+                            const firstIsThinking = isJsonObject(first) && ('thought' in first || 'thoughtSignature' in first);
+                            if (!firstIsThinking) {
+                                content.parts = [
+                                    { text: '...', thoughtSignature: 'skip_thought_signature_validator' },
+                                    ...parts
+                                ];
+                            }
+                            break;
+                        }
+                        gc.thinkingConfig = thinkingConfig;
+                    }
+                }
+                else {
+                    gc.thinkingConfig = thinkingConfig;
+                }
+            }
+        }
+        // gcli2api alignment: when generationConfig exists (and Antigravity sets thinkingConfig),
+        // clamp top-level parameters.
+        if (!isImageModel && isJsonObject(request.generationConfig)) {
+            request.generationConfig.maxOutputTokens = 64000;
+            request.generationConfig.topK = 64;
+            delete request.generationConfig.presencePenalty;
+            delete request.generationConfig.frequencyPenalty;
+        }
+    }
+    // Map OpenAI-style tool_choice to Gemini toolConfig (functionCallingConfig).
+    // This is required to reliably disable tool calling while still declaring tools
+    // (e.g. servertool followups that must preserve tool list for session continuity).
+    if (request.toolConfig === undefined && chat.parameters && 'tool_choice' in chat.parameters) {
+        const choice = chat.parameters.tool_choice;
+        if (typeof choice === 'string') {
+            const lowered = choice.trim().toLowerCase();
+            if (lowered === 'none') {
+                request.toolConfig = { functionCallingConfig: { mode: 'NONE' } };
+            }
+            else if (lowered === 'required') {
+                request.toolConfig = { functionCallingConfig: { mode: 'ANY' } };
+            }
+        }
+        else if (choice && typeof choice === 'object' && !Array.isArray(choice)) {
+            const type = typeof choice.type === 'string' ? String(choice.type).trim().toLowerCase() : '';
+            const name = type === 'function' && choice.function && typeof choice.function.name === 'string'
+                ? String(choice.function.name).trim()
+                : '';
+            const wireName = name ? normalizeToolName(name) : undefined;
+            if (wireName && declaredToolNames.has(wireName)) {
+                request.toolConfig = {
+                    functionCallingConfig: { mode: 'ANY', allowedFunctionNames: [wireName] }
+                };
+            }
+        }
+    }
     if (chat.parameters?.tool_config && isJsonObject(chat.parameters.tool_config)) {
         request.toolConfig = jsonClone(chat.parameters.tool_config);
     }
@@ -556,7 +1030,7 @@ function buildGeminiRequestFromChat(chat, metadata) {
         request.metadata = request.metadata ?? {};
         request.metadata.__rcc_stream = chat.parameters.stream;
     }
-    if ((chat.metadata?.toolsFieldPresent || hasExplicitEmptyToolsSemantics(chat)) &&
+    if (hasExplicitEmptyToolsSemantics(chat) &&
         (!Array.isArray(chat.tools) || chat.tools.length === 0)) {
         request.metadata = request.metadata ?? {};
         request.metadata.__rcc_tools_field_present = '1';
@@ -785,7 +1259,6 @@ export class GeminiSemanticMapper {
                 }
             }
             if (toolsFieldPresent) {
-                metadata.toolsFieldPresent = true;
                 explicitEmptyTools = true;
             }
             providerMetadata = cloned;