Update app.js

app.js

@@ -34,31 +34,41 @@ const azureOpenAI = new OpenAI({
 function getBedrockModelId(modelName) {
     switch(modelName) {
         case "haiku":
-        return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-haiku-4-5-20251001-v1:0"
-           // return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-haiku-4-5";
+            return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-haiku-4-5-20251001-v1:0";
         case "maverick":
-            // Standard Bedrock cross-region inference mapping for Llama
-           // return "arn:aws:bedrock:us-east-1::foundation-model/meta.llama4-maverick-17b-instruct-v1:0"; 
-        return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/us.meta.llama4-maverick-17b-instruct-v1:0";
-      case "claude":
+            return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/us.meta.llama4-maverick-17b-instruct-v1:0";
+        case "claude":
         default:
             return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6";
     }
 }
 
-// --- NON-STREAMING ENDPOINT ---
+// --- NON-STREAMING ENDPOINT (UPDATED FOR VISION) ---
 app.post('/api/generate', async (req, res) => {
-    const { model, prompt, system_prompt } = req.body;
-    console.log(`[TRAFFIC] Request for ${model}`);
+    // EXTRACT IMAGES HERE
+    const { model, prompt, system_prompt, images } = req.body;
+    console.log(`[TRAFFIC] Request for ${model} ${images?.length ? 'with images' : ''}`);
 
     try {
         if (model === "gpt" || model === "gpt-5-mini") {
+            let messagesPayload =[
+                { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT }
+            ];
+
+            // VISION SUPPORT FOR AZURE OPENAI
+            if (images && images.length > 0) {
+                let userContent = [{ type: "text", text: prompt }];
+                images.forEach(imgStr => {
+                    userContent.push({ type: "image_url", image_url: { url: imgStr } });
+                });
+                messagesPayload.push({ role: "user", content: userContent });
+            } else {
+                messagesPayload.push({ role: "user", content: prompt });
+            }
+
             const response = await azureOpenAI.chat.completions.create({
                 model: "gpt-5-mini",
-                messages:[
-                    { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT },
-                    { role: "user", content: prompt }
-                ],
+                messages: messagesPayload,
                 reasoning_effort: "high"
             });
             
@@ -68,56 +78,52 @@ app.post('/api/generate', async (req, res) => {
         } else {
             // Handles Claude Sonnet, Claude Haiku, and Llama Maverick
             const bedrockModelId = getBedrockModelId(model);
-       
-          /*   const command = new ConverseCommand({
+            
+            // VISION SUPPORT FOR AWS BEDROCK
+            let contentBlock = [{ text: prompt }];
+            if (images && images.length > 0) {
+                const imageBlocks = images.map(imgStr => {
+                    const base64Data = imgStr.replace(/^data:image\/\w+;base64,/, "");
+                    return {
+                        image: {
+                            format: 'png', // Assuming normalized to PNG by frontend
+                            source: { bytes: Buffer.from(base64Data, 'base64') }
+                        }
+                    };
+                });
+                contentBlock = [...imageBlocks, ...contentBlock];
+            }
+
+            const command = new ConverseCommand({
                 modelId: bedrockModelId,
-                system: [{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }], 
-                messages: [{ role: "user", content: [{ text: prompt }] }],
-               
-              inferenceConfig:  model.includes("claude") ? {  maxTokens: 48000, temperature: 1 }:
-                (model.includes("haiku")? {maxTokens: 30000, temperature: 1 } 
-                 :  {maxTokens: 3800, temperature: 1 }),
-           
-              performanceConfig: model.includes("maverick") ? {latency: "standard"} : undefined,
+                system:[{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
+                messages: [{ role: "user", content: contentBlock }],
                 
-                additionalModelRequestFields: model.includes("claude") ? { 
-                    thinking: { type: "adaptive" },
-                    output_config: { effort: "high" }
-                } : undefined // Llama does not support Claude's specific thinking fields
+                // Ensure maxTokens is large enough for reasoning + response
+                inferenceConfig: { 
+                    maxTokens: model.includes("haiku") ? 32000 : 4000, 
+                    temperature: 1 
+                },
+
+                performanceConfig: model.includes("maverick") ? { latency: "standard" } : undefined,
+
+                additionalModelRequestFields: (function() {
+                    if (model.includes("haiku")) {
+                        return {
+                            reasoning_config: {
+                                type: "enabled",
+                                budget_tokens: 2048 
+                            }
+                        };
+                    } else if (model.includes("claude")) {
+                        return {
+                            thinking: { type: "adaptive" },
+                            output_config: { effort: "high" }
+                        };
+                    }
+                    return undefined;
+                })()
             });
-
-            */
-
-const command = new ConverseCommand({
-    modelId: bedrockModelId,
-    system: [{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
-    messages: [{ role: "user", content: [{ text: prompt }] }],
-    
-    // Ensure maxTokens is large enough for reasoning + response
-    inferenceConfig: { 
-        maxTokens: model.includes("haiku") ? 32000 : 4000, 
-        temperature: 1 
-    },
-
-    performanceConfig: model.includes("maverick") ? { latency: "standard" } : undefined,
-
-    additionalModelRequestFields: (function() {
-        if (model.includes("haiku")) {
-            return {
-                reasoning_config: {
-                    type: "enabled",
-                    budget_tokens: 2048 // As seen in your screenshot
-                }
-            };
-        } else if (model.includes("claude")) {
-            return {
-                thinking: { type: "adaptive" },
-                output_config: { effort: "high" }
-            };
-        }
-        return undefined;
-    })()
-});
           
             const response = await bedrockClient.send(command);
             const text = response.output.message.content.find(b => b.text)?.text;
@@ -198,7 +204,7 @@ app.post('/api/stream', async (req, res) => {
             const command = new ConverseStreamCommand({
                 modelId: bedrockModelId,
                 system:[{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
-                messages: [{ role: "user", content: contentBlock }],
+                messages:[{ role: "user", content: contentBlock }],
                 inferenceConfig: { maxTokens: 48000, temperature: 1 },
                 additionalModelRequestFields: model.includes("claude") ? { 
                     thinking: { type: "adaptive" },
@@ -255,8 +261,8 @@ const CLAUDE_SYSTEM_PROMPT = "You are a pro. Provide elite, high-level technical
 const GPT_SYSTEM_PROMPT = "You are a worker. Be concise, efficient, and get the job done.";
 
 const bedrockClient = new BedrockRuntimeClient({
-    region: "us-east-1" ,
-   requestHandler: new NodeHttpHandler({
+    region: "us-east-1",
+    requestHandler: new NodeHttpHandler({
         http2Handler: undefined, 
     }) 
 });
@@ -268,38 +274,32 @@ const azureOpenAI = new OpenAI({
     defaultHeaders: { "api-key": "7U3m9NRkE38ThSWTr92hMgQ4hDCUFI9MAnFNrCgRL7MhdvckfTXwJQQJ99CBACHYHv6XJ3w3AAAAACOGV22P" }
 });
 
+// --- DYNAMIC MODEL ROUTER ---
+function getBedrockModelId(modelName) {
+    switch(modelName) {
+        case "haiku":
+        return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-haiku-4-5-20251001-v1:0"
+           // return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-haiku-4-5";
+        case "maverick":
+            // Standard Bedrock cross-region inference mapping for Llama
+           // return "arn:aws:bedrock:us-east-1::foundation-model/meta.llama4-maverick-17b-instruct-v1:0"; 
+        return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/us.meta.llama4-maverick-17b-instruct-v1:0";
+      case "claude":
+        default:
+            return "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6";
+    }
+}
+
 // --- NON-STREAMING ENDPOINT ---
 app.post('/api/generate', async (req, res) => {
-    const { model, prompt, system_prompt} = req.body;
+    const { model, prompt, system_prompt } = req.body;
     console.log(`[TRAFFIC] Request for ${model}`);
 
     try {
-        if (model === "claude") {
-            const command = new ConverseCommand({
-                modelId: "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6",
-                system: [{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }], 
-                messages: [{ role: "user", content: [{ text: prompt }] }],
-                inferenceConfig: { maxTokens: 48000, temperature: 1 },
-                additionalModelRequestFields: { 
-                    thinking: { type: "adaptive" },
-                    output_config: { effort: "high" }
-                }
-            });
-            
-            const response = await bedrockClient.send(command);
-            const text = response.output.message.content.find(b => b.text)?.text;
-            const usage = response.metrics ? 
-                (response.metrics.latencyMs || 0) : 0; // Bedrock metrics vary, usually usage is in metadata
-            
-            // Extract token usage from Bedrock response
-            const tokenUsage = response.usage ? (response.usage.inputTokens + response.usage.outputTokens) : 0;
-
-            res.json({ success: true, data: text, usage: { totalTokenCount: tokenUsage } });
-
-        } else {
+        if (model === "gpt" || model === "gpt-5-mini") {
             const response = await azureOpenAI.chat.completions.create({
                 model: "gpt-5-mini",
-                messages: [
+                messages:[
                     { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT },
                     { role: "user", content: prompt }
                 ],
@@ -308,9 +308,51 @@ app.post('/api/generate', async (req, res) => {
             
             const totalTokens = response.usage ? response.usage.total_tokens : 0;
             res.json({ success: true, data: response.choices[0].message.content, usage: { totalTokenCount: totalTokens } });
+
+        } else {
+            // Handles Claude Sonnet, Claude Haiku, and Llama Maverick
+            const bedrockModelId = getBedrockModelId(model);
+       
+
+const command = new ConverseCommand({
+    modelId: bedrockModelId,
+    system: [{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
+    messages: [{ role: "user", content: [{ text: prompt }] }],
+    
+    // Ensure maxTokens is large enough for reasoning + response
+    inferenceConfig: { 
+        maxTokens: model.includes("haiku") ? 32000 : 4000, 
+        temperature: 1 
+    },
+
+    performanceConfig: model.includes("maverick") ? { latency: "standard" } : undefined,
+
+    additionalModelRequestFields: (function() {
+        if (model.includes("haiku")) {
+            return {
+                reasoning_config: {
+                    type: "enabled",
+                    budget_tokens: 2048 // As seen in your screenshot
+                }
+            };
+        } else if (model.includes("claude")) {
+            return {
+                thinking: { type: "adaptive" },
+                output_config: { effort: "high" }
+            };
+        }
+        return undefined;
+    })()
+});
+          
+            const response = await bedrockClient.send(command);
+            const text = response.output.message.content.find(b => b.text)?.text;
+            const tokenUsage = response.usage ? (response.usage.inputTokens + response.usage.outputTokens) : 0;
+
+            res.json({ success: true, data: text, usage: { totalTokenCount: tokenUsage } });
         }
     } catch (err) {
-        console.error(`❌ [${model.toUpperCase()} ERROR]:`, err.name, err.message);
+        console.error(`❌[${model?.toUpperCase() || 'UNKNOWN'} ERROR]:`, err.name, err.message);
         res.status(500).json({ success: false, error: `${err.name}: ${err.message}` });
     }
 });
@@ -328,8 +370,42 @@ app.post('/api/stream', async (req, res) => {
     let totalTokenCount = 0;
 
     try {
-        if (model === "claude") {
-            // Construct Content Block for Claude
+        if (model === "gpt" || model === "gpt-5-mini") {
+            let messagesPayload =[
+                { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT }
+            ];
+
+            let userContent =[];
+            if (images && images.length > 0) {
+                userContent.push({ type: "text", text: prompt });
+                images.forEach(imgStr => {
+                    userContent.push({ type: "image_url", image_url: { url: imgStr } });
+                });
+                messagesPayload.push({ role: "user", content: userContent });
+            } else {
+                messagesPayload.push({ role: "user", content: prompt });
+            }
+
+            const stream = await azureOpenAI.chat.completions.create({
+                model: "gpt-5-mini",
+                messages: messagesPayload,
+                reasoning_effort: "high",
+                stream: true,
+                stream_options: { include_usage: true } 
+            });
+
+            for await (const chunk of stream) {
+                const delta = chunk.choices[0]?.delta;
+                if (delta?.reasoning_content) res.write(`__THINK__${delta.reasoning_content}`);
+                else if (delta?.content) res.write(delta.content);
+                if (chunk.usage) totalTokenCount = chunk.usage.total_tokens;
+            }
+            
+            res.write(`__USAGE__${JSON.stringify({ totalTokenCount })}`);
+            res.end();
+
+        } else {
+            const bedrockModelId = getBedrockModelId(model);
             let contentBlock = [{ text: prompt }];
             
             if (images && images.length > 0) {
@@ -337,7 +413,7 @@ app.post('/api/stream', async (req, res) => {
                     const base64Data = imgStr.replace(/^data:image\/\w+;base64,/, "");
                     return {
                         image: {
-                            format: 'png', 
+                            format: 'png', // Assuming normalized to PNG by frontend
                             source: { bytes: Buffer.from(base64Data, 'base64') }
                         }
                     };
@@ -346,14 +422,14 @@ app.post('/api/stream', async (req, res) => {
             }
 
             const command = new ConverseStreamCommand({
-                modelId: "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6",
-                system: [{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
+                modelId: bedrockModelId,
+                system:[{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
                 messages: [{ role: "user", content: contentBlock }],
                 inferenceConfig: { maxTokens: 48000, temperature: 1 },
-                additionalModelRequestFields: { 
+                additionalModelRequestFields: model.includes("claude") ? { 
                     thinking: { type: "adaptive" },
                     output_config: { effort: "high" }
-                }
+                } : undefined
             });
 
             const response = await bedrockClient.send(command);
@@ -367,60 +443,11 @@ app.post('/api/stream', async (req, res) => {
                         res.write(delta.text);
                     }
                 }
-                // Capture Usage from Bedrock Stream
                 if (chunk.metadata && chunk.metadata.usage) {
                     totalTokenCount = (chunk.metadata.usage.inputTokens || 0) + (chunk.metadata.usage.outputTokens || 0);
                 }
             }
             
-            // Send Usage Footer
-            res.write(`__USAGE__${JSON.stringify({ totalTokenCount })}`);
-            res.end();
-
-        } else {
-            // Construct Content Block for OpenAI
-            let messagesPayload = [
-                { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT }
-            ];
-
-            let userContent = [];
-            if (images && images.length > 0) {
-                userContent.push({ type: "text", text: prompt });
-                images.forEach(imgStr => {
-                    userContent.push({
-                        type: "image_url",
-                        image_url: { url: imgStr }
-                    });
-                });
-                messagesPayload.push({ role: "user", content: userContent });
-            } else {
-                messagesPayload.push({ role: "user", content: prompt });
-            }
-
-            const stream = await azureOpenAI.chat.completions.create({
-                model: "gpt-5-mini",
-                messages: messagesPayload,
-                reasoning_effort: "high",
-                stream: true,
-                stream_options: { include_usage: true } // Request usage stats in stream
-            });
-
-            for await (const chunk of stream) {
-                const delta = chunk.choices[0]?.delta;
-                
-                if (delta?.reasoning_content) {
-                    res.write(`__THINK__${delta.reasoning_content}`);
-                } else if (delta?.content) {
-                    res.write(delta.content);
-                }
-
-                // Capture Usage from OpenAI Stream (usually in the last chunk)
-                if (chunk.usage) {
-                    totalTokenCount = chunk.usage.total_tokens;
-                }
-            }
-            
-            // Send Usage Footer
             res.write(`__USAGE__${JSON.stringify({ totalTokenCount })}`);
             res.end();
         }
@@ -431,9 +458,6 @@ app.post('/api/stream', async (req, res) => {
     }
 });
 
-app.get('/', async (req, res) => {
-  res.json({ success: true });
-});
-
+app.get('/', async (req, res) => { res.json({ success: true }); });
 app.listen(PORT, '0.0.0.0', () => console.log(`Main AI Agent live on port ${PORT}`));
 */