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

package/dist/providers/google-vertex-ai/chatComplete.js

@@ -0,0 +1,1512 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * But needs some custom changes for TFY
+ * 1. Use tfy- prefix for ids instead of the legacy prefix
+ * 2. Use const instead of let for variables that are not reassigned (for linting)
+ * 3. Remove unused vars for linting
+ * 4. Add passedMimeType to the inlineData if present, otherwise default to image/jpeg
+ * 5. Remove stream_options from the request body
+ * 6. Add Qwen Chat Complete Config
+ * 7. Add Qwen Chat Complete Stream and Non-Stream Transform
+ * 8. Apply transformGeminiToolParameters on tools (inline $defs/$ref for Vertex)
+ * ================================
+ */
+// Docs for REST API
+// https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/send-multimodal-prompts#gemini-send-multimodal-samples-drest
+import { ValidationError } from '../../errors.js';
+import { GOOGLE_VERTEX_AI } from '../../globals.js';
+import { MESSAGE_ROLES, SYSTEM_MESSAGE_ROLES, } from '../../types/requestBody.js';
+import { resolveAnthropicBetas, VERTEX_BETA_KEY } from '../anthropic/anthropicBetas.js';
+import { AnthropicChatCompleteConfig, } from '../anthropic/chatComplete.js';
+import { mergeAnthropicBetasWithOverride } from '../anthropic/utils.js';
+import { encodeToolCallIdWithSignature, getThoughtSignatureFromToolCall, SYSTEM_INSTRUCTION_DISABLED_MODELS, transformOpenAIRoleToGoogleRole, transformToolChoiceForGemini, } from '../google/chatComplete.js';
+import { generateErrorResponse, generateInvalidProviderResponseError, transformFinishReason } from '../utils.js';
+import { decodeUrlIfEncoded, parseFileData } from '../utils/fileUtils.js';
+import { parseToolArgumentsByContext } from '../utils/toolUtils.js';
+import { transformGenerationConfig } from './transformGenerationConfig.js';
+import { VERTEX_MODALITY, } from './types.js';
+import { getMimeType, googleTools, mapOpenAIDetailToMediaResolution, recursivelyDeleteUnsupportedParameters, transformComputerUseToolFromOpenAI, transformGeminiToolParameters, transformGoogleTools, transformInputAudioPart, transformVertexLogprobs, } from './utils.js';
+export const buildGoogleSearchRetrievalTool = (tool) => {
+    const googleSearchRetrievalTool = {
+        googleSearchRetrieval: {},
+    };
+    if (tool.function.parameters?.dynamicRetrievalConfig) {
+        googleSearchRetrievalTool.googleSearchRetrieval.dynamicRetrievalConfig =
+            tool.function.parameters.dynamicRetrievalConfig;
+    }
+    return googleSearchRetrievalTool;
+};
+export const VertexGoogleChatCompleteConfig = {
+    // https://cloud.google.com/vertex-ai/generative-ai/docs/learn/model-versioning#gemini-model-versions
+    model: {
+        param: 'model',
+        required: true,
+        default: 'gemini-1.0-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).
+                        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.
+                        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) {
+                                    // Shouldn't throw error?
+                                    return;
+                                }
+                                const mediaResolution = mapOpenAIDetailToMediaResolution(detail);
+                                // Example: data:image/png;base64,abcdefg...
+                                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);
+                                    return;
+                                }
+                                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
+                                        /**
+                                         * ================================
+                                         * NOTE: Mimetype should be passedMimeType if provided, otherwise default to image/jpeg
+                                         * ================================
+                                         */
+                                        const part = {
+                                            inlineData: {
+                                                mimeType: passedMimeType || 'image/jpeg',
+                                                data: c.image_url?.url || undefined,
+                                            },
+                                        };
+                                        // 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),
+    },
+    // https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/configure-safety-attributes
+    // Example payload to be included in the request that sets the safety settings:
+    //   "safety_settings": [
+    //     {
+    //         "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+    //         "threshold": "BLOCK_NONE"
+    //     },
+    //     {
+    //         "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+    //         "threshold": "BLOCK_ONLY_HIGH"
+    //     }
+    // ]
+    safety_settings: {
+        param: 'safety_settings',
+    },
+    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;
+            }
+        },
+    },
+    labels: {
+        param: 'labels',
+    },
+    thinking: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    reasoning_effort: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    /**
+     * ================================
+     * NOTE: Remove stream_options from the request body
+     * ================================
+     */
+    stream_options: {
+        param: 'stream_options',
+        removeFromParams: true,
+    },
+    /**
+     * ================================
+     * NOTE: Remove parallel_tool_calls from the request body
+     * ================================
+     */
+    parallel_tool_calls: {
+        param: 'parallel_tool_calls',
+        removeFromParams: true,
+    },
+    // Vertex has no end-user identifier field and rejects unknown fields.
+    user: {
+        param: 'user',
+        removeFromParams: true,
+    },
+    modalities: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+    seed: {
+        param: 'generationConfig',
+        transform: (params) => transformGenerationConfig(params),
+    },
+};
+const buildVertexAnthropicBeta = (params, providerOptions) => resolveAnthropicBetas(mergeAnthropicBetasWithOverride(providerOptions, params?.anthropic_beta), VERTEX_BETA_KEY);
+export const VertexAnthropicChatCompleteConfig = {
+    ...AnthropicChatCompleteConfig,
+    anthropic_version: {
+        param: 'anthropic_version',
+        required: true,
+        default: 'vertex-2023-10-16',
+    },
+    // `required: true` so the header-only path still fires the default branch.
+    // Outgoing anthropic-beta header is set in api.ts; this covers the body field.
+    anthropic_beta: {
+        param: 'anthropic_beta',
+        required: true,
+        default: buildVertexAnthropicBeta,
+        transform: buildVertexAnthropicBeta,
+    },
+    model: {
+        param: 'model',
+        required: false,
+        transform: () => {
+            return undefined;
+        },
+    },
+};
+/** Sum IMAGE modality tokens from Gemini usageMetadata (native generateContent shape). */
+function getImageTokenCountsFromUsageMetadata(usageMetadata) {
+    if (!usageMetadata)
+        return { inputImageTokens: 0, outputImageTokens: 0 };
+    const inputImageTokens = usageMetadata.promptTokensDetails?.reduce((acc, curr) => {
+        if (curr.modality === VERTEX_MODALITY.IMAGE)
+            return acc + curr.tokenCount;
+        return acc;
+    }, 0) ?? 0;
+    const outputImageTokens = usageMetadata.candidatesTokensDetails?.reduce((acc, curr) => {
+        if (curr.modality === VERTEX_MODALITY.IMAGE)
+            return acc + curr.tokenCount;
+        return acc;
+    }, 0) ?? 0;
+    return { inputImageTokens, outputImageTokens };
+}
+function readGeminiUsageMetadataFromOpenAICompatPayload(payload) {
+    const raw = payload.usageMetadata ?? payload.usage_metadata;
+    if (raw !== undefined && raw !== null && typeof raw === 'object' && !Array.isArray(raw)) {
+        return raw;
+    }
+    return undefined;
+}
+function asObject(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+// Merge Gemini IMAGE modality counts into OpenAI-shaped usage.
+// Preserves existing detail fields (reasoning_tokens, cached_tokens, audio_tokens, etc.).
+function enrichOpenAIShapedUsageWithGeminiImageTokens(usage, usageMetadata) {
+    if (!usageMetadata)
+        return usage;
+    const { inputImageTokens, outputImageTokens } = getImageTokenCountsFromUsageMetadata(usageMetadata);
+    const merged = { ...asObject(usage) };
+    merged.prompt_tokens_details = {
+        ...asObject(merged.prompt_tokens_details),
+        image_tokens: inputImageTokens,
+    };
+    merged.completion_tokens_details = {
+        ...asObject(merged.completion_tokens_details),
+        image_tokens: outputImageTokens,
+    };
+    return merged;
+}
+export const GoogleChatCompleteResponseTransform = (response, responseStatus, _responseHeaders, strictOpenAiCompliance) => {
+    // when error occurs on streaming request, the response is an array of errors.
+    if (responseStatus !== 200 && Array.isArray(response) && response.length > 0 && 'error' in response[0]) {
+        const { error } = response[0];
+        return generateErrorResponse({
+            message: error.message,
+            type: error.status,
+            code: String(error.code),
+        }, GOOGLE_VERTEX_AI);
+    }
+    if (responseStatus !== 200 && 'error' in response) {
+        const { error } = response;
+        return generateErrorResponse({
+            message: error.message,
+            type: error.status,
+            code: String(error.code),
+        }, GOOGLE_VERTEX_AI);
+    }
+    // sometimes vertex gemini returns usageMetadata without candidates
+    const isValidResponse = 'candidates' in response || 'usageMetadata' in response;
+    if (isValidResponse) {
+        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);
+        const { inputImageTokens, outputImageTokens } = getImageTokenCountsFromUsageMetadata({
+            promptTokensDetails,
+            candidatesTokensDetails,
+        });
+        return {
+            /**
+             * ================================
+             * NOTE: Use tfy- prefix for ids instead of the legacy prefix
+             * ================================
+             */
+            id: 'tfy-' + crypto.randomUUID(),
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: response.modelVersion,
+            provider: GOOGLE_VERTEX_AI,
+            choices: response.candidates?.map((generation, index) => {
+                // transform tool calls and content by iterating over the content parts
+                const toolCalls = [];
+                let content;
+                const thinkingBlocks = [];
+                const thoughtSignaturesAll = [];
+                const inlineDataParts = [];
+                for (const part of generation.content?.parts ?? []) {
+                    if (part.functionCall) {
+                        const baseId = 'tfy-' + crypto.randomUUID();
+                        const thoughtSig = part.thoughtSignature;
+                        const toolCallId = thoughtSig ? encodeToolCallIdWithSignature(baseId, thoughtSig) : baseId;
+                        toolCalls.push({
+                            id: toolCallId,
+                            type: 'function',
+                            function: {
+                                name: part.functionCall.name,
+                                arguments: JSON.stringify(part.functionCall.args),
+                            },
+                            ...(thoughtSig && { provider_specific_fields: { thought_signature: thoughtSig } }),
+                        });
+                        if (thoughtSig)
+                            thoughtSignaturesAll.push(thoughtSig);
+                    }
+                    else if (part.text) {
+                        if (part.thought) {
+                            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;
+                            if (part.thoughtSignature)
+                                thoughtSignaturesAll.push(part.thoughtSignature);
+                        }
+                    }
+                    else if (part.inlineData) {
+                        // Inline data (images, audio from Imagen/TTS models).
+                        // Convert to a data URI and collect; exposed 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;
+                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,
+                    index: index,
+                    finish_reason: transformFinishReason(generation.finishReason, strictOpenAiCompliance),
+                    logprobs,
+                    ...(!strictOpenAiCompliance && {
+                        safetyRatings: generation.safetyRatings,
+                    }),
+                    ...(!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,
+                    image_tokens: outputImageTokens,
+                },
+                prompt_tokens_details: {
+                    cached_tokens: cachedContentTokenCount,
+                    audio_tokens: inputAudioTokens,
+                    image_tokens: inputImageTokens,
+                },
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, GOOGLE_VERTEX_AI);
+};
+export const VertexLlamaChatCompleteConfig = {
+    model: {
+        param: 'model',
+        required: true,
+        default: 'meta/llama-3.1-405b-instruct-maas',
+        transform: (params) => {
+            return params.model?.replace('meta.', 'meta/') || 'meta/llama-3.1-405b-instruct-maas';
+        },
+    },
+    messages: {
+        param: 'messages',
+        required: true,
+        default: [],
+    },
+    max_tokens: {
+        param: 'max_tokens',
+        default: 512,
+        min: 1,
+        max: 2048,
+    },
+    max_completion_tokens: {
+        param: 'max_tokens',
+        default: 512,
+        min: 1,
+        max: 2048,
+    },
+    temperature: {
+        param: 'temperature',
+        default: 0.5,
+        min: 0,
+        max: 1,
+    },
+    top_p: {
+        param: 'top_p',
+        default: 0.9,
+        min: 0,
+        max: 1,
+    },
+    top_k: {
+        param: 'top_k',
+        default: 0,
+        min: 0,
+        max: 2048,
+    },
+    stream: {
+        param: 'stream',
+        default: false,
+    },
+    /**
+     * ================================
+     * NOTE: Remove stream_options from the request body
+     * ================================
+     */
+    stream_options: {
+        param: 'stream_options',
+        removeFromParams: true,
+    },
+    parallel_tool_calls: {
+        param: 'parallel_tool_calls',
+        removeFromParams: true,
+    },
+};
+/**
+ * ================================
+ * NOTE: OpenAI-compatible config for default (non-Google/Anthropic/Mistral/endpoints) providers
+ * ================================
+ */
+export const VertexOpenAICompatibleChatCompleteConfig = {
+    model: {
+        param: 'model',
+        required: true,
+        default: 'openai/gpt-oss-120b-maas',
+    },
+    messages: {
+        param: 'messages',
+        required: true,
+        default: [],
+    },
+    max_tokens: {
+        param: 'max_tokens',
+        default: 2500,
+        min: 1,
+        max: 8192,
+    },
+    max_completion_tokens: {
+        param: 'max_tokens',
+        default: 2500,
+        min: 1,
+        max: 8192,
+    },
+    temperature: {
+        param: 'temperature',
+        default: 0.7,
+        min: 0,
+        max: 2,
+    },
+    top_p: {
+        param: 'top_p',
+        default: 1,
+        min: 0,
+        max: 1,
+    },
+    stop: {
+        param: 'stop',
+    },
+    stream: {
+        param: 'stream',
+        default: false,
+    },
+    /**
+     * ================================
+     * NOTE: Remove stream_options from the request body
+     * ================================
+     */
+    stream_options: {
+        param: 'stream_options',
+        removeFromParams: true,
+    },
+    parallel_tool_calls: {
+        param: 'parallel_tool_calls',
+        removeFromParams: true,
+    },
+};
+/**
+ * ================================
+ * NOTE: Add Qwen Chat Complete Config
+ * ================================
+ */
+export const VertexQwenChatCompleteConfig = {
+    model: {
+        param: 'model',
+        required: true,
+        default: 'qwen/qwen3-235b-a22b-instruct-2507-maas',
+    },
+    messages: {
+        param: 'messages',
+        required: true,
+        default: [],
+    },
+    max_tokens: {
+        param: 'max_tokens',
+        default: 512,
+        min: 1,
+        max: 2048,
+    },
+    max_completion_tokens: {
+        param: 'max_tokens',
+        default: 512,
+        min: 1,
+        max: 2048,
+    },
+    temperature: {
+        param: 'temperature',
+        default: 0.5,
+        min: 0,
+        max: 1,
+    },
+    top_p: {
+        param: 'top_p',
+        default: 0.9,
+        min: 0,
+        max: 1,
+    },
+    top_k: {
+        param: 'top_k',
+        default: 0,
+        min: 0,
+        max: 2048,
+    },
+    stream: {
+        param: 'stream',
+        default: false,
+    },
+    /**
+     * ================================
+     * NOTE: Remove stream_options from the request body
+     * ================================
+     */
+    stream_options: {
+        param: 'stream_options',
+        removeFromParams: true,
+    },
+};
+export const GoogleChatCompleteStreamChunkTransform = (responseChunk, fallbackId, streamState, strictOpenAiCompliance) => {
+    streamState.containsChainOfThoughtMessage = streamState?.containsChainOfThoughtMessage ?? false;
+    streamState.cumulativeToolCallIndex = streamState?.cumulativeToolCallIndex ?? 0;
+    const chunk = responseChunk
+        .trim()
+        .replace(/^data: /, '')
+        .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;
+        const streamInputImageTokens = parsedChunk.usageMetadata.promptTokensDetails?.reduce((acc, curr) => {
+            if (curr.modality === VERTEX_MODALITY.IMAGE)
+                return acc + curr.tokenCount;
+            return acc;
+        }, 0) ?? 0;
+        const streamOutputImageTokens = parsedChunk.usageMetadata.candidatesTokensDetails?.reduce((acc, curr) => {
+            if (curr.modality === VERTEX_MODALITY.IMAGE)
+                return acc + curr.tokenCount;
+            return acc;
+        }, 0) ?? 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),
+                image_tokens: streamOutputImageTokens,
+            },
+            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),
+                image_tokens: streamInputImageTokens,
+            },
+        };
+    }
+    const dataChunk = {
+        id: fallbackId,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model: parsedChunk.modelVersion,
+        provider: GOOGLE_VERTEX_AI,
+        choices: parsedChunk.candidates?.map((generation, index) => {
+            const finishReason = generation.finishReason
+                ? transformFinishReason(generation.finishReason, strictOpenAiCompliance)
+                : null;
+            let message = { role: 'assistant', content: '' };
+            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: index,
+                finish_reason: finishReason,
+                ...(!strictOpenAiCompliance && {
+                    safetyRatings: generation.safetyRatings,
+                }),
+                ...(!strictOpenAiCompliance && generation.groundingMetadata
+                    ? { groundingMetadata: generation.groundingMetadata }
+                    : {}),
+            };
+        }) ?? [],
+        ...(parsedChunk.usageMetadata != null && {
+            usage: usageMetadata,
+        }),
+    };
+    return `data: ${JSON.stringify(dataChunk)}\n\n`;
+};
+export const AnthropicErrorResponseTransform = response => {
+    // Vertex :streamRawPredict returns errors as an array `[{ error: {...} }]`,
+    // while :rawPredict returns a plain object `{ error: {...} }`. Normalise both
+    // to the object shape so streaming errors don't collapse to `undefined`.
+    const body = Array.isArray(response) ? response[0] : response;
+    if (body && 'error' in body) {
+        return generateErrorResponse({
+            message: body.error?.message,
+            type: body.error?.type,
+            code: null,
+        }, GOOGLE_VERTEX_AI);
+    }
+    return undefined;
+};
+export const VertexAnthropicChatCompleteResponseTransform = (response, responseStatus, _responseHeaders, strictOpenAiCompliance) => {
+    if (responseStatus !== 200) {
+        const errorResponse = AnthropicErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    if ('content' in response) {
+        const { input_tokens = 0, output_tokens = 0, cache_creation_input_tokens = 0, cache_read_input_tokens = 0, } = response?.usage ?? {};
+        const shouldSendCacheUsage = cache_creation_input_tokens || cache_read_input_tokens;
+        // Extract plain text content (always a string for the top-level content field)
+        const content = response.content
+            .filter(item => item.type === 'text')
+            .map(item => item.text)
+            .join('');
+        // Include both regular tool calls and server-side tool calls (e.g. web_search via
+        // srvtoolu_ IDs). Direct Anthropic does the same — both need to appear in tool_calls
+        // so that transformAssistantMessage can reconstruct the interleaved content on the
+        // next turn.
+        const toolCalls = [];
+        response.content.forEach(item => {
+            if (item.type === 'tool_use' || item.type === 'server_tool_use') {
+                toolCalls.push({
+                    id: item.id,
+                    type: 'function',
+                    function: {
+                        name: item.name,
+                        arguments: JSON.stringify(item.input),
+                    },
+                });
+            }
+        });
+        // Extract thinking blocks — unified format shared with the direct Anthropic provider
+        const thinking_blocks = response.content.reduce((acc, item) => {
+            if (item.type === 'thinking') {
+                acc.push({
+                    type: 'thinking',
+                    thinking: item.thinking ?? '',
+                    ...(item.signature && { signature: item.signature }),
+                });
+            }
+            else if (item.type === 'redacted_thinking') {
+                acc.push({ type: 'redacted_thinking', data: item.data ?? '' });
+            }
+            return acc;
+        }, []);
+        const reasoning_content = thinking_blocks
+            .filter((b) => b.type === 'thinking')
+            .map(b => b.thinking)
+            .join('');
+        // Server-side tool results — extracted the same way as the direct Anthropic provider.
+        const web_search_results = [];
+        const tool_results = [];
+        response.content.forEach(item => {
+            if (item.type === 'web_search_tool_result' || item.type === 'web_fetch_tool_result') {
+                web_search_results.push(item);
+            }
+            else if (item.type === 'bash_code_execution_tool_result' ||
+                item.type === 'text_editor_code_execution_tool_result') {
+                tool_results.push(item);
+            }
+        });
+        // content_blocks preserves the full response structure for non-strict mode.
+        // Matches direct Anthropic: keep everything except regular tool_use (already in tool_calls).
+        // server_tool_use and *_tool_result blocks are kept so clients that echo back content_blocks
+        // get the correct interleaved ordering on the next turn.
+        const content_blocks = !strictOpenAiCompliance
+            ? response.content.filter(item => item.type !== 'tool_use')
+            : undefined;
+        return {
+            id: response.id,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: response.model,
+            provider: GOOGLE_VERTEX_AI,
+            choices: [
+                {
+                    message: {
+                        role: 'assistant',
+                        content,
+                        tool_calls: toolCalls.length ? toolCalls : undefined,
+                        ...(thinking_blocks.length > 0 && { thinking_blocks }),
+                        ...(reasoning_content && { reasoning_content }),
+                        ...(content_blocks?.length && { content_blocks }),
+                        ...(web_search_results.length > 0 && { web_search_results }),
+                        ...(tool_results.length > 0 && { tool_results }),
+                    },
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: transformFinishReason(response.stop_reason, strictOpenAiCompliance),
+                },
+            ],
+            usage: {
+                prompt_tokens: input_tokens + (cache_read_input_tokens ?? 0) + (cache_creation_input_tokens ?? 0),
+                completion_tokens: output_tokens,
+                total_tokens: input_tokens + output_tokens,
+                ...(shouldSendCacheUsage && {
+                    cache_read_input_tokens: cache_read_input_tokens,
+                    cache_creation_input_tokens: cache_creation_input_tokens,
+                }),
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, GOOGLE_VERTEX_AI);
+};
+export const VertexAnthropicChatCompleteStreamChunkTransform = (responseChunk, fallbackId, streamState, strictOpenAiCompliance) => {
+    let chunk = responseChunk.trim();
+    if (chunk.startsWith('event: ping') || chunk.startsWith('event: vertex_event')) {
+        return;
+    }
+    if (chunk.startsWith('event: message_stop')) {
+        return 'data: [DONE]\n\n';
+    }
+    // Strip the event: line (including content_block_stop — its data line must be parsed
+    // so the zero-arg tool call handler and state resets fire correctly).
+    chunk = chunk.replace(/^event: content_block_stop[\r\n]*/, '');
+    chunk = chunk.replace(/^event: content_block_delta[\r\n]*/, '');
+    chunk = chunk.replace(/^event: content_block_start[\r\n]*/, '');
+    chunk = chunk.replace(/^event: message_delta[\r\n]*/, '');
+    chunk = chunk.replace(/^event: message_start[\r\n]*/, '');
+    chunk = chunk.replace(/^event: error[\r\n]*/, '');
+    chunk = chunk.replace(/^data: /, '');
+    chunk = chunk.trim();
+    const parsedChunk = JSON.parse(chunk);
+    if (parsedChunk.type === 'error' && parsedChunk.error) {
+        return (`data: ${JSON.stringify({
+            id: fallbackId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: '',
+            provider: GOOGLE_VERTEX_AI,
+            choices: [
+                {
+                    finish_reason: parsedChunk.error.type,
+                    delta: {
+                        content: '',
+                    },
+                },
+            ],
+        })}` +
+            '\n\n' +
+            'data: [DONE]\n\n');
+    }
+    const shouldSendCacheUsage = parsedChunk.message?.usage?.cache_read_input_tokens || parsedChunk.message?.usage?.cache_creation_input_tokens;
+    if (parsedChunk.type === 'message_start' && parsedChunk.message?.usage) {
+        streamState.model = parsedChunk?.message?.model ?? '';
+        const cacheReadTokens = parsedChunk.message?.usage?.cache_read_input_tokens ?? 0;
+        const cacheCreationTokens = parsedChunk.message?.usage?.cache_creation_input_tokens ?? 0;
+        const promptTokens = (parsedChunk.message.usage?.input_tokens ?? 0) + cacheReadTokens + cacheCreationTokens;
+        streamState.usage = {
+            prompt_tokens: promptTokens,
+            ...(shouldSendCacheUsage && {
+                cache_read_input_tokens: cacheReadTokens,
+                cache_creation_input_tokens: cacheCreationTokens,
+            }),
+        };
+        // Read by billing after the stream ends; already cache-inclusive on this path.
+        streamState.promptTokensWithCache = promptTokens;
+        return (`data: ${JSON.stringify({
+            id: fallbackId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: streamState.model,
+            provider: GOOGLE_VERTEX_AI,
+            choices: [
+                {
+                    delta: {
+                        /*
+                        ================================
+                        NOTE: Keep the message role from the response
+                        ================================
+                        */
+                        role: parsedChunk.message?.role,
+                        content: '',
+                    },
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: null,
+                },
+            ],
+            // Input side only: message_start's output_tokens is a placeholder (1-2), and sending it would
+            // look like complete usage and suppress estimation on a cancelled stream.
+            usage: {
+                prompt_tokens: promptTokens,
+                ...(shouldSendCacheUsage && {
+                    cache_read_input_tokens: cacheReadTokens,
+                    cache_creation_input_tokens: cacheCreationTokens,
+                }),
+            },
+        })}` + '\n\n');
+    }
+    if (parsedChunk.type === 'message_delta' && parsedChunk.usage) {
+        const totalTokens = (streamState?.usage?.prompt_tokens ?? 0) + (parsedChunk.usage.output_tokens ?? 0);
+        return (`data: ${JSON.stringify({
+            id: fallbackId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: streamState.model,
+            provider: GOOGLE_VERTEX_AI,
+            choices: [
+                {
+                    index: 0,
+                    delta: {
+                        // Emit fully assembled thinking_blocks (text + signature) once the stream completes.
+                        // Clients can echo these back for multi-turn without reconstructing from partial deltas.
+                        ...(streamState.thinkingBlocks?.length && { thinking_blocks: streamState.thinkingBlocks }),
+                    },
+                    finish_reason: transformFinishReason(parsedChunk.delta?.stop_reason, strictOpenAiCompliance),
+                },
+            ],
+            usage: {
+                ...streamState.usage,
+                completion_tokens: parsedChunk.usage?.output_tokens ?? 0,
+                total_tokens: totalTokens,
+                prompt_tokens_details: {
+                    cached_tokens: streamState.usage?.cache_read_input_tokens ?? 0,
+                },
+            },
+        })}` + '\n\n');
+    }
+    const toolCalls = [];
+    // Single unified content_block_start handler — mirrors the direct Anthropic provider exactly.
+    // State must be updated before any early returns so subsequent delta/stop events are consistent.
+    if (parsedChunk.type === 'content_block_start') {
+        streamState.currentContentBlockType = parsedChunk.content_block?.type;
+        streamState.currentToolBlockHasArgs = false;
+        if (parsedChunk.content_block?.type === 'thinking') {
+            streamState.currentThinkingText = '';
+            return undefined;
+        }
+        if (parsedChunk.content_block?.type === 'text') {
+            return undefined;
+        }
+        // Redacted thinking: Anthropic delivers the full data in the content_block_start event
+        // (not in a subsequent delta), same as the direct Anthropic provider.
+        if (parsedChunk.content_block?.type === 'redacted_thinking' && parsedChunk.content_block.data) {
+            const redactedBlock = {
+                type: 'redacted_thinking',
+                data: parsedChunk.content_block.data,
+            };
+            if (!streamState.thinkingBlocks)
+                streamState.thinkingBlocks = [];
+            streamState.thinkingBlocks.push(redactedBlock);
+            return undefined;
+        }
+    }
+    else if (parsedChunk.type === 'content_block_stop') {
+        // Tool block completed with no argument deltas — emit `{}` so the client
+        // receives valid JSON instead of an empty string.
+        if ((streamState.currentContentBlockType === 'tool_use' ||
+            streamState.currentContentBlockType === 'server_tool_use') &&
+            !streamState.currentToolBlockHasArgs) {
+            toolCalls.push({
+                index: streamState.toolIndex,
+                function: { arguments: '{}' },
+            });
+        }
+        streamState.currentContentBlockType = undefined;
+        streamState.currentToolBlockHasArgs = false;
+        // Only emit a chunk when there is a zero-arg tool call to send; all other block stops
+        // (text, thinking, redacted_thinking, web_search_tool_result, etc.) are silent.
+        // Without this guard a spurious empty SSE chunk is emitted for every non-tool block stop.
+        if (!toolCalls.length)
+            return undefined;
+    }
+    // server_tool_use blocks are treated the same as tool_use for streaming tool call creation.
+    const isToolBlockStart = parsedChunk.type === 'content_block_start' &&
+        (parsedChunk.content_block?.type === 'tool_use' || parsedChunk.content_block?.type === 'server_tool_use');
+    if (isToolBlockStart) {
+        // Increment tool call index for parallel tool calls. The streamState persists across chunks,
+        // so toolIndex tracks the sequential index: undefined → 0 → 1 → 2 → ...
+        // First tool: (undefined ?? -1) + 1 = 0
+        // Second tool: (0 ?? -1) + 1 = 1
+        // Third tool: (1 ?? -1) + 1 = 2
+        // Use nullish coalescing (??) instead of ternary (? : ) because 0 is a valid tool index.
+        // A ternary would treat 0 as falsy and reset to 0, causing all tool calls after the first
+        // to incorrectly get index 0. Nullish coalescing only treats null/undefined as missing.
+        streamState.toolIndex = (streamState.toolIndex ?? -1) + 1;
+    }
+    // Only emit tool_calls for partial_json deltas when inside a tool_use or server_tool_use block.
+    // web_search_tool_result blocks also emit input_json_delta and must not become tool_calls.
+    const isToolBlockDelta = parsedChunk.type === 'content_block_delta' &&
+        parsedChunk.delta?.partial_json != undefined &&
+        (streamState.currentContentBlockType === 'tool_use' || streamState.currentContentBlockType === 'server_tool_use');
+    if (isToolBlockStart && parsedChunk.content_block) {
+        toolCalls.push({
+            index: streamState.toolIndex,
+            id: parsedChunk.content_block.id,
+            type: 'function',
+            function: {
+                name: parsedChunk.content_block.name,
+                arguments: '',
+            },
+        });
+    }
+    else if (isToolBlockDelta) {
+        streamState.currentToolBlockHasArgs = true;
+        toolCalls.push({
+            index: streamState.toolIndex,
+            function: {
+                arguments: parsedChunk.delta.partial_json ?? '',
+            },
+        });
+    }
+    // Server-side tool results emitted immediately on the chunk where the block starts,
+    // same as the direct Anthropic provider.
+    let immediateWebSearchResults;
+    let immediateToolResults;
+    if (parsedChunk.type === 'content_block_start' && parsedChunk.content_block) {
+        const cbType = parsedChunk.content_block.type ?? '';
+        if (cbType === 'web_search_tool_result' || cbType === 'web_fetch_tool_result') {
+            if (!streamState.webSearchResults)
+                streamState.webSearchResults = [];
+            const newWebResult = parsedChunk.content_block;
+            streamState.webSearchResults.push(newWebResult);
+            immediateWebSearchResults = [newWebResult];
+        }
+        else if (cbType.endsWith('_tool_result') && cbType !== 'tool_search_tool_result') {
+            if (!streamState.toolResults)
+                streamState.toolResults = [];
+            const newToolResult = parsedChunk.content_block;
+            streamState.toolResults.push(newToolResult);
+            immediateToolResults = [newToolResult];
+        }
+    }
+    const content = parsedChunk.delta?.text;
+    // Handle thinking deltas: accumulate text and capture signature for multi-turn.
+    let thinkingTextDelta;
+    let incomingSignature;
+    if (parsedChunk.type === 'content_block_delta') {
+        if (parsedChunk.delta?.thinking) {
+            thinkingTextDelta = parsedChunk.delta.thinking;
+            streamState.currentThinkingText = (streamState.currentThinkingText ?? '') + thinkingTextDelta;
+        }
+        else if (parsedChunk.delta?.signature) {
+            // Signature delta marks the end of a thinking block. Assemble and store it so it can
+            // be emitted as a complete block in the message_delta chunk.
+            incomingSignature = parsedChunk.delta.signature;
+            const finalThinkingBlock = {
+                type: 'thinking',
+                thinking: streamState.currentThinkingText ?? '',
+                signature: incomingSignature,
+            };
+            if (!streamState.thinkingBlocks)
+                streamState.thinkingBlocks = [];
+            streamState.thinkingBlocks.push(finalThinkingBlock);
+            streamState.currentThinkingText = undefined;
+        }
+        // Note: redacted_thinking data is captured from content_block_start, not from a delta.
+    }
+    return (`data: ${JSON.stringify({
+        id: fallbackId,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model: streamState.model,
+        provider: GOOGLE_VERTEX_AI,
+        choices: [
+            {
+                delta: {
+                    content,
+                    // Emit incremental reasoning text for consumers that want a simple string delta
+                    ...(thinkingTextDelta && { reasoning_content: thinkingTextDelta }),
+                    // Emit the signature when it arrives (same as direct Anthropic provider)
+                    ...(incomingSignature && { reasoning_signature: incomingSignature }),
+                    tool_calls: toolCalls.length ? toolCalls : undefined,
+                    // Server-side tool results emitted immediately on the chunk where the block starts
+                    ...(immediateWebSearchResults?.length && { web_search_results: immediateWebSearchResults }),
+                    ...(immediateToolResults?.length && { tool_results: immediateToolResults }),
+                },
+                index: 0,
+                logprobs: null,
+                finish_reason: parsedChunk.delta?.stop_reason ?? null,
+            },
+        ],
+    })}` + '\n\n');
+};
+export const VertexLlamaChatCompleteResponseTransform = (response, responseStatus) => {
+    if (responseStatus !== 200 && Array.isArray(response) && response.length > 0 && 'error' in response[0]) {
+        const { error } = response[0];
+        return generateErrorResponse({
+            message: error.message,
+            type: error.status,
+            code: String(error.code),
+        }, GOOGLE_VERTEX_AI);
+    }
+    if ('choices' in response) {
+        return {
+            id: crypto.randomUUID(),
+            created: Math.floor(Date.now() / 1000),
+            provider: GOOGLE_VERTEX_AI,
+            ...response,
+        };
+    }
+    return generateInvalidProviderResponseError(response, GOOGLE_VERTEX_AI);
+};
+export const VertexLlamaChatCompleteStreamChunkTransform = (responseChunk, fallbackId) => {
+    let chunk = responseChunk.trim();
+    chunk = chunk.replace(/^data: /, '');
+    chunk = chunk.trim();
+    const parsedChunk = JSON.parse(chunk);
+    parsedChunk.id = fallbackId;
+    parsedChunk.created = Math.floor(Date.now() / 1000);
+    parsedChunk.provider = GOOGLE_VERTEX_AI;
+    return `data: ${JSON.stringify(parsedChunk)}` + '\n\n';
+};
+/**
+ * ================================
+ * NOTE: Add OpenAI OSS response transform functions
+ * ================================
+ */
+export const VertexOpenAICompatibleChatCompleteResponseTransform = (response, responseStatus) => {
+    if (responseStatus !== 200 && Array.isArray(response) && response.length > 0 && 'error' in response[0]) {
+        const { error } = response[0];
+        return generateErrorResponse({
+            message: error.message,
+            type: error.status,
+            code: String(error.code),
+        }, GOOGLE_VERTEX_AI);
+    }
+    if (!Array.isArray(response) && 'choices' in response) {
+        const resRecord = response;
+        const geminiUm = readGeminiUsageMetadataFromOpenAICompatPayload(resRecord);
+        const mergedUsage = geminiUm
+            ? enrichOpenAIShapedUsageWithGeminiImageTokens(resRecord.usage, geminiUm)
+            : resRecord.usage;
+        return {
+            ...resRecord,
+            id: response.id || crypto.randomUUID(),
+            object: response.object || 'chat.completion',
+            created: response.created || Math.floor(Date.now() / 1000),
+            model: response.model || '',
+            provider: GOOGLE_VERTEX_AI,
+            usage: mergedUsage,
+        };
+    }
+    return generateInvalidProviderResponseError(response, GOOGLE_VERTEX_AI);
+};
+export const VertexOpenAICompatibleChatCompleteStreamChunkTransform = (responseChunk, fallbackId) => {
+    let chunk = responseChunk.trim();
+    if (chunk === 'data: [DONE]') {
+        return chunk + '\n\n';
+    }
+    chunk = chunk.replace(/^data: /, '');
+    chunk = chunk.trim();
+    if (!chunk) {
+        return '';
+    }
+    const parsedChunk = JSON.parse(chunk);
+    const geminiUm = readGeminiUsageMetadataFromOpenAICompatPayload(parsedChunk);
+    if (geminiUm !== undefined && parsedChunk.usage !== undefined) {
+        parsedChunk.usage = enrichOpenAIShapedUsageWithGeminiImageTokens(parsedChunk.usage, geminiUm);
+    }
+    parsedChunk.id = parsedChunk.id || fallbackId;
+    parsedChunk.created = parsedChunk.created || Math.floor(Date.now() / 1000);
+    parsedChunk.provider = GOOGLE_VERTEX_AI;
+    return `data: ${JSON.stringify(parsedChunk)}` + '\n\n';
+};
+//# sourceMappingURL=chatComplete.js.map