Update app.js

app.js

@@ -10,14 +10,17 @@ const app = express();
 const PORT = process.env.PORT || 7860;
 
 app.use(cors());
-app.use(express.json({ limit: '50mb' }));
+app.use(express.json({ limit: '50mb' })); // Increased limit for images
 
+// --- SYSTEM PROMPT DEFINITIONS ---
 const CLAUDE_SYSTEM_PROMPT = "You are a pro. Provide elite, high-level technical responses.";
 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({ http2Handler: undefined }) 
+   requestHandler: new NodeHttpHandler({
+        http2Handler: undefined, 
+    }) 
 });
 
 const azureOpenAI = new OpenAI({
@@ -28,7 +31,9 @@ const azureOpenAI = new OpenAI({
 });
 
 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({
@@ -36,26 +41,37 @@ app.post('/api/generate', async (req, res) => {
                 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" } }
+                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;
             res.json({ success: true, data: text });
         } else {
             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: [
+                    { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT },
+                    { role: "user", content: prompt }
+                ],
                 reasoning_effort: "high"
             });
             res.json({ success: true, data: response.choices[0].message.content });
         }
     } catch (err) {
-        res.status(500).json({ success: false, error: err.message });
+        console.error(`❌ [${model.toUpperCase()} ERROR]:`, err.name, err.message);
+        res.status(500).json({ success: false, error: `${err.name}: ${err.message}` });
     }
 });
 
+// --- STREAMING ENDPOINT WITH IMAGE SUPPORT ---
 app.post('/api/stream', async (req, res) => {
-    const { model, prompt, system_prompt, images } = req.body;
+    const { model, prompt, system_prompt, images } = req.body; // Expect images array (base64)
+    console.log(`[STREAM] Request for ${model} ${images?.length ? 'with images' : ''}`);
+
     res.setHeader('Content-Type', 'text/plain; charset=utf-8');
     res.setHeader('Transfer-Encoding', 'chunked');
     res.setHeader('X-Accel-Buffering', 'no'); 
@@ -63,56 +79,96 @@ app.post('/api/stream', async (req, res) => {
 
     try {
         if (model === "claude") {
+            // Construct Content Block for Claude
             let contentBlock = [{ text: prompt }];
+            
             if (images && images.length > 0) {
+                // Prepend images to content block
+                // Bedrock expects pure base64 without data prefix
                 const imageBlocks = images.map(imgStr => {
                     const base64Data = imgStr.replace(/^data:image\/\w+;base64,/, "");
-                    return { image: { format: 'png', source: { bytes: Buffer.from(base64Data, 'base64') } } };
+                    return {
+                        image: {
+                            format: 'png', // Assuming PNG or generic byte handling
+                            source: { bytes: Buffer.from(base64Data, 'base64') }
+                        }
+                    };
                 });
                 contentBlock = [...imageBlocks, ...contentBlock];
             }
+
             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 }],
                 messages: [{ role: "user", content: contentBlock }],
                 inferenceConfig: { maxTokens: 48000, temperature: 1 },
-                additionalModelRequestFields: { thinking: { type: "adaptive" }, output_config: { effort: "high" } }
+                additionalModelRequestFields: { 
+                    thinking: { type: "adaptive" },
+                    output_config: { effort: "high" }
+                }
             });
+
             const response = await bedrockClient.send(command);
+            
             for await (const chunk of response.stream) {
                 if (chunk.contentBlockDelta) {
                     const delta = chunk.contentBlockDelta.delta;
-                    if (delta.reasoningContent?.text) res.write(`__THINK__${delta.reasoningContent.text}`);
-                    else if (delta.text) res.write(delta.text);
+                    if (delta.reasoningContent && delta.reasoningContent.text) {
+                        res.write(`__THINK__${delta.reasoningContent.text}`);
+                    } else if (delta.text) {
+                        res.write(delta.text);
+                    }
                 }
             }
             res.end();
+
         } else {
-            let messagesPayload = [{ role: "system", content: system_prompt || GPT_SYSTEM_PROMPT }];
+            // Construct Content Block for OpenAI
+            let messagesPayload = [
+                { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT }
+            ];
+
+            let userContent = [];
             if (images && images.length > 0) {
-                let userContent = [{ type: "text", text: prompt }];
-                images.forEach(img => userContent.push({ type: "image_url", image_url: { url: img } }));
+                // OpenAI supports mixed content array
+                userContent.push({ type: "text", text: prompt });
+                images.forEach(imgStr => {
+                    userContent.push({
+                        type: "image_url",
+                        image_url: { url: imgStr } // OpenAI accepts data URI directly
+                    });
+                });
                 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,
             });
+
             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 (delta?.reasoning_content) {
+                    res.write(`__THINK__${delta.reasoning_content}`);
+                } else if (delta?.content) {
+                    res.write(delta.content);
+                }
             }
             res.end();
         }
     } catch (err) {
+        console.error(`❌ [STREAM ERROR]:`, err.message);
         res.write(`ERROR: ${err.message}`);
         res.end();
     }
 });
 
-app.listen(PORT, '0.0.0.0', () => console.log(`Main AI Agents live on port ${PORT}`));
+app.post('/api/stream', async (req, res) => {
+  res.json({ success: true });
+});
+
+app.listen(PORT, '0.0.0.0', () => console.log(`Main AI Agent live on port ${PORT}`));