bedrock-wrapper 2.4.5 → 2.6.0

package/bedrock-wrapper.js

@@ -15,6 +15,7 @@ import { bedrock_models } from "./bedrock-models.js";
 import {
     BedrockRuntimeClient,
     InvokeModelCommand, InvokeModelWithResponseStreamCommand,
+    ConverseCommand, ConverseStreamCommand,
 } from "@aws-sdk/client-bedrock-runtime";
 // helper functions
 import {
@@ -81,14 +82,82 @@ function processReasoningTags(text, awsModel) {
     return text.replace(/<reasoning>[\s\S]*?<\/reasoning>/g, '').trim();
 }
 
-export async function* bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging = false } = {} ) {
-    const { region, accessKeyId, secretAccessKey } = awsCreds;
-    let { messages, model, max_tokens, stream, temperature, top_p, include_thinking_data, stop, stop_sequences } = openaiChatCompletionsCreateObject;
-
-
-  let {awsModelId, awsModel} = findAwsModelWithId(model);
+// Convert messages to Converse API format
+async function convertToConverseFormat(messages) {
+    const converseMessages = [];
+    let systemPrompts = [];
+    
+    for (const msg of messages) {
+        if (msg.role === "system") {
+            // System messages are handled separately in Converse API
+            if (typeof msg.content === 'string') {
+                systemPrompts.push({ text: msg.content });
+            } else if (Array.isArray(msg.content)) {
+                // Extract text from content array
+                const textContent = msg.content
+                    .filter(item => item.type === 'text')
+                    .map(item => item.text || item)
+                    .join('\n');
+                if (textContent) {
+                    systemPrompts.push({ text: textContent });
+                }
+            }
+        } else {
+            // Convert user and assistant messages
+            let content = [];
+            
+            if (typeof msg.content === 'string') {
+                content = [{ text: msg.content }];
+            } else if (Array.isArray(msg.content)) {
+                for (const item of msg.content) {
+                    if (item.type === 'text') {
+                        content.push({ text: item.text || item });
+                    } else if (item.type === 'image') {
+                        // Handle image content
+                        if (item.source && item.source.data) {
+                            content.push({
+                                image: {
+                                    format: 'jpeg',
+                                    source: {
+                                        bytes: Buffer.from(item.source.data, 'base64')
+                                    }
+                                }
+                            });
+                        }
+                    } else if (item.type === 'image_url') {
+                        // Process image URL to base64
+                        const processedImage = await processImage(
+                            typeof item.image_url === 'string' ? 
+                            item.image_url : 
+                            item.image_url.url
+                        );
+                        content.push({
+                            image: {
+                                format: 'jpeg',
+                                source: {
+                                    bytes: Buffer.from(processedImage, 'base64')
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+            
+            // Only add messages with actual content (Converse API doesn't allow empty content)
+            if (content.length > 0) {
+                converseMessages.push({
+                    role: msg.role,
+                    content: content
+                });
+            }
+        }
+    }
+    
+    return { messages: converseMessages, system: systemPrompts };
+}
 
-    // cleanup message content before formatting prompt message
+// Process messages for Invoke API (complex model-specific formatting)
+async function processMessagesForInvoke(messages, awsModel) {
     let message_cleaned = [];
     let system_message = "";
 
@@ -149,15 +218,17 @@ export async function* bedrockWrapper(awsCreds, openaiChatCompletionsCreateObjec
             message_cleaned.push({role: "assistant", content: ""});
         }
     }
+    
+    return { message_cleaned, system_message };
+}
 
-    let prompt;
-
-    // format prompt message from message array
+// Build prompt for Invoke API (model-specific formatting)
+function buildInvokePrompt(message_cleaned, awsModel) {
     if (awsModel.messages_api) {
         // convert message array to prompt object if model supports messages api
-        prompt = message_cleaned;
+        return message_cleaned;
     } else {
-        prompt = awsModel.bos_text;
+        let prompt = awsModel.bos_text;
         let eom_text_inserted = false;
         
         for (let i = 0; i < message_cleaned.length; i++) {
@@ -213,45 +284,64 @@ export async function* bedrockWrapper(awsCreds, openaiChatCompletionsCreateObjec
                 prompt += `\n${awsModel.eom_text}`;
             }
         }
+        return prompt;
     }
+}
 
-    // Add logging to see the final prompt
-    if (logging) {
-        console.log("\nFinal formatted prompt:", prompt);
+// Apply parameter restrictions for models that have them
+function applyParameterRestrictions(params, awsModel) {
+    if (!awsModel.parameter_restrictions) {
+        return params;
     }
 
-    let max_gen_tokens = max_tokens <= awsModel.max_supported_response_tokens ? max_tokens : awsModel.max_supported_response_tokens;
-
-    if (awsModel.special_request_schema?.thinking?.type === "enabled") {
-        // temperature may only be set to 1 when thinking is enabled
-        temperature = 1;
-        // top_p must be unset when thinking is enabled
-        top_p = undefined;
-        // bugget_tokens can not be greater than 80% of max_gen_tokens
-        let budget_tokens = awsModel.special_request_schema?.thinking?.budget_tokens;
-        if (budget_tokens > (max_gen_tokens * 0.8)) {
-            budget_tokens = Math.floor(max_gen_tokens * 0.8);
-        }
-        if (budget_tokens < 1024) {
-            budget_tokens = 1024;
-        }
-        // if awsModel.special_request_schema?.thinking?.budget_tokens, set it to budget_tokens
-        if (awsModel.special_request_schema?.thinking?.budget_tokens) {
-            awsModel.special_request_schema.thinking.budget_tokens = budget_tokens;
-            // max_gen_tokens has to be greater than budget_tokens
-            if (max_gen_tokens <= budget_tokens) {
-                // make max_gen_tokens 20% greater than budget_tokens
-                max_gen_tokens = Math.floor(budget_tokens * 1.2);
+    const restrictions = awsModel.parameter_restrictions;
+    
+    // Handle mutually exclusive parameters
+    if (restrictions.mutually_exclusive) {
+        for (const exclusiveGroup of restrictions.mutually_exclusive) {
+            // Check for both top_p and topP variants
+            const presentParams = exclusiveGroup.filter(param => {
+                if (param === 'top_p') {
+                    return (params['top_p'] !== undefined && params['top_p'] !== null) ||
+                           (params['topP'] !== undefined && params['topP'] !== null);
+                }
+                return params[param] !== undefined && params[param] !== null;
+            });
+            
+            if (presentParams.length > 1) {
+                // Keep the first parameter and remove others
+                // For temperature/top_p, prioritize temperature as it's more commonly used
+                const priorityOrder = ['temperature', 'top_p'];
+                const sortedParams = presentParams.sort((a, b) => {
+                    const aIndex = priorityOrder.indexOf(a);
+                    const bIndex = priorityOrder.indexOf(b);
+                    if (aIndex !== -1 && bIndex !== -1) return aIndex - bIndex;
+                    if (aIndex !== -1) return -1;
+                    if (bIndex !== -1) return 1;
+                    return 0;
+                });
+                
+                // Keep the first (highest priority) parameter, remove others
+                for (let i = 1; i < sortedParams.length; i++) {
+                    const paramToRemove = sortedParams[i];
+                    if (paramToRemove === 'top_p') {
+                        // Remove both variants
+                        delete params['top_p'];
+                        delete params['topP'];
+                    } else {
+                        delete params[paramToRemove];
+                    }
+                }
             }
         }
     }
+    
+    return params;
+}
 
-    // if (logging) {
-    //     console.log("\nMax tokens:", max_gen_tokens);
-    // }
-
-    // Format the request payload using the model's native structure.
-    const request = awsModel.messages_api ? (() => {
+// Build request object for Invoke API (model-specific)
+function buildInvokeRequest(prompt, awsModel, max_gen_tokens, temperature, top_p, stop_sequences, stop, system_message) {
+    if (awsModel.messages_api) {
         // Check if this is a Nova model (has schemaVersion in special_request_schema)
         if (awsModel.special_request_schema?.schemaVersion === "messages-v1") {
             // Nova model format - convert messages to Nova's expected format
@@ -289,17 +379,24 @@ export async function* bedrockWrapper(awsCreds, openaiChatCompletionsCreateObjec
             });
             
             const stopSequencesValue = stop_sequences || stop;
+            
+            // Build inference config with parameter restrictions
+            let inferenceConfig = {
+                [awsModel.max_tokens_param_name]: max_gen_tokens,
+                temperature: temperature,
+                topP: top_p,
+                ...(awsModel.stop_sequences_param_name && stopSequencesValue && {
+                    [awsModel.stop_sequences_param_name]: Array.isArray(stopSequencesValue) ? stopSequencesValue : [stopSequencesValue]
+                })
+            };
+            
+            // Apply parameter restrictions
+            inferenceConfig = applyParameterRestrictions(inferenceConfig, awsModel);
+            
             const novaRequest = {
                 ...awsModel.special_request_schema,
                 messages: novaMessages,
-                inferenceConfig: {
-                    [awsModel.max_tokens_param_name]: max_gen_tokens,
-                    temperature: temperature,
-                    topP: top_p,
-                    ...(awsModel.stop_sequences_param_name && stopSequencesValue && {
-                        [awsModel.stop_sequences_param_name]: Array.isArray(stopSequencesValue) ? stopSequencesValue : [stopSequencesValue]
-                    })
-                }
+                inferenceConfig: inferenceConfig
             };
             
             // Add system message if present
@@ -311,7 +408,9 @@ export async function* bedrockWrapper(awsCreds, openaiChatCompletionsCreateObjec
         } else {
             // Standard messages API format (Claude, etc.)
             const stopSequencesValue = stop_sequences || stop;
-            return {
+            
+            // Build request with parameter restrictions
+            let request = {
                 messages: prompt,
                 ...(awsModel.system_as_separate_field && system_message && { system: system_message }),
                 [awsModel.max_tokens_param_name]: max_gen_tokens,
@@ -322,48 +421,47 @@ export async function* bedrockWrapper(awsCreds, openaiChatCompletionsCreateObjec
                 }),
                 ...awsModel.special_request_schema
             };
+            
+            // Apply parameter restrictions
+            request = applyParameterRestrictions(request, awsModel);
+            
+            return request;
         }
-    })() : {
-        prompt: typeof prompt === 'string' ? prompt : {
-            messages: prompt.map(msg => ({
-                role: msg.role,
-                content: Array.isArray(msg.content) ? 
-                    msg.content.map(item => 
-                        item.type === 'text' ? item.text : item
-                    ).join('\n') : 
-                    msg.content
-            }))
-        },
-        // Optional inference parameters:
-        [awsModel.max_tokens_param_name]: max_gen_tokens,
-        temperature: temperature,
-        top_p: top_p,
-        ...(() => {
-            const stopSequencesValue = stop_sequences || stop;
-            return awsModel.stop_sequences_param_name && stopSequencesValue ? {
-                [awsModel.stop_sequences_param_name]: Array.isArray(stopSequencesValue) ? stopSequencesValue : [stopSequencesValue]
-            } : {};
-        })(),
-        ...awsModel.special_request_schema
-    };
-    
-    // Create a Bedrock Runtime client in the AWS Region of your choice
-    const client = new BedrockRuntimeClient({
-        region: region,
-        credentials: {
-            accessKeyId: accessKeyId,
-            secretAccessKey: secretAccessKey,
-        },
-    });
-
-    if (logging) {
-        console.log("\nFinal request:", JSON.stringify(request, null, 2));
+    } else {
+        // Build request for non-messages API models (Llama, etc.)
+        let request = {
+            prompt: typeof prompt === 'string' ? prompt : {
+                messages: prompt.map(msg => ({
+                    role: msg.role,
+                    content: Array.isArray(msg.content) ? 
+                        msg.content.map(item => 
+                            item.type === 'text' ? item.text : item
+                        ).join('\n') : 
+                        msg.content
+                }))
+            },
+            // Optional inference parameters:
+            [awsModel.max_tokens_param_name]: max_gen_tokens,
+            temperature: temperature,
+            top_p: top_p,
+            ...(() => {
+                const stopSequencesValue = stop_sequences || stop;
+                return awsModel.stop_sequences_param_name && stopSequencesValue ? {
+                    [awsModel.stop_sequences_param_name]: Array.isArray(stopSequencesValue) ? stopSequencesValue : [stopSequencesValue]
+                } : {};
+            })(),
+            ...awsModel.special_request_schema
+        };
+        
+        // Apply parameter restrictions
+        request = applyParameterRestrictions(request, awsModel);
+        
+        return request;
     }
+}
 
-    // Check if model supports streaming, override stream parameter if not
-    const modelSupportsStreaming = awsModel.streaming_supported !== false;
-    const shouldStream = stream && modelSupportsStreaming;
-
+// Execute Invoke API call (streaming and non-streaming)
+async function* executeInvokeAPI(client, request, awsModelId, shouldStream, awsModel, include_thinking_data) {
     if (shouldStream) {
         const responseStream = await client.send(
             new InvokeModelWithResponseStreamCommand({
@@ -452,7 +550,248 @@ export async function* bedrockWrapper(awsCreds, openaiChatCompletionsCreateObjec
             result = "";
         }
         yield result;
-    }    
+    }
+}
+
+export async function* bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging = false, useConverseAPI = false } = {} ) {
+    const { region, accessKeyId, secretAccessKey } = awsCreds;
+    let { messages, model, max_tokens, stream, temperature, top_p, include_thinking_data, stop, stop_sequences } = openaiChatCompletionsCreateObject;
+
+    let {awsModelId, awsModel} = findAwsModelWithId(model);
+    
+    // Create a Bedrock Runtime client 
+    const client = new BedrockRuntimeClient({
+        region: region,
+        credentials: {
+            accessKeyId: accessKeyId,
+            secretAccessKey: secretAccessKey,
+        },
+    });
+
+    // Calculate max tokens (shared between both APIs)
+    let max_gen_tokens = max_tokens <= awsModel.max_supported_response_tokens ? max_tokens : awsModel.max_supported_response_tokens;
+    
+    // Check if model supports streaming
+    const modelSupportsStreaming = awsModel.streaming_supported !== false;
+    const shouldStream = stream && modelSupportsStreaming;
+
+    // ============================
+    // CONVERSE API PATH (SIMPLIFIED)
+    // ============================
+    if (useConverseAPI) {
+        // Convert messages to Converse API format (no model-specific complexity)
+        const { messages: converseMessages, system: systemPrompts } = await convertToConverseFormat(messages);
+        
+        // Build inference configuration (handle thinking mode for Claude models)
+        let inferenceConfig = {
+            maxTokens: max_gen_tokens,
+            temperature: temperature,
+            ...(top_p !== undefined && { topP: top_p })
+        };
+        
+        // Apply parameter restrictions for Converse API
+        inferenceConfig = applyParameterRestrictions(inferenceConfig, awsModel);
+        
+        // Handle thinking mode for Claude models
+        let budget_tokens;
+        if (awsModel.special_request_schema?.thinking?.type === "enabled") {
+            // Apply thinking mode constraints for Converse API
+            inferenceConfig.temperature = 1; // temperature must be 1 for thinking
+            delete inferenceConfig.topP; // top_p must be unset for thinking
+            
+            // Calculate thinking budget configuration
+            budget_tokens = awsModel.special_request_schema?.thinking?.budget_tokens;
+            if (budget_tokens > (max_gen_tokens * 0.8)) {
+                budget_tokens = Math.floor(max_gen_tokens * 0.8);
+            }
+            if (budget_tokens < 1024) {
+                budget_tokens = 1024;
+            }
+            
+            // Ensure max tokens is sufficient for thinking
+            if (inferenceConfig.maxTokens <= budget_tokens) {
+                inferenceConfig.maxTokens = Math.floor(budget_tokens * 1.2);
+            }
+        }
+        
+        // Add stop sequences if provided (unified format)
+        const stopSequencesValue = stop_sequences || stop;
+        if (stopSequencesValue) {
+            inferenceConfig.stopSequences = Array.isArray(stopSequencesValue) ? 
+                stopSequencesValue : [stopSequencesValue];
+        }
+        
+        // Build the Converse API request (simple, unified format)
+        const converseRequest = {
+            modelId: awsModelId,
+            messages: converseMessages,
+            inferenceConfig: inferenceConfig
+        };
+        
+        // Add system prompts if any
+        if (systemPrompts.length > 0) {
+            converseRequest.system = systemPrompts;
+        }
+        
+        // Add thinking configuration for Claude models
+        if (awsModel.special_request_schema?.thinking?.type === "enabled") {
+            converseRequest.additionalModelRequestFields = {
+                thinking: {
+                    type: "enabled",
+                    budget_tokens: budget_tokens
+                }
+            };
+            
+            if (awsModel.special_request_schema?.anthropic_beta) {
+                converseRequest.additionalModelRequestFields.anthropic_beta = awsModel.special_request_schema.anthropic_beta;
+            }
+        }
+        
+        if (logging) {
+            console.log("\nConverse API request:", JSON.stringify(converseRequest, null, 2));
+        }
+        
+        if (shouldStream) {
+            // Use ConverseStream for streaming responses
+            const responseStream = await client.send(new ConverseStreamCommand(converseRequest));
+            
+            let is_thinking = false;
+            let should_think = include_thinking_data && awsModel.special_request_schema?.thinking?.type === "enabled";
+            
+            for await (const event of responseStream.stream) {
+                if (event.contentBlockDelta) {
+                    const text = event.contentBlockDelta.delta?.text;
+                    const thinking = event.contentBlockDelta.delta?.thinking;
+                    const reasoningContent = event.contentBlockDelta.delta?.reasoningContent;
+                    
+                    // Handle Claude thinking data (streaming) - check both reasoningContent and thinking
+                    const thinkingText = reasoningContent?.reasoningText?.text || thinking;
+                    if (should_think && thinkingText) {
+                        if (!is_thinking) {
+                            is_thinking = true;
+                            yield `<think>${thinkingText}`;
+                        } else {
+                            yield thinkingText;
+                        }
+                    }
+                    // Handle regular text content
+                    else if (text) {
+                        // End thinking mode if we were in it
+                        if (is_thinking) {
+                            is_thinking = false;
+                            yield `</think>\n\n${text}`;
+                        } else {
+                            // Process reasoning tags for GPT-OSS models only
+                            const processedText = processReasoningTags(text, awsModel);
+                            if (processedText) {
+                                yield processedText;
+                            }
+                        }
+                    }
+                }
+            }
+            
+            // Close thinking tag if still open
+            if (is_thinking) {
+                yield "</think>";
+            }
+        } else {
+            // Use Converse for non-streaming responses
+            const response = await client.send(new ConverseCommand(converseRequest));
+            
+            if (logging) {
+                console.log("\nConverse API response:", JSON.stringify(response, null, 2));
+            }
+            
+            // Extract text and thinking from response (handle Claude thinking)
+            if (response.output && response.output.message && response.output.message.content) {
+                let thinking_result = "";
+                let text_result = "";
+                
+                for (const contentBlock of response.output.message.content) {
+                    // Extract thinking data for Claude models (from reasoningContent)
+                    if (include_thinking_data && contentBlock.reasoningContent && 
+                        awsModel.special_request_schema?.thinking?.type === "enabled") {
+                        const reasoningText = contentBlock.reasoningContent.reasoningText?.text;
+                        if (reasoningText) {
+                            thinking_result += reasoningText;
+                        }
+                    }
+                    
+                    // Also check for legacy thinking field format
+                    if (include_thinking_data && contentBlock.thinking && 
+                        awsModel.special_request_schema?.thinking?.type === "enabled") {
+                        thinking_result += contentBlock.thinking;
+                    }
+                    
+                    // Extract regular text content
+                    if (contentBlock.text) {
+                        text_result += contentBlock.text;
+                    }
+                }
+                
+                // Process reasoning tags for GPT-OSS models
+                text_result = processReasoningTags(text_result, awsModel);
+                
+                // Combine thinking and text for Claude models
+                let result = thinking_result ? `<think>${thinking_result}</think>\n\n${text_result}` : text_result;
+                
+                if (result) {
+                    yield result;
+                }
+            }
+        }
+        return; // Exit early when using Converse API
+    }
+
+    // ============================
+    // INVOKE API PATH (COMPLEX, MODEL-SPECIFIC)
+    // ============================
+    
+    // Process messages for Invoke API (complex, model-specific)
+    const { message_cleaned, system_message } = await processMessagesForInvoke(messages, awsModel);
+    
+    // Build prompt for Invoke API (complex, model-specific)
+    const prompt = buildInvokePrompt(message_cleaned, awsModel);
+    
+    if (logging) {
+        console.log("\nFinal formatted prompt:", prompt);
+    }
+
+    // Handle thinking mode adjustments (Invoke API specific)
+    if (awsModel.special_request_schema?.thinking?.type === "enabled") {
+        // temperature may only be set to 1 when thinking is enabled
+        temperature = 1;
+        // top_p must be unset when thinking is enabled
+        top_p = undefined;
+        // budget_tokens can not be greater than 80% of max_gen_tokens
+        let budget_tokens = awsModel.special_request_schema?.thinking?.budget_tokens;
+        if (budget_tokens > (max_gen_tokens * 0.8)) {
+            budget_tokens = Math.floor(max_gen_tokens * 0.8);
+        }
+        if (budget_tokens < 1024) {
+            budget_tokens = 1024;
+        }
+        // if awsModel.special_request_schema?.thinking?.budget_tokens, set it to budget_tokens
+        if (awsModel.special_request_schema?.thinking?.budget_tokens) {
+            awsModel.special_request_schema.thinking.budget_tokens = budget_tokens;
+            // max_gen_tokens has to be greater than budget_tokens
+            if (max_gen_tokens <= budget_tokens) {
+                // make max_gen_tokens 20% greater than budget_tokens
+                max_gen_tokens = Math.floor(budget_tokens * 1.2);
+            }
+        }
+    }
+    
+    // Build request for Invoke API (complex, model-specific)
+    const request = buildInvokeRequest(prompt, awsModel, max_gen_tokens, temperature, top_p, stop_sequences, stop, system_message);
+    
+    if (logging) {
+        console.log("\nFinal request:", JSON.stringify(request, null, 2));
+    }
+    
+    // Execute Invoke API call (complex, model-specific response parsing)
+    yield* executeInvokeAPI(client, request, awsModelId, shouldStream, awsModel, include_thinking_data);
 }