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

package/dist/providers/bedrock/complete.js

@@ -0,0 +1,868 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * But needs some custom changes for TFY
+ * 1. Add BedrockConverseCompleteConfig + response transforms to support
+ *    OpenAI-style text completion (`/v1/completions`) on models that lack
+ *    a native legacy InvokeModel completion path. Translates `prompt` into
+ *    Converse messages and converts the Converse response back into the
+ *    OpenAI `text_completion` shape.
+ * ================================
+ */
+import { BEDROCK } from '../../globals.js';
+import { hashUserId } from '../anthropic/utils.js';
+import { generateInvalidProviderResponseError, transformFinishReason } from '../utils.js';
+import { BedrockErrorResponseTransform } from './chatComplete.js';
+import { transformAdditionalModelRequestFields, transformInferenceConfig } from './utils.js';
+export const BedrockAnthropicCompleteConfig = {
+    prompt: {
+        param: 'prompt',
+        transform: (params) => `\n\nHuman: ${params.prompt}\n\nAssistant:`,
+        required: true,
+    },
+    max_tokens: {
+        param: 'max_tokens_to_sample',
+        required: true,
+    },
+    temperature: {
+        param: 'temperature',
+        default: 1,
+        min: 0,
+        max: 1,
+    },
+    top_p: {
+        param: 'top_p',
+        default: -1,
+        min: -1,
+    },
+    top_k: {
+        param: 'top_k',
+        default: -1,
+    },
+    stop: {
+        param: 'stop_sequences',
+        transform: (params) => {
+            if (params.stop === null) {
+                return [];
+            }
+            return params.stop;
+        },
+    },
+    user: {
+        param: 'metadata.user_id',
+        transform: (params) => hashUserId(params.user),
+    },
+};
+export const BedrockCohereCompleteConfig = {
+    prompt: {
+        param: 'prompt',
+        required: true,
+    },
+    max_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 BedrockLLamaCompleteConfig = {
+    prompt: {
+        param: 'prompt',
+        required: true,
+    },
+    max_tokens: {
+        param: 'max_gen_len',
+        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,
+    },
+};
+export const BedrockMistralCompleteConfig = {
+    prompt: {
+        param: 'prompt',
+        required: true,
+    },
+    max_tokens: {
+        param: 'max_tokens',
+        min: 1,
+    },
+    temperature: {
+        param: 'temperature',
+        default: 0.75,
+        min: 0,
+        max: 5,
+    },
+    top_p: {
+        param: 'top_p',
+        default: 0.75,
+        min: 0,
+        max: 1,
+    },
+    top_k: {
+        param: 'top_k',
+        default: 0,
+    },
+    stop: {
+        param: 'stop',
+    },
+};
+const transformTitanGenerationConfig = (params) => {
+    const generationConfig = {};
+    if (params['temperature']) {
+        generationConfig['temperature'] = params['temperature'];
+    }
+    if (params['top_p']) {
+        generationConfig['topP'] = params['top_p'];
+    }
+    if (params['max_tokens']) {
+        generationConfig['maxTokenCount'] = params['max_tokens'];
+    }
+    if (params['stop']) {
+        generationConfig['stopSequences'] = params['stop'];
+    }
+    return generationConfig;
+};
+export const BedrockTitanCompleteConfig = {
+    prompt: {
+        param: 'inputText',
+        required: true,
+    },
+    temperature: {
+        param: 'textGenerationConfig',
+        transform: (params) => transformTitanGenerationConfig(params),
+    },
+    max_tokens: {
+        param: 'textGenerationConfig',
+        transform: (params) => transformTitanGenerationConfig(params),
+    },
+    top_p: {
+        param: 'textGenerationConfig',
+        transform: (params) => transformTitanGenerationConfig(params),
+    },
+};
+export const BedrockAI21CompleteConfig = {
+    prompt: {
+        param: 'prompt',
+        required: true,
+    },
+    max_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 BedrockLlamaCompleteResponseTransform = (response, responseStatus, _responseHeaders, _strictOpenAiCompliance, _gatewayRequestUrl, gatewayRequest) => {
+    if (responseStatus !== 200) {
+        const errorResponse = BedrockErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    if ('generation' in response) {
+        return {
+            id: Date.now().toString(),
+            object: 'text_completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model ?? '',
+            provider: BEDROCK,
+            choices: [
+                {
+                    text: response.generation,
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: response.stop_reason,
+                },
+            ],
+            usage: {
+                prompt_tokens: response.prompt_token_count,
+                completion_tokens: response.generation_token_count,
+                total_tokens: response.prompt_token_count + response.generation_token_count,
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, BEDROCK);
+};
+export const BedrockLlamaCompleteStreamChunkTransform = (responseChunk, fallbackId, _streamState, _strictOpenAiCompliance, gatewayRequest) => {
+    let chunk = responseChunk.trim();
+    chunk = chunk.trim();
+    const parsedChunk = JSON.parse(chunk);
+    const model = gatewayRequest.model ?? '';
+    if (parsedChunk.stop_reason) {
+        return [
+            `data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'text_completion',
+                created: Math.floor(Date.now() / 1000),
+                model,
+                provider: BEDROCK,
+                choices: [
+                    {
+                        text: '',
+                        index: 0,
+                        logprobs: null,
+                        finish_reason: parsedChunk.stop_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: 'text_completion',
+        created: Math.floor(Date.now() / 1000),
+        model,
+        provider: BEDROCK,
+        choices: [
+            {
+                text: parsedChunk.generation,
+                index: 0,
+                logprobs: null,
+                finish_reason: null,
+            },
+        ],
+    })}\n\n`;
+};
+export const BedrockTitanCompleteResponseTransform = (response, responseStatus, responseHeaders, strictOpenAiCompliance, gatewayRequestUrl, gatewayRequest) => {
+    if (responseStatus !== 200) {
+        const errorResponse = BedrockErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    if ('results' in response) {
+        const completionTokens = response.results.map(r => r.tokenCount).reduce((partialSum, a) => partialSum + a, 0);
+        return {
+            id: Date.now().toString(),
+            object: 'text_completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model ?? '',
+            provider: BEDROCK,
+            choices: response.results.map((generation, index) => ({
+                text: generation.outputText,
+                index: index,
+                logprobs: null,
+                finish_reason: generation.completionReason,
+            })),
+            usage: {
+                prompt_tokens: response.inputTextTokenCount,
+                completion_tokens: completionTokens,
+                total_tokens: response.inputTextTokenCount + completionTokens,
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, BEDROCK);
+};
+export const BedrockTitanCompleteStreamChunkTransform = (responseChunk, fallbackId, _streamState, _strictOpenAiCompliance, gatewayRequest) => {
+    let chunk = responseChunk.trim();
+    chunk = chunk.trim();
+    const parsedChunk = JSON.parse(chunk);
+    return [
+        `data: ${JSON.stringify({
+            id: fallbackId,
+            object: 'text_completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model ?? '',
+            provider: BEDROCK,
+            choices: [
+                {
+                    text: parsedChunk.outputText,
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: null,
+                },
+            ],
+        })}\n\n`,
+        `data: ${JSON.stringify({
+            id: fallbackId,
+            object: 'text_completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model ?? '',
+            provider: BEDROCK,
+            choices: [
+                {
+                    text: '',
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: parsedChunk.completionReason,
+                },
+            ],
+            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`,
+    ];
+};
+export const BedrockAI21CompleteResponseTransform = (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: 'text_completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model ?? '',
+            provider: BEDROCK,
+            choices: response.completions.map((completion, index) => ({
+                text: completion.data.text,
+                index: index,
+                logprobs: null,
+                finish_reason: completion.finishReason?.reason,
+            })),
+            usage: {
+                prompt_tokens: prompt_tokens,
+                completion_tokens: completion_tokens,
+                total_tokens: prompt_tokens + completion_tokens,
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, BEDROCK);
+};
+export const BedrockAnthropicCompleteResponseTransform = (response, responseStatus, responseHeaders, _strictOpenAiCompliance, _gatewayRequestUrl, gatewayRequest) => {
+    if (responseStatus !== 200) {
+        const errorResponse = BedrockErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    if ('completion' 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: 'text_completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model ?? '',
+            provider: BEDROCK,
+            choices: [
+                {
+                    text: response.completion,
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: response.stop_reason,
+                },
+            ],
+            usage: {
+                prompt_tokens: prompt_tokens,
+                completion_tokens: completion_tokens,
+                total_tokens: prompt_tokens + completion_tokens,
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, BEDROCK);
+};
+export const BedrockAnthropicCompleteStreamChunkTransform = (responseChunk, fallbackId, _streamState, _strictOpenAiCompliance, gatewayRequest) => {
+    const chunk = responseChunk.trim();
+    const model = gatewayRequest.model ?? '';
+    const parsedChunk = JSON.parse(chunk);
+    if (parsedChunk.stop_reason) {
+        return [
+            `data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'text_completion',
+                created: Math.floor(Date.now() / 1000),
+                model,
+                provider: BEDROCK,
+                choices: [
+                    {
+                        text: parsedChunk.completion,
+                        index: 0,
+                        logprobs: null,
+                        finish_reason: null,
+                    },
+                ],
+            })}\n\n`,
+            `data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'text_completion',
+                created: Math.floor(Date.now() / 1000),
+                model,
+                provider: BEDROCK,
+                choices: [
+                    {
+                        text: '',
+                        index: 0,
+                        logprobs: null,
+                        finish_reason: parsedChunk.stop_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: 'text_completion',
+        created: Math.floor(Date.now() / 1000),
+        model,
+        provider: BEDROCK,
+        choices: [
+            {
+                text: parsedChunk.completion,
+                index: 0,
+                logprobs: null,
+                finish_reason: null,
+            },
+        ],
+    })}\n\n`;
+};
+export const BedrockCohereCompleteResponseTransform = (response, responseStatus, responseHeaders, _strictOpenAiCompliance, _gatewayRequestUrl, gatewayRequest) => {
+    if (responseStatus !== 200) {
+        const errorResponse = BedrockErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    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: response.id,
+            object: 'text_completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model ?? '',
+            provider: BEDROCK,
+            choices: response.generations.map((generation, index) => ({
+                text: generation.text,
+                index: index,
+                logprobs: null,
+                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 BedrockCohereCompleteStreamChunkTransform = (responseChunk, fallbackId, _streamState, _strictOpenAiCompliance, gatewayRequest) => {
+    let chunk = responseChunk.trim();
+    chunk = chunk.replace(/^data: /, '');
+    chunk = chunk.trim();
+    const parsedChunk = JSON.parse(chunk);
+    // discard the last cohere chunk as it sends the whole response combined.
+    if (parsedChunk.is_finished) {
+        return [
+            `data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'text_completion',
+                created: Math.floor(Date.now() / 1000),
+                model: gatewayRequest.model ?? '',
+                provider: BEDROCK,
+                choices: [
+                    {
+                        text: '',
+                        index: 0,
+                        logprobs: null,
+                        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: 'text_completion',
+        created: Math.floor(Date.now() / 1000),
+        model: gatewayRequest.model ?? '',
+        provider: BEDROCK,
+        choices: [
+            {
+                text: parsedChunk.text,
+                index: parsedChunk.index ?? 0,
+                logprobs: null,
+                finish_reason: null,
+            },
+        ],
+    })}\n\n`;
+};
+export const BedrockMistralCompleteStreamChunkTransform = (responseChunk, fallbackId, _streamState, _strictOpenAiCompliance, gatewayRequest) => {
+    let chunk = responseChunk.trim();
+    chunk = chunk.trim();
+    const parsedChunk = JSON.parse(chunk);
+    if (parsedChunk.outputs[0].stop_reason) {
+        return [
+            `data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'text_completion',
+                created: Math.floor(Date.now() / 1000),
+                model: gatewayRequest.model ?? '',
+                provider: BEDROCK,
+                choices: [
+                    {
+                        text: parsedChunk.outputs[0].text,
+                        index: 0,
+                        logprobs: null,
+                        finish_reason: parsedChunk.outputs[0].stop_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: 'text_completion',
+        created: Math.floor(Date.now() / 1000),
+        model: gatewayRequest.model ?? '',
+        provider: BEDROCK,
+        choices: [
+            {
+                text: parsedChunk.outputs[0].text,
+                index: 0,
+                logprobs: null,
+                finish_reason: null,
+            },
+        ],
+    })}\n\n`;
+};
+export const BedrockMistralCompleteResponseTransform = (response, responseStatus, responseHeaders, _strictOpenAiCompliance, _gatewayRequestUrl, gatewayRequest) => {
+    if (responseStatus !== 200) {
+        const errorResponse = BedrockErrorResponseTransform(response);
+        if (errorResponse)
+            return errorResponse;
+    }
+    if ('outputs' 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: 'text_completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model ?? '',
+            provider: BEDROCK,
+            choices: [
+                {
+                    text: response.outputs[0].text,
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: response.outputs[0].stop_reason,
+                },
+            ],
+            usage: {
+                prompt_tokens: prompt_tokens,
+                completion_tokens: completion_tokens,
+                total_tokens: prompt_tokens + completion_tokens,
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, BEDROCK);
+};
+// Prompt arrays are message segments joined into one user message (not separate
+// messages) to match OpenAI text-completion semantics and ensure cross-provider
+// consistency (same convention used in the Groq complete handler).
+const buildConversePromptMessages = (prompt) => {
+    if (prompt === undefined || prompt === null)
+        return [];
+    let text;
+    if (typeof prompt === 'string') {
+        text = prompt;
+    }
+    else if (Array.isArray(prompt)) {
+        text = prompt.map(p => (typeof p === 'string' ? p : String(p))).join('\n');
+    }
+    else {
+        text = String(prompt);
+    }
+    return [{ role: 'user', content: [{ text }] }];
+};
+// Inlined rather than spreading `BedrockConverseChatCompleteConfig` to avoid a
+// circular value-import (chatComplete.ts already imports types from this file).
+// We intentionally only carry over the params that are meaningful for an
+// OpenAI-style text completion request — tools, response_format, output_config,
+// etc. don't apply here.
+export const BedrockConverseCompleteConfig = {
+    prompt: {
+        param: 'messages',
+        required: true,
+        transform: (params) => buildConversePromptMessages(params.prompt),
+    },
+    max_tokens: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    max_completion_tokens: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    temperature: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    top_p: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    stop: {
+        param: 'inferenceConfig',
+        transform: (params) => transformInferenceConfig(params),
+    },
+    additionalModelRequestFields: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAdditionalModelRequestFields(params),
+    },
+    additional_model_request_fields: {
+        param: 'additionalModelRequestFields',
+        transform: (params) => transformAdditionalModelRequestFields(params),
+    },
+    guardrailConfig: {
+        param: 'guardrailConfig',
+        required: false,
+    },
+    guardrail_config: {
+        param: 'guardrailConfig',
+        required: false,
+    },
+    // Strip OpenAI text-completion-only params that have no Converse equivalent.
+    echo: {
+        param: 'echo',
+        removeFromParams: true,
+    },
+    best_of: {
+        param: 'best_of',
+        removeFromParams: true,
+    },
+    suffix: {
+        param: 'suffix',
+        removeFromParams: true,
+    },
+    logprobs: {
+        param: 'logprobs',
+        removeFromParams: true,
+    },
+    top_logprobs: {
+        param: 'top_logprobs',
+        removeFromParams: true,
+    },
+};
+export const BedrockConverseCompleteResponseTransform = (response, responseStatus, _responseHeaders, strictOpenAiCompliance, _gatewayRequestUrl, gatewayRequest) => {
+    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 text = response.output.message.content
+            .filter(item => item.text)
+            .map(item => item.text)
+            .join('');
+        return {
+            id: Date.now().toString(),
+            object: 'text_completion',
+            created: Math.floor(Date.now() / 1000),
+            model: gatewayRequest.model || 'unknown',
+            provider: BEDROCK,
+            choices: [
+                {
+                    text,
+                    index: 0,
+                    logprobs: null,
+                    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,
+                }),
+            },
+        };
+    }
+    return generateInvalidProviderResponseError(response, BEDROCK);
+};
+export const BedrockConverseCompleteStreamChunkTransform = (responseChunk, fallbackId, streamState, strictOpenAiCompliance, gatewayRequest) => {
+    const parsedChunk = JSON.parse(responseChunk);
+    const model = gatewayRequest.model || 'unknown';
+    if (parsedChunk.stopReason) {
+        streamState.stopReason = parsedChunk.stopReason;
+    }
+    // Final chunk carries usage; emit a closing text_completion chunk + DONE.
+    if (parsedChunk.usage) {
+        const cacheReadInputTokens = parsedChunk.usage?.cacheReadInputTokens || 0;
+        const cacheWriteInputTokens = parsedChunk.usage?.cacheWriteInputTokens || 0;
+        return [
+            `data: ${JSON.stringify({
+                id: fallbackId,
+                object: 'text_completion',
+                created: Math.floor(Date.now() / 1000),
+                model,
+                provider: BEDROCK,
+                choices: [
+                    {
+                        index: 0,
+                        text: '',
+                        logprobs: null,
+                        finish_reason: transformFinishReason(streamState.stopReason, strictOpenAiCompliance),
+                    },
+                ],
+                usage: {
+                    prompt_tokens: parsedChunk.usage.inputTokens + cacheReadInputTokens + cacheWriteInputTokens,
+                    completion_tokens: parsedChunk.usage.outputTokens,
+                    total_tokens: parsedChunk.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,
+                    }),
+                },
+            })}\n\n`,
+            `data: [DONE]\n\n`,
+        ];
+    }
+    // Only forward textual content deltas. Tool/reasoning blocks and
+    // contentBlockStart/Stop events are irrelevant for text completion output —
+    // returning undefined tells `readAWSStream` to skip the chunk entirely.
+    const text = parsedChunk.delta?.text;
+    if (!text) {
+        return undefined;
+    }
+    return `data: ${JSON.stringify({
+        id: fallbackId,
+        object: 'text_completion',
+        created: Math.floor(Date.now() / 1000),
+        model,
+        provider: BEDROCK,
+        choices: [
+            {
+                index: 0,
+                text,
+                logprobs: null,
+                finish_reason: null,
+            },
+        ],
+    })}\n\n`;
+};
+//# sourceMappingURL=complete.js.map