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

package/dist/providers/bedrock/chatComplete.js

@@ -0,0 +1,1375 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * But needs some custom changes for TFY
+ * 1. Add a default model name if not present in request ('unknown')
+ * 2. Update let to const at few places (for linting)
+ * 3. Add support for response_format in anthropic chat complete request transform
+ * 4. Add response_format to BedrockConverseAnthropicChatCompleteConfig
+ * 5. Remove stream_options from the request body
+ * ================================
+ */
+import { ValidationError } from '../../errors.js';
+import { BEDROCK, fileExtensionMimeTypeMap, imagesMimeTypes, isBedrockEagerInputStreamingSupported, isClaudeAdaptiveThinkingModel, mimeTypeToExtensionMap, RESPONSE_FORMAT_TOOL_NAME, videoMimeTypes, } from '../../globals.js';
+import { logger } from '../../logger.js';
+import { SYSTEM_MESSAGE_ROLES } from '../../types/requestBody.js';
+import { modelHasFeature } from '../../utils/modelParamUtils.js';
+import { calculateBudgetTokens } from '../../utils/reasoningUtils.js';
+import { BEDROCK_CONVERSE_BETA_KEY, BEDROCK_INVOKE_BETA_KEY, resolveAnthropicBetas } from '../anthropic/anthropicBetas.js';
+import { AnthropicChatCompleteConfig, getAzureAnthropicChatCompleteResponseTransform, getAzureAnthropicStreamChunkTransform, } from '../anthropic/chatComplete.js';
+import { resolveServerTools } from '../anthropic/serverTools.js';
+import { anthropicBetaResolveFromParamMap, mergeAnthropicBetasWithOverride } from '../anthropic/utils.js';
+import { convertCursorCustomToolsToFunctions, getCursorFreeformToolNames, unwrapCursorFreeformPayload, } from '../open-ai-base/cursor.utils.js';
+import { generateErrorResponse, generateInvalidProviderResponseError, transformFinishReason } from '../utils.js';
+import { parseFileData } from '../utils/fileUtils.js';
+import { parseToolArgumentsByContext } from '../utils/toolUtils.js';
+import { getBedrockErrorChunk, transformAdditionalModelRequestFields, transformAI21AdditionalModelRequestFields, transformAnthropicAdditionalModelRequestFields, transformCohereAdditionalModelRequestFields, transformInferenceConfig, } from './utils.js';
+const getMessageTextContentArray = (message) => {
+    if (message.content && Array.isArray(message.content)) {
+        const filteredContentMessages = message.content.filter(item => item.type === 'text');
+        const finalContent = [];
+        filteredContentMessages.forEach(item => {
+            finalContent.push({
+                text: item.text || '',
+            });
+            // push a cache point.
+            if (item.cache_control) {
+                finalContent.push({
+                    cachePoint: {
+                        type: 'default',
+                    },
+                });
+            }
+        });
+        return finalContent;
+    }
+    return [
+        {
+            text: message.content || '',
+        },
+    ];
+};
+const transformAndAppendThinkingMessageItem = (item, out) => {
+    if (item.type === 'thinking') {
+        out.push({
+            reasoningContent: {
+                reasoningText: {
+                    text: item.thinking ?? '',
+                    // Omit signature key entirely when absent — an empty-string signature can cause
+                    // Bedrock validation errors on models that validate the signature format.
+                    ...(item.signature && { signature: item.signature }),
+                },
+            },
+        });
+    }
+    else if (item.type === 'redacted_thinking') {
+        out.push({
+            reasoningContent: {
+                redactedContent: item.data ?? '',
+            },
+        });
+    }
+};
+const determineMimeType = (file, fileData) => {
+    if (file?.mime_type)
+        return file.mime_type;
+    // Parse from data URI if present
+    if (fileData?.startsWith('data:')) {
+        const match = fileData.match(/^data:(.*?);base64/);
+        if (match)
+            return match[1];
+    }
+    // Default fallback
+    return fileExtensionMimeTypeMap.pdf;
+};
+const determineContentType = (mimeType) => {
+    if (mimeType.startsWith('application/') || mimeType.startsWith('text/')) {
+        return 'document';
+    }
+    if (videoMimeTypes.includes(mimeType)) {
+        return 'video';
+    }
+    return 'image';
+};
+const mimeTypeToBedrockFormat = (mimeType, contentType) => {
+    // Use mapping if available
+    if (mimeTypeToExtensionMap[mimeType]) {
+        return mimeTypeToExtensionMap[mimeType];
+    }
+    // Fallback: extract from MIME type (e.g., "video/mp4" -> "mp4")
+    const parts = mimeType.split('/');
+    if (parts.length === 2) {
+        return parts[1];
+    }
+    // Final fallback based on content type
+    return contentType === 'document' ? 'pdf' : contentType === 'video' ? 'mp4' : 'jpeg';
+};
+const buildBedrockSource = (fileId, fileData) => {
+    if (fileId) {
+        return {
+            s3Location: {
+                uri: fileId,
+            },
+        };
+    }
+    if (fileData) {
+        const { base64String } = parseFileData(fileData);
+        return {
+            bytes: base64String,
+        };
+    }
+    return {};
+};
+const createBedrockContentBlock = (contentType, source, fileFormat, fileName) => {
+    if (contentType === 'document') {
+        const name = fileName || `DocumentPDFmessages_${crypto.randomUUID().slice(0, 16)}_${fileFormat}`;
+        return {
+            document: {
+                source,
+                format: fileFormat,
+                name,
+            },
+        };
+    }
+    if (contentType === 'video') {
+        return {
+            video: {
+                source,
+                format: fileFormat,
+            },
+        };
+    }
+    return {
+        image: {
+            source,
+            format: fileFormat,
+        },
+    };
+};
+const getMessageContent = (message, model) => {
+    const msg = message;
+    const hasThinkingBlocks = !!msg.thinking_blocks?.length;
+    if (!message.content && !message.tool_calls && !message.tool_call_id && !hasThinkingBlocks)
+        return [];
+    if (message.role === 'tool') {
+        const toolResultContent = getMessageTextContentArray(message);
+        const textContent = toolResultContent.filter(block => 'text' in block);
+        const blocks = [
+            {
+                toolResult: {
+                    // Bedrock allows empty array but does not allow empty string in content.
+                    content: textContent[0]?.text ? textContent : [],
+                    toolUseId: message.tool_call_id ?? '',
+                },
+            },
+        ];
+        if (textContent.length < toolResultContent.length) {
+            blocks.push({ cachePoint: { type: 'default' } });
+        }
+        return blocks;
+    }
+    const out = [];
+    // For assistant messages: reconstruct reasoning content from thinking_blocks for multi-turn.
+    // thinking_blocks carries per-block signatures required for the Bedrock reasoningContent format.
+    const topLevelThinkingBlocks = msg.thinking_blocks;
+    const hasTopLevelThinkingBlocks = message.role === 'assistant' && !!topLevelThinkingBlocks?.length;
+    if (hasTopLevelThinkingBlocks && topLevelThinkingBlocks) {
+        for (const block of topLevelThinkingBlocks) {
+            if (block.type === 'thinking' && block.thinking !== undefined) {
+                if (block.signature) {
+                    // Signed thinking block — valid for multi-turn, echo as reasoningContent
+                    out.push({
+                        reasoningContent: {
+                            reasoningText: { text: block.thinking, signature: block.signature },
+                        },
+                    });
+                }
+                else if (block.thinking.trim()) {
+                    // No signature (e.g. non-Anthropic Bedrock model) — send as plain text
+                    out.push({ text: block.thinking });
+                }
+            }
+            else if (block.type === 'redacted_thinking' && block.data) {
+                out.push({ reasoningContent: { redactedContent: block.data } });
+            }
+        }
+    }
+    const inputContent = message.content_blocks ?? message.content;
+    let trailingCachePoint = false;
+    // if message is a string, return a single element array with the text
+    if (typeof inputContent === 'string' && inputContent.trim()) {
+        out.push({
+            text: inputContent,
+        });
+    }
+    else if (inputContent && Array.isArray(inputContent)) {
+        inputContent.forEach((item, index) => {
+            if (item.type === 'text') {
+                out.push({
+                    text: item.text || '',
+                });
+            }
+            else if (item.type === 'thinking') {
+                // Only read thinking from content_blocks if we didn't already process top-level thinking_blocks
+                if (!hasTopLevelThinkingBlocks) {
+                    transformAndAppendThinkingMessageItem(item, out);
+                }
+            }
+            else if (item.type === 'image_url' && item.image_url) {
+                const mimetypeParts = item.image_url.url.split(';');
+                const mimeType = mimetypeParts[0].split(':')[1];
+                const bytes = mimetypeParts[1].split(',')[1];
+                const contentType = determineContentType(mimeType);
+                const fileFormat = mimeTypeToBedrockFormat(mimeType, contentType);
+                if (imagesMimeTypes.includes(mimeType)) {
+                    out.push({
+                        image: {
+                            source: {
+                                bytes,
+                            },
+                            format: fileFormat,
+                        },
+                    });
+                }
+                else if (videoMimeTypes.includes(mimeType)) {
+                    out.push({
+                        video: {
+                            format: fileFormat,
+                            source: {
+                                bytes,
+                            },
+                        },
+                    });
+                }
+                else {
+                    out.push({
+                        document: {
+                            format: fileFormat,
+                            name: crypto.randomUUID(),
+                            source: {
+                                bytes,
+                            },
+                        },
+                    });
+                }
+            }
+            else if (item.type === 'file') {
+                if (!item.file) {
+                    return;
+                }
+                // Extract file information (use file_id if present, otherwise file_data)
+                const fileId = item.file.file_id || item.file.file_url;
+                const fileData = item.file.file_data;
+                // Validate: at least one must exist
+                if (!fileData && !fileId) {
+                    throw new ValidationError(`file_data and file_id cannot both be None. Got=${JSON.stringify(item)}`);
+                }
+                // Determine MIME type and content type (use mime_type if available)
+                const mimeType = item.file.mime_type || determineMimeType(item.file, fileData);
+                const contentType = determineContentType(mimeType);
+                const fileFormat = mimeTypeToBedrockFormat(mimeType, contentType);
+                // Build source: prefer file_id (S3 location), otherwise use file_data (bytes)
+                const useFileId = !!fileId;
+                const source = buildBedrockSource(fileId, useFileId ? undefined : fileData);
+                // Create and push content block
+                const contentBlock = createBedrockContentBlock(contentType, source, fileFormat, item.file.file_name);
+                out.push(contentBlock);
+            }
+            if (item.cache_control) {
+                // if content item has `cache_control`, push the cache point to the out array
+                if (index === inputContent.length - 1) {
+                    trailingCachePoint = true;
+                }
+                else {
+                    out.push({
+                        cachePoint: {
+                            type: 'default',
+                        },
+                    });
+                }
+            }
+        });
+    }
+    // If message is an array of objects, handle text content, tool calls, tool results, this would be much cleaner if the upstream chat create object were a union type
+    message.tool_calls?.forEach((toolCall) => {
+        out.push({
+            toolUse: {
+                name: toolCall.function.name,
+                input: parseToolArgumentsByContext(toolCall.function?.arguments, { model }),
+                toolUseId: toolCall.id ?? '',
+            },
+        });
+    });
+    if (trailingCachePoint) {
+        out.push({ cachePoint: { type: 'default' } });
+    }
+    return out;
+};
+// refer: https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html
+export const BedrockConverseChatCompleteConfig = {
+    messages: [
+        {
+            param: 'messages',
+            required: true,
+            transform: (params) => {
+                if (!params.messages)
+                    return [];
+                const supportsSystem = modelHasFeature(BEDROCK, params.model || '', 'system_messages');
+                const transformedMessages = params.messages
+                    .filter(msg => !supportsSystem || !SYSTEM_MESSAGE_ROLES.includes(msg.role))
+                    .map(msg => {
+                    return {
+                        role: msg.role === 'assistant' ? 'assistant' : 'user',
+                        content: getMessageContent(msg, params.model),
+                    };
+                });
+                let prevRole = '';
+                // combine user messages in succession
+                const combinedMessages = transformedMessages.reduce((acc, msg) => {
+                    if (msg.role === 'user' && prevRole === 'user') {
+                        const lastMessage = acc[acc.length - 1];
+                        const newContent = [...lastMessage.content, ...msg.content];
+                        lastMessage.content = newContent;
+                    }
+                    else {
+                        acc.push(msg);
+                    }
+                    prevRole = msg.role;
+                    return acc;
+                }, []);
+                return combinedMessages;
+            },
+        },
+        {
+            param: 'system',
+            required: false,
+            transform: (params) => {
+                if (!params.messages)
+                    return;
+                if (!modelHasFeature(BEDROCK, params.model || '', 'system_messages'))
+                    return;
+                const systemMessages = params.messages.reduce((acc, msg) => {
+                    if (SYSTEM_MESSAGE_ROLES.includes(msg.role))
+                        return acc.concat(...getMessageTextContentArray(msg));
+                    return acc;
+                }, []);
+                if (!systemMessages.length)
+                    return;
+                return systemMessages;
+            },
+        },
+    ],
+    tools: {
+        param: 'toolConfig',
+        transform: (params, transformInput) => {
+            const canBeAmazonModel = params.model?.includes('amazon');
+            const tools = [];
+            const requestTools = transformInput.callConfig.isCursorEndpoint
+                ? convertCursorCustomToolsToFunctions(params)
+                : params.tools;
+            // The loop below only emits `tool.function` entries, so unsupported server tools would
+            // be discarded silently; resolving them first makes the drop deliberate and logged.
+            const supportedTools = resolveServerTools(requestTools, BEDROCK_CONVERSE_BETA_KEY).tools;
+            supportedTools.forEach(tool => {
+                if (tool.function) {
+                    tools.push({
+                        toolSpec: {
+                            name: tool.function.name,
+                            description: tool.function.description,
+                            inputSchema: {
+                                json: {
+                                    type: tool.function.parameters?.type || 'object',
+                                    properties: tool.function.parameters?.properties || {},
+                                    required: tool.function.parameters?.required || [],
+                                },
+                            },
+                        },
+                    });
+                }
+                if (tool.cache_control && !canBeAmazonModel) {
+                    tools.push({
+                        cachePoint: {
+                            type: 'default',
+                        },
+                    });
+                }
+            });
+            if (!tools.length)
+                return null;
+            const modelId = params.model || '';
+            // Skip synthetic tools (from response_format) when the model doesn't support tools.
+            // User-provided tools are always forwarded — let the model API return its own error.
+            const allSynthetic = tools.every(t => ('toolSpec' in t && t.toolSpec.name === RESPONSE_FORMAT_TOOL_NAME) || 'cachePoint' in t);
+            if (allSynthetic && !modelHasFeature(BEDROCK, modelId, 'function_calling')) {
+                return null;
+            }
+            const toolConfig = { tools };
+            const supportsToolChoice = modelHasFeature(BEDROCK, modelId, 'tool_choice');
+            let toolChoice = undefined;
+            if (params.tool_choice && supportsToolChoice) {
+                if (typeof params.tool_choice === 'object') {
+                    toolChoice = {
+                        tool: {
+                            name: params.tool_choice.function.name,
+                        },
+                    };
+                }
+                else if (typeof params.tool_choice === 'string') {
+                    if (params.tool_choice === 'required') {
+                        toolChoice = {
+                            any: {},
+                        };
+                    }
+                    else if (params.tool_choice === 'auto') {
+                        toolChoice = {
+                            auto: {},
+                        };
+                    }
+                }
+            }
+            return toolChoice ? { ...toolConfig, toolChoice } : toolConfig;
+        },
+    },
+    guardrailConfig: {
+        param: 'guardrailConfig',
+        required: false,
+    },
+    guardrail_config: {
+        param: 'guardrailConfig',
+        required: false,
+    },
+    additionalModelResponseFieldPaths: {
+        param: 'additionalModelResponseFieldPaths',
+        required: false,
+    },
+    additional_model_response_field_paths: {
+        param: 'additionalModelResponseFieldPaths',
+        required: false,
+    },
+    max_tokens: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    max_completion_tokens: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    stop: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    temperature: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    top_p: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    additionalModelRequestFields: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAdditionalModelRequestFields(params),
+    },
+    additional_model_request_fields: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAdditionalModelRequestFields(params),
+    },
+    performance_config: {
+        param: 'performanceConfig',
+        required: false,
+    },
+    output_config: {
+        param: 'outputConfig',
+        transform: (params) => {
+            if (!params.output_config?.format?.schema) {
+                return undefined;
+            }
+            const { schema } = params.output_config.format;
+            return {
+                textFormat: {
+                    type: 'json_schema',
+                    structure: {
+                        jsonSchema: {
+                            schema: typeof schema === 'string' ? schema : JSON.stringify(schema),
+                            name: schema?.title || 'response_schema',
+                        },
+                    },
+                },
+            };
+        },
+    },
+    response_format: {
+        param: 'response_format',
+        removeFromParams: true,
+    },
+    // Strip root cache_control — Converse uses cachePoint blocks, not Anthropic top-level caching.
+    cache_control: {
+        param: 'cache_control',
+        removeFromParams: true,
+    },
+};
+export const BedrockErrorResponseTransform = response => {
+    if ('message' in response) {
+        return generateErrorResponse({ message: response.message, type: null, code: null }, BEDROCK);
+    }
+    return undefined;
+};
+export const BedrockChatCompleteResponseTransform = (response, responseStatus, responseHeaders, strictOpenAiCompliance, _gatewayRequestUrl, gatewayRequest, isCursorEndpoint) => {
+    if (responseStatus !== 200) {
+        const errorResponse = BedrockErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    if ('output' in response) {
+        const cacheReadInputTokens = response.usage?.cacheReadInputTokens || 0;
+        const cacheWriteInputTokens = response.usage?.cacheWriteInputTokens || 0;
+        const content = response.output.message.content
+            .filter(item => item.text)
+            .map(item => item.text)
+            .join('');
+        // Extract Bedrock reasoning blocks to build thinking_blocks and reasoning_content.
+        const reasoningContentBlocks = response.output.message.content
+            .map(item => item.reasoningContent)
+            .filter((rc) => rc !== undefined);
+        // Unified thinking_blocks format (same as Anthropic) — always included when present.
+        const thinking_blocks = reasoningContentBlocks
+            .map(rc => {
+            if (rc.reasoningText) {
+                return {
+                    type: 'thinking',
+                    thinking: rc.reasoningText.text,
+                    ...(rc.reasoningText.signature && { signature: rc.reasoningText.signature }),
+                };
+            }
+            if (rc.redactedContent) {
+                return { type: 'redacted_thinking', data: rc.redactedContent };
+            }
+            return null;
+        })
+            .filter((b) => b !== null);
+        // Aggregated thinking text for the reasoning_content convenience field.
+        const reasoning_content = reasoningContentBlocks.map(rc => rc.reasoningText?.text ?? '').join('');
+        const responseObj = {
+            id: Date.now().toString(),
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model || 'unknown',
+            provider: BEDROCK,
+            choices: [
+                {
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content,
+                        ...(thinking_blocks.length > 0 && { thinking_blocks }),
+                        ...(reasoning_content && { reasoning_content }),
+                    },
+                    finish_reason: transformFinishReason(response.stopReason, strictOpenAiCompliance),
+                },
+            ],
+            usage: {
+                prompt_tokens: response.usage.inputTokens + cacheReadInputTokens + cacheWriteInputTokens,
+                completion_tokens: response.usage.outputTokens,
+                total_tokens: response.usage.totalTokens, // contains the cache usage as well
+                prompt_tokens_details: {
+                    cached_tokens: cacheReadInputTokens,
+                },
+                // we only want to be sending this for anthropic and bedrock models and this is not openai compliant
+                ...((cacheReadInputTokens > 0 || cacheWriteInputTokens > 0) && {
+                    cache_read_input_tokens: cacheReadInputTokens,
+                    cache_creation_input_tokens: cacheWriteInputTokens,
+                }),
+            },
+        };
+        const cursorFreeformToolNames = isCursorEndpoint
+            ? getCursorFreeformToolNames(gatewayRequest.tools)
+            : new Set();
+        const toolCalls = response.output.message.content
+            .filter(content => content.toolUse)
+            .map(content => {
+            // `JSON.stringify(undefined)` returns undefined, not a string, which would put a
+            // non-string in `arguments`. The streaming path emits '{}' for an argument-less call.
+            const args = JSON.stringify(content?.toolUse?.input ?? {});
+            const name = content?.toolUse?.name;
+            return {
+                id: content?.toolUse?.toolUseId,
+                type: 'function',
+                function: {
+                    name,
+                    arguments: name && cursorFreeformToolNames.has(name) ? unwrapCursorFreeformPayload(args) : args,
+                },
+            };
+        });
+        if (toolCalls.length > 0)
+            responseObj.choices[0].message.tool_calls = toolCalls;
+        return responseObj;
+    }
+    return generateInvalidProviderResponseError(response, BEDROCK);
+};
+export const BedrockCursorChatCompleteResponseTransform = (...args) => BedrockChatCompleteResponseTransform(args[0], args[1], args[2], args[3], args[4], args[5], true);
+// refer: https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html
+export const BedrockChatCompleteStreamChunkTransform = (responseChunk, fallbackId, streamState, strictOpenAiCompliance, gatewayRequest, isCursorEndpoint) => {
+    const parsedChunk = JSON.parse(responseChunk);
+    if (parsedChunk.message) {
+        return getBedrockErrorChunk(fallbackId, gatewayRequest.model || 'unknown');
+    }
+    if (parsedChunk.stopReason) {
+        streamState.stopReason = parsedChunk.stopReason;
+    }
+    if (streamState.currentToolCallIndex === undefined) {
+        streamState.currentToolCallIndex = -1;
+    }
+    // final chunk
+    if (parsedChunk.usage) {
+        const cacheReadInputTokens = parsedChunk.usage?.cacheReadInputTokens || 0;
+        const cacheWriteInputTokens = parsedChunk.usage?.cacheWriteInputTokens || 0;
+        return [
+            `data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: gatewayRequest.model || 'unknown',
+                provider: BEDROCK,
+                choices: [
+                    {
+                        index: 0,
+                        delta: {},
+                        finish_reason: transformFinishReason(streamState.stopReason, strictOpenAiCompliance),
+                    },
+                ],
+                usage: {
+                    prompt_tokens: parsedChunk.usage.inputTokens + cacheReadInputTokens + cacheWriteInputTokens,
+                    completion_tokens: parsedChunk.usage.outputTokens ?? 0,
+                    total_tokens: parsedChunk.usage.totalTokens,
+                    prompt_tokens_details: {
+                        cached_tokens: cacheReadInputTokens,
+                    },
+                    // we only want to be sending this for anthropic models and this is not openai compliant
+                    ...((cacheReadInputTokens > 0 || cacheWriteInputTokens > 0) && {
+                        cache_read_input_tokens: cacheReadInputTokens,
+                        cache_creation_input_tokens: cacheWriteInputTokens,
+                    }),
+                },
+            })}\n\n`,
+            `data: [DONE]\n\n`,
+        ];
+    }
+    // Tools converted from `custom` answer with `{"input":"<payload>"}`. The wrapper can only be
+    // stripped once the JSON is complete, so their deltas are buffered and released whole on
+    // contentBlockStop. Every other tool call streams through untouched.
+    const cursorFreeformToolNames = isCursorEndpoint
+        ? getCursorFreeformToolNames(gatewayRequest.tools)
+        : new Set();
+    const isCursorFreeformToolBlock = () => !!streamState.currentToolName && cursorFreeformToolNames.has(streamState.currentToolName);
+    const toolCalls = [];
+    if (parsedChunk.start?.toolUse) {
+        streamState.currentToolCallIndex = streamState.currentToolCallIndex + 1;
+        streamState.currentToolBlockHasArgs = false;
+        streamState.currentContentBlockType = 'toolUse';
+        streamState.currentToolName = parsedChunk.start.toolUse.name;
+        streamState.cursorBufferedToolArguments = undefined;
+        toolCalls.push({
+            index: streamState.currentToolCallIndex,
+            id: parsedChunk.start.toolUse.toolUseId,
+            type: 'function',
+            function: {
+                name: parsedChunk.start.toolUse.name,
+                // Bedrock's contentBlockStart for toolUse never carries input — only toolUseId + name.
+                // Arguments arrive exclusively via contentBlockDelta.delta.toolUse.input.
+                arguments: '',
+            },
+        });
+    }
+    else if (parsedChunk.start?.reasoningContent !== undefined) {
+        // Reasoning blocks also emit contentBlockStart/Stop events. Track their type so the
+        // zero-arg heuristic below does not misfire on their contentBlockStop.
+        streamState.currentContentBlockType = 'reasoningContent';
+        streamState.currentToolBlockHasArgs = false;
+    }
+    else if (parsedChunk.delta?.toolUse) {
+        streamState.currentToolBlockHasArgs = true;
+        if (isCursorFreeformToolBlock()) {
+            streamState.cursorBufferedToolArguments =
+                (streamState.cursorBufferedToolArguments ?? '') + (parsedChunk.delta.toolUse.input ?? '');
+        }
+        else {
+            toolCalls.push({
+                index: streamState.currentToolCallIndex,
+                // id/name are undefined on delta events — omit them so consumers see only the arg fragment.
+                function: {
+                    arguments: parsedChunk.delta.toolUse.input,
+                },
+            });
+        }
+    }
+    else if (isCursorEndpoint &&
+        parsedChunk.contentBlockIndex !== undefined &&
+        !parsedChunk.start &&
+        !parsedChunk.delta &&
+        !parsedChunk.stopReason &&
+        !parsedChunk.usage &&
+        streamState.currentContentBlockType === 'toolUse' &&
+        streamState.cursorBufferedToolArguments !== undefined &&
+        streamState.currentToolCallIndex !== undefined &&
+        streamState.currentToolCallIndex >= 0) {
+        toolCalls.push({
+            index: streamState.currentToolCallIndex,
+            function: { arguments: unwrapCursorFreeformPayload(streamState.cursorBufferedToolArguments) },
+        });
+        streamState.cursorBufferedToolArguments = undefined;
+        streamState.currentToolName = undefined;
+        streamState.currentContentBlockType = undefined;
+        streamState.currentToolBlockHasArgs = false;
+    }
+    else if (
+    // contentBlockStop: {contentBlockIndex: N} with no start/delta/stopReason/usage.
+    // Only emit '{}' when this is actually a tool block that received no argument deltas.
+    // Reasoning blocks also emit contentBlockStop with the same shape — currentContentBlockType
+    // distinguishes them so we do not spuriously emit a duplicate {} tool-call chunk.
+    parsedChunk.contentBlockIndex !== undefined &&
+        !parsedChunk.start &&
+        !parsedChunk.delta &&
+        !parsedChunk.stopReason &&
+        !parsedChunk.usage &&
+        streamState.currentContentBlockType === 'toolUse' &&
+        !streamState.currentToolBlockHasArgs &&
+        streamState.currentToolCallIndex !== undefined &&
+        streamState.currentToolCallIndex >= 0) {
+        toolCalls.push({
+            index: streamState.currentToolCallIndex,
+            function: { arguments: '{}' },
+        });
+        streamState.currentContentBlockType = undefined;
+        streamState.currentToolBlockHasArgs = false;
+        streamState.currentToolName = undefined;
+    }
+    else if (
+    // Any other contentBlockStop (text, reasoning, etc.) — just clear the block type.
+    parsedChunk.contentBlockIndex !== undefined &&
+        !parsedChunk.start &&
+        !parsedChunk.delta &&
+        !parsedChunk.stopReason &&
+        !parsedChunk.usage) {
+        streamState.currentContentBlockType = undefined;
+        streamState.currentToolBlockHasArgs = false;
+        streamState.currentToolName = undefined;
+    }
+    const content = parsedChunk.delta?.text;
+    // Build thinking_blocks delta and provider_specific_fields from Bedrock reasoningContent.
+    // Each reasoning event is emitted immediately (text chunk, signature chunk, or redacted chunk).
+    // Redacted thinking blocks may arrive in the `start` event (not `delta`).
+    let streamThinkingBlocks;
+    let reasoning_content_delta;
+    const rcDelta = parsedChunk.delta?.reasoningContent;
+    const rcStart = parsedChunk.start?.reasoningContent;
+    if (rcStart?.redactedContent !== undefined) {
+        // Redacted thinking is delivered in the contentBlockStart event, not in a delta.
+        streamThinkingBlocks = [{ type: 'redacted_thinking', data: rcStart.redactedContent }];
+    }
+    else if (rcDelta) {
+        if (rcDelta.text !== undefined) {
+            streamThinkingBlocks = [{ type: 'thinking', thinking: rcDelta.text }];
+            reasoning_content_delta = rcDelta.text;
+        }
+        else if (rcDelta.signature !== undefined) {
+            // Signature arrives as a separate delta; set reasoning_content to "" for stream consistency
+            streamThinkingBlocks = [{ type: 'thinking', signature: rcDelta.signature, thinking: '' }];
+            reasoning_content_delta = '';
+        }
+        else if (rcDelta.redactedContent !== undefined) {
+            streamThinkingBlocks = [{ type: 'redacted_thinking', data: rcDelta.redactedContent }];
+        }
+    }
+    return `data: ${JSON.stringify({
+        id: fallbackId,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model: gatewayRequest.model || 'unknown',
+        provider: BEDROCK,
+        choices: [
+            {
+                index: 0,
+                delta: {
+                    role: 'assistant',
+                    content,
+                    // Incremental reasoning text (empty string on signature delta)
+                    ...(reasoning_content_delta !== undefined && { reasoning_content: reasoning_content_delta }),
+                    // Per-delta thinking_blocks (same structure as Anthropic for cross-provider consistency)
+                    ...(streamThinkingBlocks && { thinking_blocks: streamThinkingBlocks }),
+                    tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                },
+                finish_reason: null,
+            },
+        ],
+    })}\n\n`;
+};
+export const BedrockCursorChatCompleteStreamChunkTransform = (...args) => BedrockChatCompleteStreamChunkTransform(args[0], args[1], args[2], args[3], args[4], true);
+// `required: true` plus an identical `default` means the providerOptions-only path
+// (header set, no body field) still resolves betas — `transformUsingProviderConfig`
+// only runs `transform` when the key is present in the request.
+const buildConverseAnthropicBeta = (params, transformInput) => resolveAnthropicBetas(mergeAnthropicBetasWithOverride(anthropicBetaResolveFromParamMap(transformInput), params?.anthropic_beta), BEDROCK_CONVERSE_BETA_KEY);
+// Bedrock gates tool search behind a beta the caller never sends, since it is GA on the
+// first-party API — hence resolving the tools here too, not just in the `tools` transform.
+// Note: an `x-tfy-anthropic-beta` override (GATEWAY-2923) suppresses this auto-added beta too.
+const buildInvokeAnthropicBeta = (params, transformInput) => resolveAnthropicBetas(mergeAnthropicBetasWithOverride(anthropicBetaResolveFromParamMap(transformInput), params?.anthropic_beta, resolveServerTools(params?.tools, BEDROCK_INVOKE_BETA_KEY).betas), BEDROCK_INVOKE_BETA_KEY);
+/**
+ * ================================
+ * NOTE - Add response_format to the request transform
+ * ================================
+ */
+export const BedrockConverseAnthropicChatCompleteConfig = {
+    ...BedrockConverseChatCompleteConfig,
+    additionalModelRequestFields: {
+        param: 'additionalModelRequestFields',
+        transform: (params, transformInput) => transformAnthropicAdditionalModelRequestFields(params, transformInput),
+    },
+    additional_model_request_fields: {
+        param: 'additionalModelRequestFields',
+        transform: (params, transformInput) => transformAnthropicAdditionalModelRequestFields(params, transformInput),
+    },
+    top_k: {
+        param: 'additionalModelRequestFields',
+        transform: (params, transformInput) => transformAnthropicAdditionalModelRequestFields(params, transformInput),
+    },
+    anthropic_version: {
+        param: 'additionalModelRequestFields',
+        transform: (params, transformInput) => transformAnthropicAdditionalModelRequestFields(params, transformInput),
+    },
+    user: {
+        param: 'additionalModelRequestFields',
+        transform: (params, transformInput) => transformAnthropicAdditionalModelRequestFields(params, transformInput),
+    },
+    thinking: {
+        param: 'additionalModelRequestFields',
+        transform: (params, transformInput) => transformAnthropicAdditionalModelRequestFields(params, transformInput),
+    },
+    reasoning_effort: {
+        param: 'additionalModelRequestFields',
+        transform: (params, transformInput) => {
+            const effort = params.reasoning_effort;
+            const base = transformAnthropicAdditionalModelRequestFields(params, transformInput);
+            if (!effort) {
+                return base;
+            }
+            const model = params.model ?? '';
+            // Amazon Nova 2 models use reasoningConfig, not thinking.
+            const isNova2 = model.includes('nova-2') || model.includes('nova2');
+            if (isNova2) {
+                if (effort === 'none') {
+                    return base;
+                }
+                return {
+                    ...base,
+                    reasoningConfig: {
+                        type: 'enabled',
+                        maxReasoningEffort: effort,
+                    },
+                };
+            }
+            if (effort === 'none') {
+                return {
+                    ...base,
+                    thinking: { type: 'disabled' },
+                };
+            }
+            // Claude 4-6+ models require {type: 'adaptive'} — no budget_tokens.
+            if (isClaudeAdaptiveThinkingModel(model)) {
+                const effortMap = {
+                    minimal: 'low',
+                    low: 'low',
+                    medium: 'medium',
+                    high: 'high',
+                    xhigh: 'xhigh',
+                    max: 'max',
+                };
+                return {
+                    ...base,
+                    thinking: { type: 'adaptive' },
+                    output_config: { effort: params.output_config?.effort ?? effortMap[effort] ?? effort },
+                };
+            }
+            // All other Anthropic models on Bedrock: {type: 'enabled', budget_tokens: N}.
+            // Bedrock enforces a minimum of 1024 budget_tokens.
+            const maxTokens = params.max_completion_tokens || params.max_tokens || 2048;
+            const budgetTokens = Math.max(1024, calculateBudgetTokens(maxTokens, effort));
+            return {
+                ...base,
+                thinking: { type: 'enabled', budget_tokens: budgetTokens },
+            };
+        },
+    },
+    anthropic_beta: {
+        param: 'additionalModelRequestFields.anthropic_beta',
+        required: true,
+        default: buildConverseAnthropicBeta,
+        transform: buildConverseAnthropicBeta,
+    },
+    output_config: {
+        param: 'outputConfig',
+        transform: (params) => {
+            if (!params.output_config?.format?.schema) {
+                return undefined;
+            }
+            const { schema } = params.output_config.format;
+            return {
+                textFormat: {
+                    type: 'json_schema',
+                    structure: {
+                        jsonSchema: {
+                            schema: typeof schema === 'string' ? schema : JSON.stringify(schema),
+                            name: schema?.title || 'response_schema',
+                        },
+                    },
+                },
+            };
+        },
+    },
+    /**
+     * ================================
+     * NOTE - support for response_format is handled by universal response format transform
+     * ================================
+     */
+    response_format: {
+        param: 'response_format',
+        removeFromParams: true, // Handled by universal response format transform
+    },
+    /**
+     * ================================
+     * NOTE: Remove stream_options from the request body
+     * ================================
+     */
+    stream_options: {
+        param: 'stream_options',
+        removeFromParams: true,
+    },
+};
+/** OpenAI chat completions translated to Anthropic Messages for Bedrock InvokeModel. */
+export const BedrockAnthropicInvokeChatCompleteConfig = {
+    ...AnthropicChatCompleteConfig,
+    // The model is part of the InvokeModel URL.
+    model: {
+        param: 'model',
+        required: false,
+        transform: () => undefined,
+    },
+    // Streaming is selected by the endpoint.
+    stream: {
+        param: 'stream',
+        removeFromParams: true,
+    },
+    anthropic_version: {
+        param: 'anthropic_version',
+        required: true,
+        default: 'bedrock-2023-05-31',
+    },
+    // Run the default when beta features come only from provider options.
+    anthropic_beta: {
+        param: 'anthropic_beta',
+        required: true,
+        default: buildInvokeAnthropicBeta,
+        transform: buildInvokeAnthropicBeta,
+    },
+    tools: {
+        param: 'tools',
+        required: false,
+        transform: (params, transformInput) => {
+            const baseTransform = AnthropicChatCompleteConfig.tools?.transform;
+            const tools = baseTransform ? baseTransform(params, transformInput) : params.tools;
+            if (!Array.isArray(tools))
+                return tools;
+            const model = params.model ?? '';
+            const stripped = isBedrockEagerInputStreamingSupported(model)
+                ? tools
+                : tools.map((tool) => {
+                    const { eager_input_streaming: _omit, ...rest } = tool;
+                    return rest;
+                });
+            return resolveServerTools(stripped, BEDROCK_INVOKE_BETA_KEY).tools;
+        },
+    },
+    // Remove fields that do not belong in the native Anthropic body.
+    guardrailConfig: {
+        param: 'guardrailConfig',
+        removeFromParams: true,
+    },
+    guardrail_config: {
+        param: 'guardrail_config',
+        removeFromParams: true,
+    },
+    performance_config: {
+        param: 'performance_config',
+        removeFromParams: true,
+    },
+    additionalModelRequestFields: {
+        param: 'additionalModelRequestFields',
+        removeFromParams: true,
+    },
+    additional_model_request_fields: {
+        param: 'additional_model_request_fields',
+        removeFromParams: true,
+    },
+    additionalModelResponseFieldPaths: {
+        param: 'additionalModelResponseFieldPaths',
+        removeFromParams: true,
+    },
+    additional_model_response_field_paths: {
+        param: 'additional_model_response_field_paths',
+        removeFromParams: true,
+    },
+};
+// Bedrock and Anthropic use different error shapes.
+export const BedrockAnthropicInvokeChatCompleteResponseTransform = (response, responseStatus, responseHeaders, strictOpenAiCompliance) => {
+    if (responseStatus !== 200) {
+        const errorResponse = BedrockErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    return getAzureAnthropicChatCompleteResponseTransform(BEDROCK)(response, responseStatus, responseHeaders, strictOpenAiCompliance);
+};
+// Convert decoded Bedrock events to the SSE format expected by the shared transform.
+export const BedrockAnthropicInvokeChatCompleteStreamChunkTransform = (responseChunk, fallbackId, streamState, strictOpenAiCompliance) => {
+    let event;
+    try {
+        event = JSON.parse(responseChunk);
+    }
+    catch (error) {
+        logger.error('Failed to parse Bedrock Anthropic InvokeModel streaming chunk:', error);
+        return undefined;
+    }
+    const sseChunk = `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
+    return getAzureAnthropicStreamChunkTransform(BEDROCK)(sseChunk, fallbackId, streamState, strictOpenAiCompliance);
+};
+export const BedrockConverseCohereChatCompleteConfig = {
+    ...BedrockConverseChatCompleteConfig,
+    additionalModelRequestFields: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformCohereAdditionalModelRequestFields(params),
+    },
+    additional_model_request_fields: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformCohereAdditionalModelRequestFields(params),
+    },
+    top_k: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformCohereAdditionalModelRequestFields(params),
+    },
+    frequency_penalty: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformCohereAdditionalModelRequestFields(params),
+    },
+    presence_penalty: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformCohereAdditionalModelRequestFields(params),
+    },
+    logit_bias: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformCohereAdditionalModelRequestFields(params),
+    },
+    n: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformCohereAdditionalModelRequestFields(params),
+    },
+};
+export const BedrockConverseAI21ChatCompleteConfig = {
+    ...BedrockConverseChatCompleteConfig,
+    additionalModelRequestFields: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAI21AdditionalModelRequestFields(params),
+    },
+    additional_model_request_fields: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAI21AdditionalModelRequestFields(params),
+    },
+    top_k: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAI21AdditionalModelRequestFields(params),
+    },
+    frequency_penalty: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAI21AdditionalModelRequestFields(params),
+    },
+    presence_penalty: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAI21AdditionalModelRequestFields(params),
+    },
+    frequencyPenalty: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAI21AdditionalModelRequestFields(params),
+    },
+    presencePenalty: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAI21AdditionalModelRequestFields(params),
+    },
+    countPenalty: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAI21AdditionalModelRequestFields(params),
+    },
+};
+export const BedrockCohereChatCompleteConfig = {
+    messages: {
+        param: 'prompt',
+        required: true,
+        transform: (params) => {
+            let prompt = '';
+            if (params.messages) {
+                const messages = params.messages;
+                messages.forEach((msg, index) => {
+                    if (index === 0 && SYSTEM_MESSAGE_ROLES.includes(msg.role)) {
+                        prompt += `system: ${messages}\n`;
+                    }
+                    else if (msg.role == 'user') {
+                        prompt += `user: ${msg.content}\n`;
+                    }
+                    else if (msg.role == 'assistant') {
+                        prompt += `assistant: ${msg.content}\n`;
+                    }
+                    else {
+                        prompt += `${msg.role}: ${msg.content}\n`;
+                    }
+                });
+                prompt += 'Assistant:';
+            }
+            return prompt;
+        },
+    },
+    max_tokens: {
+        param: 'max_tokens',
+        min: 1,
+    },
+    max_completion_tokens: {
+        param: 'max_tokens',
+        min: 1,
+    },
+    temperature: {
+        param: 'temperature',
+        default: 0.75,
+        min: 0,
+        max: 5,
+    },
+    top_p: {
+        param: 'p',
+        default: 0.75,
+        min: 0,
+        max: 1,
+    },
+    top_k: {
+        param: 'k',
+        default: 0,
+        max: 500,
+    },
+    frequency_penalty: {
+        param: 'frequency_penalty',
+        default: 0,
+        min: 0,
+        max: 1,
+    },
+    presence_penalty: {
+        param: 'presence_penalty',
+        default: 0,
+        min: 0,
+        max: 1,
+    },
+    logit_bias: {
+        param: 'logit_bias',
+    },
+    n: {
+        param: 'num_generations',
+        default: 1,
+        min: 1,
+        max: 5,
+    },
+    stop: {
+        param: 'end_sequences',
+    },
+    stream: {
+        param: 'stream',
+    },
+};
+export const BedrockCohereChatCompleteResponseTransform = (response, responseStatus, responseHeaders, _strictOpenAiCompliance, _gatewayRequestUrl, gatewayRequest) => {
+    if (responseStatus !== 200) {
+        const errorResponse = BedrockErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    const model = gatewayRequest.model || 'unknown';
+    if ('generations' in response) {
+        const prompt_tokens = Number(responseHeaders.get('X-Amzn-Bedrock-Input-Token-Count')) || 0;
+        const completion_tokens = Number(responseHeaders.get('X-Amzn-Bedrock-Output-Token-Count')) || 0;
+        return {
+            id: Date.now().toString(),
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model,
+            provider: BEDROCK,
+            choices: response.generations.map((generation, index) => ({
+                index: index,
+                message: {
+                    role: 'assistant',
+                    content: generation.text,
+                },
+                finish_reason: generation.finish_reason,
+            })),
+            usage: {
+                prompt_tokens: prompt_tokens,
+                completion_tokens: completion_tokens,
+                total_tokens: prompt_tokens + completion_tokens,
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, BEDROCK);
+};
+export const BedrockCohereChatCompleteStreamChunkTransform = (responseChunk, fallbackId, _streamState, _strictOpenAiCompliance, gatewayRequest) => {
+    let chunk = responseChunk.trim();
+    chunk = chunk.replace(/^data: /, '');
+    chunk = chunk.trim();
+    const parsedChunk = JSON.parse(chunk);
+    const model = gatewayRequest.model || 'unknown';
+    // discard the last cohere chunk as it sends the whole response combined.
+    if (parsedChunk.is_finished) {
+        return [
+            `data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model,
+                provider: BEDROCK,
+                choices: [
+                    {
+                        index: parsedChunk.index ?? 0,
+                        delta: {},
+                        finish_reason: parsedChunk.finish_reason,
+                    },
+                ],
+                usage: {
+                    prompt_tokens: parsedChunk['amazon-bedrock-invocationMetrics'].inputTokenCount,
+                    completion_tokens: parsedChunk['amazon-bedrock-invocationMetrics'].outputTokenCount,
+                    total_tokens: parsedChunk['amazon-bedrock-invocationMetrics'].inputTokenCount +
+                        parsedChunk['amazon-bedrock-invocationMetrics'].outputTokenCount,
+                },
+            })}\n\n`,
+            `data: [DONE]\n\n`,
+        ];
+    }
+    return `data: ${JSON.stringify({
+        id: fallbackId,
+        object: 'chat.completion.chunk',
+        created: Math.floor(Date.now() / 1000),
+        model,
+        provider: BEDROCK,
+        choices: [
+            {
+                index: parsedChunk.index ?? 0,
+                delta: {
+                    role: 'assistant',
+                    content: parsedChunk.text,
+                },
+                finish_reason: null,
+            },
+        ],
+    })}\n\n`;
+};
+export const BedrockAI21ChatCompleteConfig = {
+    messages: {
+        param: 'prompt',
+        required: true,
+        transform: (params) => {
+            let prompt = '';
+            if (params.messages) {
+                const messages = params.messages;
+                messages.forEach((msg, index) => {
+                    if (index === 0 && SYSTEM_MESSAGE_ROLES.includes(msg.role)) {
+                        prompt += `system: ${messages}\n`;
+                    }
+                    else if (msg.role == 'user') {
+                        prompt += `user: ${msg.content}\n`;
+                    }
+                    else if (msg.role == 'assistant') {
+                        prompt += `assistant: ${msg.content}\n`;
+                    }
+                    else {
+                        prompt += `${msg.role}: ${msg.content}\n`;
+                    }
+                });
+                prompt += 'Assistant:';
+            }
+            return prompt;
+        },
+    },
+    max_tokens: {
+        param: 'maxTokens',
+    },
+    max_completion_tokens: {
+        param: 'maxTokens',
+    },
+    temperature: {
+        param: 'temperature',
+        default: 0.7,
+        min: 0,
+        max: 1,
+    },
+    top_p: {
+        param: 'topP',
+        default: 1,
+    },
+    stop: {
+        param: 'stopSequences',
+    },
+    presence_penalty: {
+        param: 'presencePenalty',
+        transform: (params) => {
+            return {
+                scale: params.presence_penalty,
+            };
+        },
+    },
+    frequency_penalty: {
+        param: 'frequencyPenalty',
+        transform: (params) => {
+            return {
+                scale: params.frequency_penalty,
+            };
+        },
+    },
+    countPenalty: {
+        param: 'countPenalty',
+    },
+    frequencyPenalty: {
+        param: 'frequencyPenalty',
+    },
+    presencePenalty: {
+        param: 'presencePenalty',
+    },
+};
+export const BedrockAI21ChatCompleteResponseTransform = (response, responseStatus, responseHeaders, _strictOpenAiCompliance, _gatewayRequestUrl, gatewayRequest) => {
+    if (responseStatus !== 200) {
+        const errorResponse = BedrockErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    if ('completions' in response) {
+        const prompt_tokens = Number(responseHeaders.get('X-Amzn-Bedrock-Input-Token-Count')) || 0;
+        const completion_tokens = Number(responseHeaders.get('X-Amzn-Bedrock-Output-Token-Count')) || 0;
+        return {
+            id: response.id.toString(),
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model ?? 'unknown',
+            provider: BEDROCK,
+            choices: response.completions.map((completion, index) => ({
+                index: index,
+                message: {
+                    role: 'assistant',
+                    content: completion.data.text,
+                },
+                finish_reason: completion.finishReason?.reason,
+            })),
+            usage: {
+                prompt_tokens: prompt_tokens,
+                completion_tokens: completion_tokens,
+                total_tokens: prompt_tokens + completion_tokens,
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, BEDROCK);
+};
+//# sourceMappingURL=chatComplete.js.map