@truefoundry/ai-gateway-sdk 0.0.0-stage → 0.0.1

package/dist/providers/google/chatComplete.js

@@ -0,0 +1,935 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * But needs some custom changes for TFY
+ * 1. Change the prefix of id to tfy-
+ * 2. Remove stream_options from the request body
+ * 3. Add reasoning_effort translation
+ * ================================
+ */
+import { ValidationError } from '../../errors.js';
+import { GOOGLE } from '../../globals.js';
+import { MESSAGE_ROLES, SYSTEM_MESSAGE_ROLES, } from '../../types/requestBody.js';
+import { calculateBudgetTokens } from '../../utils/reasoningUtils.js';
+import { VERTEX_MODALITY } from '../google-vertex-ai/types.js';
+import { budgetTokensToThinkingLevel, buildGeminiThinkingConfig, getDummyThoughtSignature, getMimeType, googleTools, mapOpenAIDetailToMediaResolution, recursivelyDeleteUnsupportedParameters, supportsThinking, supportsThinkingLevel, transformComputerUseToolFromOpenAI, transformGeminiToolParameters, transformGoogleTools, transformInputAudioPart, transformVertexLogprobs, } from '../google-vertex-ai/utils.js';
+import { generateErrorResponse, generateInvalidProviderResponseError, transformFinishReason } from '../utils.js';
+import { decodeUrlIfEncoded, parseFileData } from '../utils/fileUtils.js';
+import { parseToolArgumentsByContext } from '../utils/toolUtils.js';
+// Separator used to embed thoughtSignature into tool call IDs for clients that strip
+// provider_specific_fields (e.g. LangChain). Format: call_<uuid>__thought__<sig>
+export const THOUGHT_SIGNATURE_SEPARATOR = '__thought__';
+export function encodeToolCallIdWithSignature(toolCallId, thoughtSignature) {
+    return `${toolCallId}${THOUGHT_SIGNATURE_SEPARATOR}${thoughtSignature}`;
+}
+// Extract thoughtSignature from a tool call object.
+// Checks provider_specific_fields (both on the call and on function), falls back to legacy
+// function.thought_signature, and finally tries to decode from the tool call ID.
+// If model is a Gemini 3+ model and still no signature is found, injects a dummy placeholder
+// (Google-recommended: base64("skip_thought_signature_validator")) so the Gemini 3 validator
+// does not reject multi-turn requests where the prior turn had no real signature.
+export function getThoughtSignatureFromToolCall(toolCall, model) {
+    // Check tool call level provider_specific_fields
+    if (toolCall.provider_specific_fields?.thought_signature) {
+        return toolCall.provider_specific_fields.thought_signature;
+    }
+    // Check function level provider_specific_fields
+    if (toolCall.function.provider_specific_fields?.thought_signature) {
+        return toolCall.function.provider_specific_fields.thought_signature;
+    }
+    // Legacy: function.thought_signature (previous gateway format)
+    if (toolCall.function.thought_signature) {
+        return toolCall.function.thought_signature;
+    }
+    // Fallback: decode from embedded tool call ID
+    if (toolCall.id?.includes(THOUGHT_SIGNATURE_SEPARATOR)) {
+        return toolCall.id.slice(toolCall.id.indexOf(THOUGHT_SIGNATURE_SEPARATOR) + THOUGHT_SIGNATURE_SEPARATOR.length);
+    }
+    // Gemini 3+ requires a thoughtSignature on every functionCall part in multi-turn requests,
+    // even when the previous turn had no real signature. Inject Google's recommended placeholder.
+    // The `model.includes('gemini')` guard ensures non-Gemini models are never affected;
+    // supportsThinkingLevel handles the Gemini 2.5 / 2.0-flash-thinking exclusion.
+    if (model && model.includes('gemini') && supportsThinkingLevel(model)) {
+        return getDummyThoughtSignature();
+    }
+    return undefined;
+}
+export const transformGenerationConfig = (params) => {
+    const generationConfig = {};
+    if (params['temperature'] != null && params['temperature'] != undefined) {
+        generationConfig['temperature'] = params['temperature'];
+    }
+    if (params['top_p'] != null && params['top_p'] != undefined) {
+        generationConfig['topP'] = params['top_p'];
+    }
+    if (params['top_k'] != null && params['top_k'] != undefined) {
+        generationConfig['topK'] = params['top_k'];
+    }
+    if (params['max_tokens'] != null && params['max_tokens'] != undefined) {
+        generationConfig['maxOutputTokens'] = params['max_tokens'];
+    }
+    if (params['max_completion_tokens'] != null && params['max_completion_tokens'] != undefined) {
+        generationConfig['maxOutputTokens'] = params['max_completion_tokens'];
+    }
+    if (params['stop']) {
+        generationConfig['stopSequences'] = params['stop'];
+    }
+    if (params?.response_format?.type === 'json_object') {
+        generationConfig['responseMimeType'] = 'application/json';
+    }
+    if (params['logprobs']) {
+        generationConfig['responseLogprobs'] = params['logprobs'];
+    }
+    if (params['top_logprobs'] != null && params['top_logprobs'] != undefined) {
+        generationConfig['logprobs'] = params['top_logprobs']; // range 1-5, openai supports 1-20
+    }
+    if (params['seed'] != null && params['seed'] != undefined) {
+        generationConfig['seed'] = params['seed'];
+    }
+    if (params?.response_format?.type === 'json_schema') {
+        generationConfig['responseMimeType'] = 'application/json';
+        const schema = params?.response_format?.json_schema?.schema ?? params?.response_format?.json_schema;
+        recursivelyDeleteUnsupportedParameters(schema);
+        generationConfig['responseSchema'] = transformGeminiToolParameters(schema);
+    }
+    const model = params.model ?? '';
+    if (supportsThinking(model)) {
+        const thinkingLevelSupported = supportsThinkingLevel(model);
+        if (params?.thinking) {
+            const { budget_tokens, type } = params.thinking;
+            const enabled = type === 'enabled' && (budget_tokens === undefined || budget_tokens > 0);
+            if (thinkingLevelSupported) {
+                generationConfig['thinkingConfig'] = {
+                    ...(enabled && { thinkingLevel: budgetTokensToThinkingLevel(budget_tokens, model) }),
+                    includeThoughts: enabled,
+                };
+            }
+            else {
+                generationConfig['thinkingConfig'] = {
+                    thinkingBudget: budget_tokens,
+                    includeThoughts: enabled,
+                };
+            }
+        }
+        else if (params?.reasoning_effort) {
+            if (thinkingLevelSupported) {
+                generationConfig['thinkingConfig'] = buildGeminiThinkingConfig(params.reasoning_effort, model);
+            }
+            else {
+                const maxTokens = params.max_completion_tokens || params.max_tokens || 2048;
+                const budgetTokens = calculateBudgetTokens(maxTokens, params.reasoning_effort);
+                generationConfig['thinkingConfig'] = {
+                    thinkingBudget: budgetTokens,
+                    includeThoughts: params.reasoning_effort !== 'none',
+                };
+            }
+        }
+    }
+    if (params.modalities) {
+        generationConfig['responseModalities'] = params.modalities.map(modality => modality.toUpperCase());
+    }
+    // Gemini TTS: speechConfig must live inside generationConfig and is overwritten when any param sets generationConfig, so include it here
+    if (params.audio && typeof params.audio === 'object') {
+        const audioParam = params.audio;
+        if (audioParam.multiSpeakerVoiceConfig) {
+            generationConfig['speechConfig'] = {
+                multiSpeakerVoiceConfig: audioParam.multiSpeakerVoiceConfig,
+            };
+        }
+        else if (audioParam.voice) {
+            generationConfig['speechConfig'] = {
+                voiceConfig: {
+                    prebuiltVoiceConfig: {
+                        voiceName: audioParam.voice,
+                    },
+                },
+            };
+        }
+    }
+    return generationConfig;
+};
+// models for which systemInstruction is not supported
+export const SYSTEM_INSTRUCTION_DISABLED_MODELS = [
+    'gemini-1.0-pro',
+    'gemini-1.0-pro-001',
+    'gemini-1.0-pro-latest',
+    'gemini-1.0-pro-vision-latest',
+    'gemini-pro',
+    'gemini-pro-vision',
+];
+export const transformOpenAIRoleToGoogleRole = (role) => {
+    switch (role) {
+        case 'assistant':
+            return 'model';
+        case 'tool':
+            return 'user';
+        case 'developer':
+            return 'system';
+        default:
+            return role;
+    }
+};
+export const transformToolChoiceForGemini = (tool_choice) => {
+    if (typeof tool_choice === 'object' && tool_choice.type === 'function')
+        return 'ANY';
+    if (typeof tool_choice === 'string') {
+        switch (tool_choice) {
+            case 'auto':
+                return 'AUTO';
+            case 'none':
+                return 'NONE';
+            case 'required':
+                return 'ANY';
+        }
+    }
+    return undefined;
+};
+// TODOS: this configuration does not enforce the maximum token limit for the input parameter. If you want to enforce this, you might need to add a custom validation function or a max property to the ParameterConfig interface, and then use it in the input configuration. However, this might be complex because the token count is not a simple length check, but depends on the specific tokenization method used by the model.
+export const GoogleChatCompleteConfig = {
+    model: {
+        param: 'model',
+        required: true,
+        default: 'gemini-1.5-pro',
+    },
+    messages: [
+        {
+            param: 'contents',
+            default: '',
+            transform: (params) => {
+                let lastRole;
+                const messages = [];
+                params.messages?.forEach((message) => {
+                    // From gemini-1.5 onwards, systemInstruction is supported
+                    // Skipping system message and sending it in systemInstruction for gemini 1.5 models
+                    if (SYSTEM_MESSAGE_ROLES.includes(message.role) &&
+                        !SYSTEM_INSTRUCTION_DISABLED_MODELS.includes(params.model))
+                        return;
+                    const role = transformOpenAIRoleToGoogleRole(message.role);
+                    const parts = [];
+                    if (message.role === 'assistant') {
+                        const msg = message;
+                        // 1. Emit thinking parts first (for multi-turn signature reconstruction).
+                        // thinking_blocks carries per-block signatures needed to produce thoughtSignature.
+                        const thinkingBlocks = msg.thinking_blocks;
+                        if (thinkingBlocks?.length) {
+                            for (const block of thinkingBlocks) {
+                                if (block.type === 'thinking' && block.thinking !== undefined && block.signature) {
+                                    parts.push({
+                                        thought: true,
+                                        text: block.thinking,
+                                        thoughtSignature: block.signature,
+                                    });
+                                }
+                            }
+                        }
+                        // 2. Emit text content part.
+                        // Do NOT attach thoughtSignature here: `thought_signatures[0]` is the first
+                        // thinking-block signature (already on the thought part above), not a text-part
+                        // signature. Gemini only validates thoughtSignature on `thought: true` and
+                        // `functionCall` parts — plain text parts do not require it.
+                        if (typeof message.content === 'string' && message.content) {
+                            parts.push({ text: message.content });
+                        }
+                        else if (message.content && Array.isArray(message.content)) {
+                            message.content.forEach((c) => {
+                                if (c.type === 'text' && c.text) {
+                                    parts.push({ text: c.text });
+                                }
+                            });
+                        }
+                        // 3. Emit function call parts with thoughtSignature for multi-turn reconstruction.
+                        if (message.tool_calls) {
+                            message.tool_calls.forEach((tool_call) => {
+                                const thoughtSig = getThoughtSignatureFromToolCall(tool_call, params.model);
+                                parts.push({
+                                    functionCall: {
+                                        name: tool_call.function.name,
+                                        args: parseToolArgumentsByContext(tool_call.function.arguments, { model: params.model }),
+                                    },
+                                    ...(thoughtSig && { thoughtSignature: thoughtSig }),
+                                });
+                            });
+                        }
+                        // Guard: Gemini rejects turns with zero parts. If somehow all branches above
+                        // produced nothing (e.g. content="" with no tool_calls), emit a minimal empty-text
+                        // part rather than silently sending an invalid message that the API will reject.
+                        if (parts.length === 0) {
+                            parts.push({ text: '' });
+                        }
+                    }
+                    else if (message.role === 'tool') {
+                        let toolContent = '';
+                        if (typeof message.content === 'string') {
+                            toolContent = message.content;
+                        }
+                        else if (Array.isArray(message.content)) {
+                            // concatenate all text parts from the content array
+                            toolContent = message.content
+                                .filter((c) => c.type === 'text')
+                                .map((c) => c.text)
+                                .join('\n');
+                        }
+                        parts.push({
+                            functionResponse: {
+                                name: message.name ?? 'gateway-tool-filler-name',
+                                response: {
+                                    content: toolContent,
+                                },
+                            },
+                        });
+                    }
+                    else if (message.content && Array.isArray(message.content)) {
+                        message.content.forEach((c) => {
+                            if (c.type === 'text') {
+                                parts.push({
+                                    text: c.text,
+                                });
+                            }
+                            else if (c.type === 'input_audio') {
+                                parts.push(transformInputAudioPart(c));
+                            }
+                            else if (c.type === 'file') {
+                                // Handle file content type - translate to Gemini PartType format
+                                if (!c.file) {
+                                    return;
+                                }
+                                const fileId = c.file.file_id || c.file.file_url;
+                                const fileData = c.file.file_data;
+                                const mimeType = c.file.mime_type;
+                                // Determine file source
+                                const fileSource = fileId || fileData;
+                                if (!fileSource) {
+                                    throw new ValidationError('Unknown file type. Please pass in a file_id or file_data');
+                                }
+                                // Case A: Google Cloud Storage (GCS) URI
+                                if (typeof fileSource === 'string') {
+                                    const decodedFileSource = decodeUrlIfEncoded(fileSource);
+                                    if (decodedFileSource.includes('gs://')) {
+                                        const detectedMimeType = mimeType || getMimeType(decodedFileSource) || 'application/octet-stream';
+                                        parts.push({
+                                            fileData: {
+                                                mimeType: detectedMimeType,
+                                                fileUri: decodedFileSource,
+                                            },
+                                        });
+                                        return;
+                                    }
+                                }
+                                // Case B: HTTP/HTTPS URL
+                                if (typeof fileSource === 'string') {
+                                    const decodedFileSource = decodeUrlIfEncoded(fileSource);
+                                    if (decodedFileSource.includes('https://') || decodedFileSource.includes('http://')) {
+                                        const detectedMimeType = mimeType || getMimeType(decodedFileSource);
+                                        if (!detectedMimeType) {
+                                            throw new ValidationError(`Unable to determine mime type for file_id: ${decodedFileSource}, set this explicitly using file.mime_type`);
+                                        }
+                                        parts.push({
+                                            fileData: {
+                                                fileUri: decodedFileSource,
+                                                mimeType: detectedMimeType,
+                                            },
+                                        });
+                                        return;
+                                    }
+                                }
+                                // Case C: Base64 Data URI
+                                if (fileData) {
+                                    const { base64String, mimeType: parsedMimeType } = parseFileData(fileData);
+                                    const detectedMimeType = mimeType || parsedMimeType || 'application/octet-stream';
+                                    parts.push({
+                                        inlineData: {
+                                            mimeType: detectedMimeType,
+                                            data: base64String,
+                                        },
+                                    });
+                                    return;
+                                }
+                            }
+                            else if (c.type === 'image_url') {
+                                const { url, mime_type: passedMimeType, detail } = c.image_url || {};
+                                if (!url)
+                                    return;
+                                const mediaResolution = mapOpenAIDetailToMediaResolution(detail);
+                                if (url.startsWith('data:')) {
+                                    const [mimeTypeWithPrefix, base64Image] = url.split(';base64,');
+                                    const mimeType = mimeTypeWithPrefix.split(':')[1];
+                                    const part = {
+                                        inlineData: {
+                                            mimeType: mimeType,
+                                            data: base64Image,
+                                        },
+                                    };
+                                    // only add mediaResolution for base64 images if it's not null
+                                    if (mediaResolution !== null) {
+                                        part.mediaResolution = mediaResolution;
+                                    }
+                                    parts.push(part);
+                                }
+                                else {
+                                    const decodedUrl = decodeUrlIfEncoded(url);
+                                    if (decodedUrl.startsWith('gs://') ||
+                                        decodedUrl.startsWith('https://') ||
+                                        decodedUrl.startsWith('http://')) {
+                                        const part = {
+                                            fileData: {
+                                                mimeType: passedMimeType || getMimeType(decodedUrl) || 'image/jpeg',
+                                                fileUri: decodedUrl,
+                                            },
+                                        };
+                                        // only add mediaResolution for URL images if it's not null
+                                        if (mediaResolution !== null) {
+                                            part.mediaResolution = mediaResolution;
+                                        }
+                                        parts.push(part);
+                                    }
+                                    else {
+                                        // NOTE: This block is kept to maintain backward compatibility
+                                        // Earlier we were assuming that all images will be base64 with image/jpeg mimeType
+                                        const part = {
+                                            inlineData: {
+                                                mimeType: 'image/jpeg',
+                                                data: c.image_url?.url,
+                                            },
+                                        };
+                                        // only add mediaResolution for base64 images if it's not null
+                                        if (mediaResolution !== null) {
+                                            part.mediaResolution = mediaResolution;
+                                        }
+                                        parts.push(part);
+                                    }
+                                }
+                            }
+                        });
+                    }
+                    else if (typeof message.content === 'string') {
+                        parts.push({
+                            text: message.content,
+                        });
+                    }
+                    // @NOTE: This takes care of the "Please ensure that multiturn requests alternate between user and model."
+                    // error that occurs when we have multiple user messages in a row.
+                    const shouldCombineMessages = lastRole === role && !params.model?.includes('vision');
+                    if (shouldCombineMessages) {
+                        messages[messages.length - 1].parts.push(...parts);
+                    }
+                    else {
+                        messages.push({ role, parts });
+                    }
+                    lastRole = role;
+                });
+                return messages;
+            },
+        },
+        {
+            param: 'systemInstruction',
+            default: '',
+            transform: (params) => {
+                // systemInstruction is only supported from gemini 1.5 models
+                if (SYSTEM_INSTRUCTION_DISABLED_MODELS.includes(params.model))
+                    return;
+                const firstMessage = params.messages?.[0] || null;
+                if (!firstMessage)
+                    return;
+                if (SYSTEM_MESSAGE_ROLES.includes(firstMessage.role) && typeof firstMessage.content === 'string') {
+                    return {
+                        parts: [
+                            {
+                                text: firstMessage.content,
+                            },
+                        ],
+                        role: 'system',
+                    };
+                }
+                if (SYSTEM_MESSAGE_ROLES.includes(firstMessage.role) &&
+                    typeof firstMessage.content === 'object' &&
+                    firstMessage.content?.[0]?.text) {
+                    return {
+                        parts: [
+                            {
+                                text: firstMessage.content?.[0].text,
+                            },
+                        ],
+                        role: 'system',
+                    };
+                }
+                return;
+            },
+        },
+    ],
+    temperature: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    top_p: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    top_k: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    max_tokens: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    max_completion_tokens: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    stop: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    response_format: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    logprobs: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    top_logprobs: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    tools: {
+        param: 'tools',
+        default: '',
+        transform: (params) => {
+            const functionDeclarations = [];
+            const tools = [];
+            params.tools?.forEach(tool => {
+                if (tool.type === 'computer_use') {
+                    tools.push(transformComputerUseToolFromOpenAI(tool));
+                }
+                else if (tool.type === 'function') {
+                    // these are not supported by google
+                    recursivelyDeleteUnsupportedParameters(tool.function?.parameters);
+                    delete tool.function?.strict;
+                    if (googleTools.includes(tool.function.name)) {
+                        tools.push(...transformGoogleTools(tool));
+                    }
+                    else {
+                        if (tool.function?.parameters) {
+                            tool.function.parameters = transformGeminiToolParameters(tool.function.parameters);
+                        }
+                        functionDeclarations.push(tool.function);
+                    }
+                }
+            });
+            if (functionDeclarations.length) {
+                tools.push({ functionDeclarations });
+            }
+            return tools;
+        },
+    },
+    tool_choice: {
+        param: 'tool_config',
+        default: '',
+        transform: (params) => {
+            if (params.tool_choice) {
+                const allowedFunctionNames = [];
+                if (typeof params.tool_choice === 'object' && params.tool_choice.type === 'function') {
+                    allowedFunctionNames.push(params.tool_choice.function.name);
+                }
+                const toolConfig = {
+                    function_calling_config: {
+                        mode: transformToolChoiceForGemini(params.tool_choice),
+                    },
+                };
+                if (allowedFunctionNames.length > 0) {
+                    toolConfig.function_calling_config.allowed_function_names = allowedFunctionNames;
+                }
+                return toolConfig;
+            }
+        },
+    },
+    /**
+     * ================================
+     * NOTE: Google does not support parallel_tool_calls parameter
+     * ================================
+     */
+    parallel_tool_calls: {
+        param: 'parallel_tool_calls',
+        removeFromParams: true,
+    },
+    thinking: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    /**
+     * ================================
+     * NOTE: Add reasoning_effort translation
+     * ================================
+     */
+    reasoning_effort: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    /**
+     * ================================
+     * NOTE: Remove stream_options from the request body
+     * ================================
+     */
+    stream_options: {
+        param: 'stream_options',
+        removeFromParams: true,
+    },
+    // Gemini has no end-user identifier field and rejects unknown fields.
+    user: {
+        param: 'user',
+        removeFromParams: true,
+    },
+    seed: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    modalities: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    /**
+     * ================================
+     * NOTE: Add audio parameter mapping for Gemini TTS
+     * Maps audio: { voice, format } to generationConfig.speechConfig (Gemini REST expects speechConfig inside generationConfig)
+     * ================================
+     */
+    audio: {
+        param: 'generationConfig.speechConfig',
+        transform: (params) => {
+            const audioParam = params.audio;
+            if (!audioParam || typeof audioParam !== 'object') {
+                return undefined;
+            }
+            const ac = audioParam;
+            const voice = ac.voice;
+            const format = ac.format;
+            const multiSpeakerVoiceConfig = ac.multiSpeakerVoiceConfig;
+            // Validate format - Gemini TTS only supports pcm16
+            if (format && format !== 'pcm16' && format !== 'pcm') {
+                throw new ValidationError(`Unsupported audio format for Gemini TTS models: ${format}. Gemini TTS models only support 'pcm16' format as they return audio data in L16 PCM format.`);
+            }
+            // Multi-speaker: return speechConfig with multiSpeakerVoiceConfig
+            if (multiSpeakerVoiceConfig?.speakerVoiceConfigs?.length) {
+                return {
+                    multiSpeakerVoiceConfig,
+                };
+            }
+            // Single-speaker: voice required
+            if (!voice) {
+                return undefined;
+            }
+            return {
+                voiceConfig: {
+                    prebuiltVoiceConfig: {
+                        voiceName: voice,
+                    },
+                },
+            };
+        },
+    },
+};
+export const GoogleErrorResponseTransform = (response, provider = GOOGLE) => {
+    if ('error' in response) {
+        return generateErrorResponse({
+            message: response.error.message ?? '',
+            type: response.error.status ?? null,
+            code: response.error.code ?? null,
+        }, provider);
+    }
+    return undefined;
+};
+export const GoogleChatCompleteResponseTransform = (response, responseStatus, _responseHeaders, strictOpenAiCompliance) => {
+    if (responseStatus !== 200) {
+        const errorResponse = GoogleErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    if ('candidates' in response) {
+        const { promptTokenCount = 0, candidatesTokenCount = 0, totalTokenCount = 0, thoughtsTokenCount = 0, cachedContentTokenCount = 0, promptTokensDetails = [], candidatesTokensDetails = [], } = response.usageMetadata;
+        const inputAudioTokens = promptTokensDetails.reduce((acc, curr) => {
+            if (curr.modality === VERTEX_MODALITY.AUDIO)
+                return acc + curr.tokenCount;
+            return acc;
+        }, 0);
+        const outputAudioTokens = candidatesTokensDetails.reduce((acc, curr) => {
+            if (curr.modality === VERTEX_MODALITY.AUDIO)
+                return acc + curr.tokenCount;
+            return acc;
+        }, 0);
+        return {
+            id: 'tfy-' + crypto.randomUUID(),
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: response.modelVersion,
+            provider: 'google',
+            choices: response.candidates?.map((generation, idx) => {
+                // transform tool calls and content by iterating over the content parts
+                const toolCalls = [];
+                let content;
+                const thinkingBlocks = [];
+                const thoughtSignaturesAll = []; // all thoughtSignature values from all parts
+                const inlineDataParts = [];
+                for (const part of generation.content?.parts ?? []) {
+                    if (part.functionCall) {
+                        const baseId = 'tfy-' + crypto.randomUUID();
+                        const thoughtSig = part.thoughtSignature;
+                        // Embed signature into the ID for clients that strip provider_specific_fields
+                        const toolCallId = thoughtSig ? encodeToolCallIdWithSignature(baseId, thoughtSig) : baseId;
+                        toolCalls.push({
+                            id: toolCallId,
+                            type: 'function',
+                            function: {
+                                name: part.functionCall.name,
+                                arguments: JSON.stringify(part.functionCall.args),
+                            },
+                            // Store signature in provider_specific_fields for clients that preserve it
+                            ...(thoughtSig && { provider_specific_fields: { thought_signature: thoughtSig } }),
+                        });
+                        if (thoughtSig)
+                            thoughtSignaturesAll.push(thoughtSig);
+                    }
+                    else if (part.text) {
+                        if (part.thought) {
+                            // Thought part — capture thinking text and its signature
+                            const block = {
+                                type: 'thinking',
+                                thinking: part.text,
+                            };
+                            if (part.thoughtSignature) {
+                                block.signature = part.thoughtSignature;
+                                thoughtSignaturesAll.push(part.thoughtSignature);
+                            }
+                            thinkingBlocks.push(block);
+                        }
+                        else {
+                            // Concatenate — Gemini can return multiple text parts in one candidate.
+                            content = (content ?? '') + part.text;
+                            // Non-thought text part may also carry thoughtSignature (multi-turn token)
+                            if (part.thoughtSignature)
+                                thoughtSignaturesAll.push(part.thoughtSignature);
+                        }
+                    }
+                    else if (part.inlineData) {
+                        // Inline data (images, audio from Imagen/TTS models).
+                        // Collect and expose via provider_specific_fields.inline_data so clients can
+                        // consume the binary payload without breaking the string content field.
+                        inlineDataParts.push({
+                            mimeType: part.inlineData.mimeType,
+                            data: part.inlineData.data,
+                        });
+                    }
+                }
+                const reasoning_content = thinkingBlocks.map(b => b.thinking).join('') || undefined;
+                // provider_specific_fields carries thoughtSignature values for round-trip fidelity
+                // and any inline data payloads (images, audio) from generative model responses.
+                const providerSpecificFields = {
+                    ...(thoughtSignaturesAll.length > 0 && { thought_signatures: thoughtSignaturesAll }),
+                    ...(inlineDataParts.length > 0 && { inline_data: inlineDataParts }),
+                };
+                const message = {
+                    role: MESSAGE_ROLES.ASSISTANT,
+                    ...(toolCalls.length && { tool_calls: toolCalls }),
+                    ...(content && { content }),
+                    ...(thinkingBlocks.length > 0 && { thinking_blocks: thinkingBlocks }),
+                    ...(reasoning_content && { reasoning_content }),
+                    ...(Object.keys(providerSpecificFields).length > 0 && { provider_specific_fields: providerSpecificFields }),
+                };
+                const logprobsContent = transformVertexLogprobs(generation);
+                let logprobs;
+                if (logprobsContent) {
+                    logprobs = {
+                        content: logprobsContent,
+                    };
+                }
+                return {
+                    message: message,
+                    logprobs,
+                    index: generation.index ?? idx,
+                    finish_reason: transformFinishReason(generation.finishReason, strictOpenAiCompliance),
+                    ...(!strictOpenAiCompliance && generation.groundingMetadata
+                        ? { groundingMetadata: generation.groundingMetadata }
+                        : {}),
+                };
+            }) ?? [],
+            usage: {
+                prompt_tokens: promptTokenCount,
+                completion_tokens: candidatesTokenCount + thoughtsTokenCount,
+                total_tokens: totalTokenCount,
+                completion_tokens_details: {
+                    reasoning_tokens: thoughtsTokenCount,
+                    audio_tokens: outputAudioTokens,
+                },
+                prompt_tokens_details: {
+                    cached_tokens: cachedContentTokenCount,
+                    audio_tokens: inputAudioTokens,
+                },
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, GOOGLE);
+};
+export const GoogleChatCompleteStreamChunkTransform = (responseChunk, fallbackId, streamState, strictOpenAiCompliance) => {
+    streamState.containsChainOfThoughtMessage = streamState?.containsChainOfThoughtMessage ?? false;
+    streamState.cumulativeToolCallIndex = streamState?.cumulativeToolCallIndex ?? 0;
+    let chunk = responseChunk.trim();
+    if (chunk.startsWith('[')) {
+        chunk = chunk.slice(1);
+    }
+    if (chunk.endsWith(',')) {
+        chunk = chunk.slice(0, chunk.length - 1);
+    }
+    if (chunk.endsWith(']')) {
+        chunk = chunk.slice(0, chunk.length - 1);
+    }
+    chunk = chunk.replace(/^data: /, '');
+    chunk = chunk.trim();
+    if (chunk === '[DONE]') {
+        return `data: ${chunk}\n\n`;
+    }
+    const parsedChunk = JSON.parse(chunk);
+    let usageMetadata;
+    if (parsedChunk.usageMetadata) {
+        const thoughtsTokenCount = parsedChunk.usageMetadata.thoughtsTokenCount ?? 0;
+        usageMetadata = {
+            prompt_tokens: parsedChunk.usageMetadata.promptTokenCount,
+            completion_tokens: (parsedChunk.usageMetadata.candidatesTokenCount ?? 0) + thoughtsTokenCount,
+            total_tokens: parsedChunk.usageMetadata.totalTokenCount,
+            completion_tokens_details: {
+                reasoning_tokens: thoughtsTokenCount,
+                audio_tokens: parsedChunk.usageMetadata?.candidatesTokensDetails?.reduce((acc, curr) => {
+                    if (curr.modality === VERTEX_MODALITY.AUDIO)
+                        return acc + curr.tokenCount;
+                    return acc;
+                }, 0),
+            },
+            prompt_tokens_details: {
+                cached_tokens: parsedChunk.usageMetadata.cachedContentTokenCount,
+                audio_tokens: parsedChunk.usageMetadata?.promptTokensDetails?.reduce((acc, curr) => {
+                    if (curr.modality === VERTEX_MODALITY.AUDIO)
+                        return acc + curr.tokenCount;
+                    return acc;
+                }, 0),
+            },
+        };
+    }
+    return (`data: ${JSON.stringify({
+        id: fallbackId,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model: parsedChunk.modelVersion,
+        provider: 'google',
+        choices: parsedChunk.candidates?.map((generation, index) => {
+            let message = { role: 'assistant', content: '' };
+            const finishReason = generation.finishReason
+                ? transformFinishReason(generation.finishReason, strictOpenAiCompliance)
+                : null;
+            if (generation.content?.parts?.[0]?.text) {
+                const streamThinkingBlocks = [];
+                let content = '';
+                // Gemini 3+ can emit thought parts AND functionCall parts in the same streaming chunk.
+                // Collect function calls here so they aren't dropped when parts[0] is a thought/text part.
+                const mixedToolCalls = [];
+                let localToolIdx = 0;
+                for (const part of generation.content.parts) {
+                    if (part.thought) {
+                        const block = {
+                            type: 'thinking',
+                            thinking: part.text ?? '',
+                        };
+                        if (part.thoughtSignature)
+                            block.signature = part.thoughtSignature;
+                        streamThinkingBlocks.push(block);
+                        streamState.containsChainOfThoughtMessage = true;
+                    }
+                    else if (part.functionCall) {
+                        const baseId = 'tfy-' + crypto.randomUUID();
+                        const thoughtSig = part.thoughtSignature;
+                        const toolCallId = thoughtSig ? encodeToolCallIdWithSignature(baseId, thoughtSig) : baseId;
+                        mixedToolCalls.push({
+                            index: (streamState.cumulativeToolCallIndex ?? 0) + localToolIdx++,
+                            id: toolCallId,
+                            type: 'function',
+                            function: {
+                                name: part.functionCall.name,
+                                arguments: JSON.stringify(part.functionCall.args),
+                            },
+                            ...(thoughtSig && { provider_specific_fields: { thought_signature: thoughtSig } }),
+                        });
+                    }
+                    else {
+                        // Concatenate — a chunk may contain multiple plain-text parts.
+                        content = (content ?? '') + (part.text ?? '');
+                    }
+                }
+                streamState.cumulativeToolCallIndex = (streamState.cumulativeToolCallIndex ?? 0) + localToolIdx;
+                const reasoning_content = streamThinkingBlocks.map(b => b.thinking).join('') || undefined;
+                message = {
+                    role: 'assistant',
+                    content,
+                    ...(reasoning_content && { reasoning_content }),
+                    ...(streamThinkingBlocks.length > 0 && { thinking_blocks: streamThinkingBlocks }),
+                    ...(mixedToolCalls.length > 0 && { tool_calls: mixedToolCalls }),
+                };
+            }
+            else if (generation.content?.parts?.[0]?.functionCall) {
+                let localIdx = 0;
+                const toolCalls = generation.content.parts
+                    .map(part => {
+                    if (part.functionCall) {
+                        const baseId = 'tfy-' + crypto.randomUUID();
+                        const thoughtSig = part.thoughtSignature;
+                        const toolCallId = thoughtSig ? encodeToolCallIdWithSignature(baseId, thoughtSig) : baseId;
+                        return {
+                            index: (streamState.cumulativeToolCallIndex ?? 0) + localIdx++,
+                            id: toolCallId,
+                            type: 'function',
+                            function: {
+                                name: part.functionCall.name,
+                                arguments: JSON.stringify(part.functionCall.args),
+                            },
+                            ...(thoughtSig && { provider_specific_fields: { thought_signature: thoughtSig } }),
+                        };
+                    }
+                    return undefined;
+                })
+                    .filter((tc) => tc !== undefined);
+                streamState.cumulativeToolCallIndex = (streamState.cumulativeToolCallIndex ?? 0) + localIdx;
+                message = {
+                    role: 'assistant',
+                    tool_calls: toolCalls,
+                };
+            }
+            else if (generation.content?.parts?.[0]?.inlineData) {
+                const part = generation.content.parts[0];
+                const contentBlocks = [
+                    {
+                        index: streamState.containsChainOfThoughtMessage ? 1 : 0,
+                        delta: {
+                            type: 'image_url',
+                            image_url: {
+                                url: `data:${part.inlineData?.mimeType};base64,${part.inlineData?.data}`,
+                            },
+                        },
+                    },
+                ];
+                message = {
+                    role: 'assistant',
+                    content_blocks: contentBlocks,
+                };
+            }
+            return {
+                delta: message,
+                index: generation.index ?? index,
+                finish_reason: finishReason,
+                ...(!strictOpenAiCompliance && generation.groundingMetadata
+                    ? { groundingMetadata: generation.groundingMetadata }
+                    : {}),
+            };
+        }) ?? [],
+        ...(parsedChunk.usageMetadata?.candidatesTokenCount && {
+            usage: usageMetadata,
+        }),
+    })}` + '\n\n');
+};
+//# sourceMappingURL=chatComplete.js.map