bedrock-wrapper 2.4.4 → 2.5.0

package/test-models.js

@@ -51,7 +51,7 @@ async function logOutput(message, type = 'info', writeToFile = true ) {
     }
 }
 
-async function testModel(model, awsCreds, testMessage, isStreaming) {
+async function testModel(model, awsCreds, testMessage, isStreaming, useConverseAPI, apiName) {
     const messages = [{ role: "user", content: testMessage }];
     const openaiChatCompletionsCreateObject = {
         messages,
@@ -60,17 +60,18 @@ async function testModel(model, awsCreds, testMessage, isStreaming) {
         stream: isStreaming,
         temperature: LLM_TEMPERATURE,
         top_p: LLM_TOP_P,
+        include_thinking_data: true,
     };
 
     let completeResponse = "";
     
     try {
         if (isStreaming) {
-            for await (const chunk of bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: true })) {
+            for await (const chunk of bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: true, useConverseAPI })) {
                 completeResponse += chunk;
             }
         } else {
-            const response = await bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: true });
+            const response = await bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: true, useConverseAPI });
             for await (const data of response) {
                 completeResponse += data;
             }
@@ -88,12 +89,24 @@ async function testModel(model, awsCreds, testMessage, isStreaming) {
 }
 
 async function main() {
+    // Check for command-line arguments
+    const args = process.argv.slice(2);
+    const testBothAPIs = args.includes('--both') || args.includes('--compare');
+    const useConverseOnly = args.includes('--converse');
+    
     const testMessage = "Respond with exactly one word: What is 1+1?";
     
+    // Determine test mode
+    let testMode = "Invoke API";
+    if (useConverseOnly) testMode = "Converse API";
+    if (testBothAPIs) testMode = "Both APIs (Comparison)";
+    
     // Clear output file and add header
     await fs.writeFile('test-models-output.txt', 
+        `Test Mode: ${testMode}\n` +
         `Test Question: "${testMessage}"\n` +
-        `=`.repeat(50) + '\n\n'
+        `Test Date: ${new Date().toISOString()}\n` +
+        `${'='.repeat(60)}\n\n`
     );
 
     const supportedModels = await listBedrockWrapperSupportedModels();
@@ -105,7 +118,7 @@ async function main() {
     });
 
     console.clear();
-    await logOutput(`Starting tests with ${availableModels.length} models...`, 'info');
+    await logOutput(`Starting tests with ${availableModels.length} models using ${testMode}...`, 'info');
     await logOutput(`Each model will be tested with streaming and non-streaming calls\n`, 'info');
 
     const awsCreds = {
@@ -115,30 +128,93 @@ async function main() {
     };
 
     for (const model of availableModels) {
-        await logOutput(`\n${'-'.repeat(50)}\nTesting ${model} ⇢`, 'running');
+        await logOutput(`\n${'-'.repeat(60)}\nTesting ${model} ⇢`, 'running');
+
+        if (testBothAPIs) {
+            // Test both APIs and compare
+            await logOutput(`\n📡 Testing with Invoke API:`, 'info');
+            
+            // Invoke API streaming test
+            const invokeStreamResult = await testModel(model, awsCreds, testMessage, true, false, "Invoke API");
+            if (invokeStreamResult.success) {
+                await logOutput(`✓ Invoke API Streaming: "${invokeStreamResult.response}"`, 'success');
+            } else {
+                await logOutput(`✗ Invoke API Streaming: ${invokeStreamResult.error}`, 'error');
+            }
 
-        // Test streaming
-        const streamResult = await testModel(model, awsCreds, testMessage, true);
-        if (streamResult.success) {
-            await logOutput(`Streaming test passed for ${model}: "${streamResult.response}"`, 'success');
-        } else {
-            await logOutput(`Streaming test failed for ${model}: ${streamResult.error}`, 'error');
-        }
+            // Invoke API non-streaming test
+            const invokeNonStreamResult = await testModel(model, awsCreds, testMessage, false, false, "Invoke API");
+            if (invokeNonStreamResult.success) {
+                await logOutput(`✓ Invoke API Non-streaming: "${invokeNonStreamResult.response}"`, 'success');
+            } else {
+                await logOutput(`✗ Invoke API Non-streaming: ${invokeNonStreamResult.error}`, 'error');
+            }
+            
+            await logOutput(`\n📡 Testing with Converse API:`, 'info');
+            
+            // Converse API streaming test
+            const converseStreamResult = await testModel(model, awsCreds, testMessage, true, true, "Converse API");
+            if (converseStreamResult.success) {
+                await logOutput(`✓ Converse API Streaming: "${converseStreamResult.response}"`, 'success');
+            } else {
+                await logOutput(`✗ Converse API Streaming: ${converseStreamResult.error}`, 'error');
+            }
 
-        // Test non-streaming
-        const nonStreamResult = await testModel(model, awsCreds, testMessage, false);
-        if (nonStreamResult.success) {
-            await logOutput(`Non-streaming test passed for ${model}: "${nonStreamResult.response}"`, 'success');
+            // Converse API non-streaming test
+            const converseNonStreamResult = await testModel(model, awsCreds, testMessage, false, true, "Converse API");
+            if (converseNonStreamResult.success) {
+                await logOutput(`✓ Converse API Non-streaming: "${converseNonStreamResult.response}"`, 'success');
+            } else {
+                await logOutput(`✗ Converse API Non-streaming: ${converseNonStreamResult.error}`, 'error');
+            }
+            
+            // Compare results
+            const invokeSuccess = invokeStreamResult.success && invokeNonStreamResult.success;
+            const converseSuccess = converseStreamResult.success && converseNonStreamResult.success;
+            
+            if (invokeSuccess && converseSuccess) {
+                await logOutput(`🔍 Both APIs successful for ${model}`, 'success');
+            } else if (invokeSuccess || converseSuccess) {
+                await logOutput(`⚠ Partial success for ${model}`, 'warning');
+            } else {
+                await logOutput(`❌ Both APIs failed for ${model}`, 'error');
+            }
+            
         } else {
-            await logOutput(`Non-streaming test failed for ${model}: ${nonStreamResult.error}`, 'error');
+            // Test single API
+            const useConverseAPI = useConverseOnly;
+            const apiName = useConverseAPI ? "Converse API" : "Invoke API";
+            
+            // Test streaming
+            const streamResult = await testModel(model, awsCreds, testMessage, true, useConverseAPI, apiName);
+            if (streamResult.success) {
+                await logOutput(`✓ ${apiName} Streaming: "${streamResult.response}"`, 'success');
+            } else {
+                await logOutput(`✗ ${apiName} Streaming: ${streamResult.error}`, 'error');
+            }
+
+            // Test non-streaming
+            const nonStreamResult = await testModel(model, awsCreds, testMessage, false, useConverseAPI, apiName);
+            if (nonStreamResult.success) {
+                await logOutput(`✓ ${apiName} Non-streaming: "${nonStreamResult.response}"`, 'success');
+            } else {
+                await logOutput(`✗ ${apiName} Non-streaming: ${nonStreamResult.error}`, 'error');
+            }
         }
         
-        console.log(''); // Add blank line between models
+        console.log('\n' + '-'.repeat(40));
     }
 
-    await logOutput('Testing complete! Check test-models-output.txt for full test results.', 'info', false);
+    await logOutput('\nTesting complete! Check test-models-output.txt for full test results.', 'info', false);
 }
 
+// Add usage info
+console.log('Model Test Usage:');
+console.log('  npm run test                  # Test with Invoke API (default)');
+console.log('  npm run test -- --converse       # Test with Converse API only');
+console.log('  npm run test -- --both           # Test both APIs and compare');
+console.log('\n');
+
 main().catch(async (error) => {
     await logOutput(`Fatal Error: ${error.message}`, 'error');
     console.error(error);

package/test-stop-sequences.js

@@ -49,7 +49,7 @@ async function logOutput(message, type = 'info', writeToFile = true ) {
     }
 }
 
-async function testStopSequence(model, awsCreds, testCase, isStreaming) {
+async function testStopSequence(model, awsCreds, testCase, isStreaming, useConverseAPI, apiName) {
     const messages = [{ role: "user", content: testCase.prompt }];
     const openaiChatCompletionsCreateObject = {
         messages,
@@ -65,11 +65,11 @@ async function testStopSequence(model, awsCreds, testCase, isStreaming) {
     
     try {
         if (isStreaming) {
-            for await (const chunk of bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: false })) {
+            for await (const chunk of bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: false, useConverseAPI })) {
                 completeResponse += chunk;
             }
         } else {
-            const response = await bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: false });
+            const response = await bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: false, useConverseAPI });
             for await (const data of response) {
                 completeResponse += data;
             }
@@ -159,10 +159,21 @@ const stopSequenceTestCases = [
 ];
 
 async function main() {
+    // Check for command-line arguments
+    const args = process.argv.slice(2);
+    const testBothAPIs = args.includes('--both') || args.includes('--compare');
+    const useConverseOnly = args.includes('--converse');
+    
+    // Determine test mode
+    let testMode = "Invoke API";
+    if (useConverseOnly) testMode = "Converse API";
+    if (testBothAPIs) testMode = "Both APIs (Comparison)";
+    
     // Clear output file and add header
     const timestamp = new Date().toISOString();
     await fs.writeFile('test-stop-sequences-output.txt', 
-        `Stop Sequences Test Results - ${timestamp}\n` +
+        `Stop Sequences Test Results - ${testMode}\n` +
+        `Test Date: ${timestamp}\n` +
         `${'='.repeat(80)}\n\n` +
         `This test validates that stop sequences work correctly across all models.\n` +
         `Each model is tested with multiple stop sequence scenarios.\n\n`
@@ -174,7 +185,7 @@ async function main() {
     });
 
     console.clear();
-    await logOutput(`Starting stop sequences tests with ${availableModels.length} models...`, 'info');
+    await logOutput(`Starting stop sequences tests with ${availableModels.length} models using ${testMode}...`, 'info');
     await logOutput(`Testing ${stopSequenceTestCases.length} different stop sequence scenarios\n`, 'info');
 
     const awsCreds = {
@@ -193,6 +204,10 @@ async function main() {
         "Claude-3-Haiku", 
         "Nova-Pro",
         "Nova-Lite",
+        "GPT-OSS-120B",
+        "GPT-OSS-120B-Thinking",
+        "GPT-OSS-20B",
+        "GPT-OSS-20B-Thinking",
         "Llama-3-3-70b",
         "Mistral-7b"
     ].filter(m => availableModels.includes(m));
@@ -204,50 +219,133 @@ async function main() {
         await logOutput(`Testing ${model}`, 'running');
         await logOutput(`${'='.repeat(60)}`, 'info');
 
-        modelResults[model] = {
-            streaming: { passed: 0, failed: 0 },
-            nonStreaming: { passed: 0, failed: 0 }
-        };
+        if (testBothAPIs) {
+            modelResults[model] = {
+                invoke: { streaming: { passed: 0, failed: 0 }, nonStreaming: { passed: 0, failed: 0 } },
+                converse: { streaming: { passed: 0, failed: 0 }, nonStreaming: { passed: 0, failed: 0 } }
+            };
+        } else {
+            modelResults[model] = {
+                streaming: { passed: 0, failed: 0 },
+                nonStreaming: { passed: 0, failed: 0 }
+            };
+        }
 
         for (const testCase of stopSequenceTestCases) {
             await logOutput(`\n▶ Test Case: ${testCase.name}`, 'info');
             await logOutput(`  Prompt: "${testCase.prompt.substring(0, 50)}..."`, 'info');
             await logOutput(`  Stop sequences: [${testCase.stopSequences.join(', ')}]`, 'info');
 
-            // Test streaming
-            await logOutput(`  Testing streaming...`, 'info');
-            const streamResult = await testStopSequence(model, awsCreds, testCase, true);
-            
-            if (streamResult.success) {
-                if (streamResult.stoppedCorrectly) {
-                    await logOutput(`  ✓ Streaming: PASSED - ${streamResult.analysis}`, 'success');
-                    modelResults[model].streaming.passed++;
+            if (testBothAPIs) {
+                // Test both APIs and compare
+                await logOutput(`\n  📡 Testing with Invoke API:`, 'info');
+                
+                // Invoke API streaming test
+                const invokeStreamResult = await testStopSequence(model, awsCreds, testCase, true, false, "Invoke API");
+                if (invokeStreamResult.success) {
+                    if (invokeStreamResult.stoppedCorrectly) {
+                        await logOutput(`    ✓ Invoke Streaming: PASSED - ${invokeStreamResult.analysis}`, 'success');
+                        modelResults[model].invoke.streaming.passed++;
+                    } else {
+                        await logOutput(`    ✗ Invoke Streaming: FAILED - ${invokeStreamResult.analysis}`, 'warning');
+                        modelResults[model].invoke.streaming.failed++;
+                    }
+                    await logOutput(`    Response: "${invokeStreamResult.response.substring(0, 100)}..."`, 'info');
                 } else {
-                    await logOutput(`  ✗ Streaming: FAILED - ${streamResult.analysis}`, 'warning');
-                    modelResults[model].streaming.failed++;
+                    await logOutput(`    ✗ Invoke Streaming: ERROR - ${invokeStreamResult.error}`, 'error');
+                    modelResults[model].invoke.streaming.failed++;
+                }
+
+                // Invoke API non-streaming test
+                const invokeNonStreamResult = await testStopSequence(model, awsCreds, testCase, false, false, "Invoke API");
+                if (invokeNonStreamResult.success) {
+                    if (invokeNonStreamResult.stoppedCorrectly) {
+                        await logOutput(`    ✓ Invoke Non-streaming: PASSED - ${invokeNonStreamResult.analysis}`, 'success');
+                        modelResults[model].invoke.nonStreaming.passed++;
+                    } else {
+                        await logOutput(`    ✗ Invoke Non-streaming: FAILED - ${invokeNonStreamResult.analysis}`, 'warning');
+                        modelResults[model].invoke.nonStreaming.failed++;
+                    }
+                    await logOutput(`    Response: "${invokeNonStreamResult.response.substring(0, 100)}..."`, 'info');
+                } else {
+                    await logOutput(`    ✗ Invoke Non-streaming: ERROR - ${invokeNonStreamResult.error}`, 'error');
+                    modelResults[model].invoke.nonStreaming.failed++;
+                }
+
+                await logOutput(`\n  📡 Testing with Converse API:`, 'info');
+                
+                // Converse API streaming test
+                const converseStreamResult = await testStopSequence(model, awsCreds, testCase, true, true, "Converse API");
+                if (converseStreamResult.success) {
+                    if (converseStreamResult.stoppedCorrectly) {
+                        await logOutput(`    ✓ Converse Streaming: PASSED - ${converseStreamResult.analysis}`, 'success');
+                        modelResults[model].converse.streaming.passed++;
+                    } else {
+                        await logOutput(`    ✗ Converse Streaming: FAILED - ${converseStreamResult.analysis}`, 'warning');
+                        modelResults[model].converse.streaming.failed++;
+                    }
+                    await logOutput(`    Response: "${converseStreamResult.response.substring(0, 100)}..."`, 'info');
+                } else {
+                    await logOutput(`    ✗ Converse Streaming: ERROR - ${converseStreamResult.error}`, 'error');
+                    modelResults[model].converse.streaming.failed++;
+                }
+
+                // Converse API non-streaming test
+                const converseNonStreamResult = await testStopSequence(model, awsCreds, testCase, false, true, "Converse API");
+                if (converseNonStreamResult.success) {
+                    if (converseNonStreamResult.stoppedCorrectly) {
+                        await logOutput(`    ✓ Converse Non-streaming: PASSED - ${converseNonStreamResult.analysis}`, 'success');
+                        modelResults[model].converse.nonStreaming.passed++;
+                    } else {
+                        await logOutput(`    ✗ Converse Non-streaming: FAILED - ${converseNonStreamResult.analysis}`, 'warning');
+                        modelResults[model].converse.nonStreaming.failed++;
+                    }
+                    await logOutput(`    Response: "${converseNonStreamResult.response.substring(0, 100)}..."`, 'info');
+                } else {
+                    await logOutput(`    ✗ Converse Non-streaming: ERROR - ${converseNonStreamResult.error}`, 'error');
+                    modelResults[model].converse.nonStreaming.failed++;
                 }
-                await logOutput(`  Response: "${streamResult.response.substring(0, 100)}..."`, 'info');
+                
             } else {
-                await logOutput(`  ✗ Streaming: ERROR - ${streamResult.error}`, 'error');
-                modelResults[model].streaming.failed++;
-            }
+                // Test single API
+                const useConverseAPI = useConverseOnly;
+                const apiName = useConverseAPI ? "Converse API" : "Invoke API";
+                
+                // Test streaming
+                await logOutput(`  Testing streaming with ${apiName}...`, 'info');
+                const streamResult = await testStopSequence(model, awsCreds, testCase, true, useConverseAPI, apiName);
+                
+                if (streamResult.success) {
+                    if (streamResult.stoppedCorrectly) {
+                        await logOutput(`  ✓ Streaming: PASSED - ${streamResult.analysis}`, 'success');
+                        modelResults[model].streaming.passed++;
+                    } else {
+                        await logOutput(`  ✗ Streaming: FAILED - ${streamResult.analysis}`, 'warning');
+                        modelResults[model].streaming.failed++;
+                    }
+                    await logOutput(`  Response: "${streamResult.response.substring(0, 100)}..."`, 'info');
+                } else {
+                    await logOutput(`  ✗ Streaming: ERROR - ${streamResult.error}`, 'error');
+                    modelResults[model].streaming.failed++;
+                }
 
-            // Test non-streaming
-            await logOutput(`  Testing non-streaming...`, 'info');
-            const nonStreamResult = await testStopSequence(model, awsCreds, testCase, false);
-            
-            if (nonStreamResult.success) {
-                if (nonStreamResult.stoppedCorrectly) {
-                    await logOutput(`  ✓ Non-streaming: PASSED - ${nonStreamResult.analysis}`, 'success');
-                    modelResults[model].nonStreaming.passed++;
+                // Test non-streaming
+                await logOutput(`  Testing non-streaming with ${apiName}...`, 'info');
+                const nonStreamResult = await testStopSequence(model, awsCreds, testCase, false, useConverseAPI, apiName);
+                
+                if (nonStreamResult.success) {
+                    if (nonStreamResult.stoppedCorrectly) {
+                        await logOutput(`  ✓ Non-streaming: PASSED - ${nonStreamResult.analysis}`, 'success');
+                        modelResults[model].nonStreaming.passed++;
+                    } else {
+                        await logOutput(`  ✗ Non-streaming: FAILED - ${nonStreamResult.analysis}`, 'warning');
+                        modelResults[model].nonStreaming.failed++;
+                    }
+                    await logOutput(`  Response: "${nonStreamResult.response.substring(0, 100)}..."`, 'info');
                 } else {
-                    await logOutput(`  ✗ Non-streaming: FAILED - ${nonStreamResult.analysis}`, 'warning');
+                    await logOutput(`  ✗ Non-streaming: ERROR - ${nonStreamResult.error}`, 'error');
                     modelResults[model].nonStreaming.failed++;
                 }
-                await logOutput(`  Response: "${nonStreamResult.response.substring(0, 100)}..."`, 'info');
-            } else {
-                await logOutput(`  ✗ Non-streaming: ERROR - ${nonStreamResult.error}`, 'error');
-                modelResults[model].nonStreaming.failed++;
             }
         }
     }
@@ -258,19 +356,49 @@ async function main() {
     await logOutput(`${'='.repeat(80)}\n`, 'info');
 
     for (const [model, results] of Object.entries(modelResults)) {
-        const streamingRate = (results.streaming.passed / (results.streaming.passed + results.streaming.failed) * 100).toFixed(1);
-        const nonStreamingRate = (results.nonStreaming.passed / (results.nonStreaming.passed + results.nonStreaming.failed) * 100).toFixed(1);
-        
         await logOutput(`${model}:`, 'info');
-        await logOutput(`  Streaming:     ${results.streaming.passed}/${results.streaming.passed + results.streaming.failed} passed (${streamingRate}%)`, 
-            streamingRate > 80 ? 'success' : 'warning');
-        await logOutput(`  Non-streaming: ${results.nonStreaming.passed}/${results.nonStreaming.passed + results.nonStreaming.failed} passed (${nonStreamingRate}%)`, 
-            nonStreamingRate > 80 ? 'success' : 'warning');
+        
+        if (testBothAPIs) {
+            // Both APIs summary
+            const invokeStreamingRate = (results.invoke.streaming.passed / (results.invoke.streaming.passed + results.invoke.streaming.failed) * 100).toFixed(1);
+            const invokeNonStreamingRate = (results.invoke.nonStreaming.passed / (results.invoke.nonStreaming.passed + results.invoke.nonStreaming.failed) * 100).toFixed(1);
+            const converseStreamingRate = (results.converse.streaming.passed / (results.converse.streaming.passed + results.converse.streaming.failed) * 100).toFixed(1);
+            const converseNonStreamingRate = (results.converse.nonStreaming.passed / (results.converse.nonStreaming.passed + results.converse.nonStreaming.failed) * 100).toFixed(1);
+            
+            await logOutput(`  Invoke API:`, 'info');
+            await logOutput(`    Streaming:     ${results.invoke.streaming.passed}/${results.invoke.streaming.passed + results.invoke.streaming.failed} passed (${invokeStreamingRate}%)`, 
+                invokeStreamingRate > 80 ? 'success' : 'warning');
+            await logOutput(`    Non-streaming: ${results.invoke.nonStreaming.passed}/${results.invoke.nonStreaming.passed + results.invoke.nonStreaming.failed} passed (${invokeNonStreamingRate}%)`, 
+                invokeNonStreamingRate > 80 ? 'success' : 'warning');
+            
+            await logOutput(`  Converse API:`, 'info');
+            await logOutput(`    Streaming:     ${results.converse.streaming.passed}/${results.converse.streaming.passed + results.converse.streaming.failed} passed (${converseStreamingRate}%)`, 
+                converseStreamingRate > 80 ? 'success' : 'warning');
+            await logOutput(`    Non-streaming: ${results.converse.nonStreaming.passed}/${results.converse.nonStreaming.passed + results.converse.nonStreaming.failed} passed (${converseNonStreamingRate}%)`, 
+                converseNonStreamingRate > 80 ? 'success' : 'warning');
+                
+        } else {
+            // Single API summary
+            const streamingRate = (results.streaming.passed / (results.streaming.passed + results.streaming.failed) * 100).toFixed(1);
+            const nonStreamingRate = (results.nonStreaming.passed / (results.nonStreaming.passed + results.nonStreaming.failed) * 100).toFixed(1);
+            
+            await logOutput(`  Streaming:     ${results.streaming.passed}/${results.streaming.passed + results.streaming.failed} passed (${streamingRate}%)`, 
+                streamingRate > 80 ? 'success' : 'warning');
+            await logOutput(`  Non-streaming: ${results.nonStreaming.passed}/${results.nonStreaming.passed + results.nonStreaming.failed} passed (${nonStreamingRate}%)`, 
+                nonStreamingRate > 80 ? 'success' : 'warning');
+        }
     }
 
     await logOutput('\nTesting complete! Check test-stop-sequences-output.txt for full results.', 'info', false);
 }
 
+// Add usage info
+console.log('Stop Sequences Test Usage:');
+console.log('  npm run test-stop                # Test with Invoke API (default)');
+console.log('  npm run test-stop -- --converse      # Test with Converse API only');
+console.log('  npm run test-stop -- --both          # Test both APIs and compare');
+console.log('\n');
+
 main().catch(async (error) => {
     await logOutput(`Fatal Error: ${error.message}`, 'error');
     console.error(error);

package/test-vision.js

@@ -37,7 +37,37 @@ async function logOutput(message, type = 'info', writeToFile = true) {
     }
 }
 
+async function testVisionModel(model, messages, useConverseAPI, apiName) {
+    const openaiChatCompletionsCreateObject = {
+        messages,
+        model,
+        max_tokens: 1000,
+        stream: true,
+        temperature: 0.7
+    };
+
+    try {
+        console.log(`\nSending request to ${model} using ${apiName}...`);
+        
+        let response = "";
+        for await (const chunk of bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: false, useConverseAPI })) {
+            response += chunk;
+            process.stdout.write(chunk);
+        }
+        
+        return { success: true, response: response.trim() };
+        
+    } catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+
 async function testVisionCapabilities() {
+    // Check for command-line arguments
+    const args = process.argv.slice(2);
+    const testBothAPIs = args.includes('--both') || args.includes('--compare');
+    const useConverseOnly = args.includes('--converse');
+    
     // Read and convert image to base64
     const imageBuffer = await fs.readFile('./test-image.jpg');
     const base64Image = imageBuffer.toString('base64');
@@ -68,58 +98,88 @@ async function testVisionCapabilities() {
         .filter(model => model.vision === true)
         .map(model => model.modelName);
 
+    // Determine test mode
+    let testMode = "Invoke API";
+    if (useConverseOnly) testMode = "Converse API";
+    if (testBothAPIs) testMode = "Both APIs (Comparison)";
+
     // Clear output file and add header
     await fs.writeFile('test-vision-models-output.txt', 
-        `Vision Test Results\n` +
+        `Vision Test Results - ${testMode}\n` +
         `Test Question: "${testPrompt}"\n` +
         `Test Date: ${new Date().toISOString()}\n` +
-        `${'='.repeat(50)}\n\n`
+        `${'='.repeat(60)}\n\n`
     );
 
     console.clear();
-    await logOutput(`Starting vision tests with ${visionModels.length} models...`, 'info');
+    await logOutput(`Starting vision tests with ${visionModels.length} models using ${testMode}...`, 'info');
     await logOutput(`Testing image description capabilities\n`, 'info');
 
     for (const model of visionModels) {
-        await logOutput(`\n${'-'.repeat(50)}\nTesting ${model} ⇢`, 'running');
+        await logOutput(`\n${'-'.repeat(60)}\nTesting ${model} ⇢`, 'running');
         
-        const openaiChatCompletionsCreateObject = {
-            messages,
-            model,
-            max_tokens: 1000,
-            stream: true,
-            temperature: 0.7
-        };
-
-        try {
-            console.log(`\nSending request to ${model}...`);
+        if (testBothAPIs) {
+            // Test both APIs and compare
+            await logOutput(`\n📡 Testing with Invoke API:`, 'info');
+            const invokeResult = await testVisionModel(model, messages, false, "Invoke API");
+            
+            if (invokeResult.success) {
+                await logOutput(`✓ Invoke API: Success`, 'success');
+                await logOutput(`Response: ${invokeResult.response.substring(0, 150)}...\n`, 'info');
+            } else {
+                await logOutput(`✗ Invoke API: ${invokeResult.error}`, 'error');
+            }
             
-            let response = "";
-            for await (const chunk of bedrockWrapper(awsCreds, openaiChatCompletionsCreateObject, { logging: false })) {
-                response += chunk;
-                process.stdout.write(chunk);
+            await logOutput(`📡 Testing with Converse API:`, 'info');
+            const converseResult = await testVisionModel(model, messages, true, "Converse API");
+            
+            if (converseResult.success) {
+                await logOutput(`✓ Converse API: Success`, 'success');
+                await logOutput(`Response: ${converseResult.response.substring(0, 150)}...\n`, 'info');
+            } else {
+                await logOutput(`✗ Converse API: ${converseResult.error}`, 'error');
+            }
+            
+            // Compare results
+            if (invokeResult.success && converseResult.success) {
+                await logOutput(`🔍 Both APIs successful for ${model}`, 'success');
+            } else if (invokeResult.success || converseResult.success) {
+                await logOutput(`⚠ Partial success for ${model}`, 'warning');
+            } else {
+                await logOutput(`❌ Both APIs failed for ${model}`, 'error');
             }
             
-            // Write successful response to file
-            await logOutput(`\nModel: ${model}`, 'success');
-            await logOutput(`Response: ${response.trim()}\n`, 'info', true);
+        } else {
+            // Test single API
+            const useConverseAPI = useConverseOnly;
+            const apiName = useConverseAPI ? "Converse API" : "Invoke API";
             
-        } catch (error) {
-            const errorMessage = `Error with ${model}: ${error.message}`;
-            await logOutput(errorMessage, 'error');
+            const result = await testVisionModel(model, messages, useConverseAPI, apiName);
             
-            // Log the full error details to file
-            if (error.response) {
+            if (result.success) {
+                await logOutput(`\n✓ ${apiName}: Success`, 'success');
+                await logOutput(`Response: ${result.response}\n`, 'info', true);
+            } else {
+                await logOutput(`\n✗ ${apiName}: ${result.error}`, 'error');
+                
+                // Log the full error details to file
                 await fs.appendFile('test-vision-models-output.txt', 
-                    `Error details: ${JSON.stringify(error.response, null, 2)}\n\n`
+                    `Error details: ${result.error}\n\n`
                 );
             }
         }
         
-        console.log("\n-------------------");
+        console.log("\n" + "-".repeat(40));
     }
     
     await logOutput('\nVision testing complete! Check test-vision-models-output.txt for full results.', 'info', false);
 }
 
+// Add usage info
+console.log('Vision Test Usage:');
+console.log('  npm run test-vision              # Test with Invoke API (default)');
+console.log('  npm run test-vision -- --converse    # Test with Converse API only');
+console.log('  npm run test-vision -- --both        # Test both APIs and compare');
+console.log('\n');
+
 testVisionCapabilities().catch(console.error);