Update aiEngine.js

aiEngine.js

@@ -1,236 +1,103 @@
-import { AzureOpenAI } from "openai"; // Use the dedicated Azure class
-import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
-import { NodeHttpHandler } from "@smithy/node-http-handler";
+import dotenv from 'dotenv';
 import fs from 'fs';
 import path from 'path';
-import dotenv from 'dotenv';
+
 dotenv.config();
 
+// Configuration for your remote "Battle Arena" server
+const REMOTE_SERVER_URL = process.env.REMOTE_AI_URL || "http://localhost:7860";
+
 let prompts = {};
 try {
     const promptsPath = path.resolve('./prompts.json');
     if (fs.existsSync(promptsPath)) prompts = JSON.parse(fs.readFileSync(promptsPath, 'utf8'));
 } catch (e) { console.error("Prompt Load Error:", e); }
 
-// --- BEDROCK CLIENT ---
-const bedrockClient = new BedrockRuntimeClient({
-    region: "us-east-1",
-    requestHandler: new NodeHttpHandler({
-      http2Handler: undefined
-    })
-  /*  credentials: {
-        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-    } */
-});
-
-// --- AZURE OPENAI CLIENT (Fixed Initialization) ---
-const azureOpenAI = new AzureOpenAI({
-    apiKey: process.env.AZURE_OPENAI_API_KEY,
-    // Note: endpoint should be: https://resource-name.cognitiveservices.azure.com
-    endpoint: process.env.AZURE_OPENAI_ENDPOINT, 
-    deployment: process.env.AZURE_DEPLOYMENT_NAME, // e.g., "gpt-5-mini"
-    apiVersion: "2024-05-01-preview",
-});
-
-// Formatters
-const toAzureHistory = (h) => h.map(m => ({ 
-    role: m.role === 'model' ? 'assistant' : 'user', 
-    content: m.parts[0].text 
-}));
-
-const toBedrockHistory = (h) => h.map(m => ({ 
-    role: m.role === 'model' ? 'assistant' : 'user', 
-    content: [{ text: m.parts[0].text }] 
-}));
+/**
+ * HELPER: Flattens the history array into a single string 
+ * because the remote server expects a 'prompt' string.
+ */
+const flattenHistory = (history, currentInput, systemPrompt) => {
+    const context = history.map(m => {
+        const roleName = m.role === 'model' ? 'Assistant' : 'User';
+        return `${roleName}: ${m.parts[0].text}`;
+    }).join('\n');
+    
+    return `System: ${systemPrompt}\n\n${context}\nUser: ${currentInput}\nAssistant:`;
+};
 
 export const AIEngine = {
-   /* callPM: async (history, input) => {
-        const command = new ConverseCommand({
-            modelId: "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6",
-            system: [{ text: prompts.pm_system_prompt || "You are a pro manager." }],
-            messages: [...toBedrockHistory(history), { role: "user", content: [{ text: input }] }],
-            inferenceConfig: { 
-                maxTokens: 4096, // Reduced from 50k (which causes errors) to standard max output
-                temperature: 1 
-            },
-            additionalModelRequestFields: { 
-                thinking: { type: "adaptive" },
-                output_config: { effort: "high" }
-            }
-        });
-        const res = await bedrockClient.send(command);
-        const text = res.output.message.content.find(b => b.text)?.text;
-        return { text, usage: { totalTokenCount: (res.usage?.inputTokens || 0) + (res.usage?.outputTokens || 0) } };
-    },
-    */
-  
-    /* callPM: async (history, input) => {
-        try {
-            // 1. Filter history to ensure strict alternation (User -> Assistant)
-            // and prevent the "Consecutive Role" error.
-            const formattedHistory = toBedrockHistory(history).filter((msg, index, array) => {
-                if (index === 0) return msg.role === 'user'; // First must be user
-                return msg.role !== array[index - 1].role;   // Must alternate
-            });
-
-            const command = new ConverseCommand({
-                modelId: "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6",
-                system: [{ text: prompts.pm_system_prompt || "You are a pro manager." }],
-                // Only append input if it's not already the last message in history
-                messages: [
-                    ...formattedHistory, 
-                    { role: "user", content: [{ text: input }] }
-                ],
-                inferenceConfig: { 
-                    maxTokens: 20000, // Increased to allow room for Thinking + Output
-                    temperature: 1 
-                },
-                additionalModelRequestFields: { 
-                    thinking: { type: "adaptive" },
-                    output_config: { effort: "high" }
-                }
-            });
-
-            const res = await bedrockClient.send(command);
-            
-            // 2. Claude 3.7/4.6 returns multiple content blocks (thinking + text)
-            // We specifically look for the 'text' block.
-            const text = res.output.message.content.find(b => b.text)?.text;
-
-            return { 
-                text: text || "No response text found.", 
-                usage: { 
-                    totalTokenCount: (res.usage?.inputTokens || 0) + (res.usage?.outputTokens || 0) 
-                } 
-            };
-        } catch (error) {
-            console.error("❌ BEDROCK API ERROR:", error.name, error.message);
-            throw error; // Rethrow so your UI knows it failed
-        }
-    }, */
-  
- // callWorker: async (history, input, images = []) => {
     callPM: async (history, input) => {
-        
-        let userContent = input;
-        
-        // Handle Multimodal (Images)
-        if (images?.length > 0) {
-            userContent = [
-                { type: "text", text: input },
-                ...images.map(img => ({ 
-                    type: "image_url", 
-                    image_url: { url: img.startsWith('data') ? img : `data:image/png;base64,${img}` } 
-                }))
-            ];
-        }
-
-        const res = await azureOpenAI.chat.completions.create({
-            model: process.env.AZURE_DEPLOYMENT_NAME,
-            messages: [
-                { role: "system", content: prompts.worker_system_prompt || "You are a worker." },
-                ...toAzureHistory(history),
-                { role: "user", content: userContent }
-            ],
-            reasoning_effort: "high"
+        const systemPrompt = prompts.pm_system_prompt || "You are a pro manager.";
+        const fullPrompt = flattenHistory(history, input, systemPrompt);
+
+        const response = await fetch(`${REMOTE_SERVER_URL}/api/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: "claude",
+                prompt: fullPrompt
+            })
         });
 
+        const result = await response.json();
+        if (!result.success) throw new Error(result.error);
+
         return { 
-            text: res.choices[0].message.content, 
-            usage: { totalTokenCount: res.usage.total_tokens } 
+            text: result.data, 
+            usage: { totalTokenCount: 0 } // Remote server doesn't return usage yet
         };
     },
-    
-   /* callWorker: async (history, input, images = []) => {
-        let userContent = input;
-        
-        // Handle Multimodal (Images)
-        if (images?.length > 0) {
-            userContent = [
-                { type: "text", text: input },
-                ...images.map(img => ({ 
-                    type: "image_url", 
-                    image_url: { url: img.startsWith('data') ? img : `data:image/png;base64,${img}` } 
-                }))
-            ];
-        }
-
-        const res = await azureOpenAI.chat.completions.create({
-            model: process.env.AZURE_DEPLOYMENT_NAME,
-            messages: [
-                { role: "system", content: prompts.worker_system_prompt || "You are a worker." },
-                ...toAzureHistory(history),
-                { role: "user", content: userContent }
-            ],
-            reasoning_effort: "high"
+
+    callWorker: async (history, input, images = []) => {
+        // Note: The current remote server doesn't support images in its /api/generate 
+        // We'll send it as a text-only gpt request for now.
+        const systemPrompt = prompts.worker_system_prompt || "You are a worker.";
+        const fullPrompt = flattenHistory(history, input, systemPrompt);
+
+        const response = await fetch(`${REMOTE_SERVER_URL}/api/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: "gpt",
+                prompt: fullPrompt
+            })
         });
 
+        const result = await response.json();
+        if (!result.success) throw new Error(result.error);
+
         return { 
-            text: res.choices[0].message.content, 
-            usage: { totalTokenCount: res.usage.total_tokens } 
+            text: result.data, 
+            usage: { totalTokenCount: 0 } 
         };
-    }, */
-  
+    },
 
     generateEntryQuestions: async (desc) => {
-        /*const res = await azureOpenAI.chat.completions.create({
-            model: process.env.AZURE_DEPLOYMENT_NAME,
-            messages: [
-                { role: "system", content: prompts.analyst_system_prompt + " Output ONLY JSON." },
-                { role: "user", content: `[MODE 1: QUESTIONS]\nIdea: "${desc}"` }
-            ],
-            response_format: { type: "json_object" }
+        const response = await fetch(`${REMOTE_SERVER_URL}/api/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: "gpt",
+                prompt: `[OUTPUT ONLY JSON]\nGoal: Generate entry questions for this idea: ${desc}`
+            })
         });
-        return { 
-            ...JSON.parse(res.choices[0].message.content), 
-            usage: { totalTokenCount: res.usage.total_tokens } 
-        };*/
-        try {
-               let ppp = `${prompts.analyst_system_prompt} Output ONLY JSON.`;
-
-  const command = new ConverseCommand({
-                modelId: "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6",
-                // --- OFFICIAL BEDROCK SYSTEM PROMPT ---
-                system: [{ text: ppp }], 
-                messages: [{ role: "user", content: [{ text: `[MODE 1: QUESTIONS]\nIdea: "${desc}"` }] }],
-                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;
-            
-            return { 
-                text: text || "No response text found.", 
-                usage: { 
-                    totalTokenCount: (response.usage?.inputTokens || 0) + (response.usage?.outputTokens || 0) 
-                } 
-            };
-        } catch (error) {
-            console.error("❌ BEDROCK API ERROR:", error.name, error.message);
-            throw error; // Rethrow so your UI knows it failed
-        }
-    
+
+        const result = await response.json();
+        return JSON.parse(result.data);
     },
 
     gradeProject: async (desc, ans) => {
-        const res = await azureOpenAI.chat.completions.create({
-            model: process.env.AZURE_DEPLOYMENT_NAME,
-            messages: [
-                { role: "system", content: prompts.analyst_system_prompt + " Output ONLY JSON." },
-                { role: "user", content: `[MODE 2: GRADING]\nIdea: ${desc}\nAns: ${JSON.stringify(ans)}` }
-            ],
-            response_format: { type: "json_object" }
+        const response = await fetch(`${REMOTE_SERVER_URL}/api/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: "gpt",
+                prompt: `[OUTPUT ONLY JSON]\nGrade this project. Desc: ${desc}\nAnswers: ${JSON.stringify(ans)}`
+            })
         });
-        return { 
-            ...JSON.parse(res.choices[0].message.content), 
-            usage: { totalTokenCount: res.usage.total_tokens } 
-        };
-    },
 
-    generateImage: async () => null
+        const result = await response.json();
+        return JSON.parse(result.data);
+    }
 };