Update aiEngine.js

aiEngine.js

@@ -1,249 +1,104 @@
-//aiEngine.js
-import { GoogleGenAI } from '@google/genai';
+import OpenAI from "openai";
+import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
+import { NodeHttpHandler } from "@smithy/node-http-handler";
 import fs from 'fs';
-import path from 'path';
-import mime from 'mime';
 
-// Load prompts safely
-const promptsPath = path.resolve('./prompts.json');
-const prompts = JSON.parse(fs.readFileSync(promptsPath, 'utf8'));
+// Load prompts
+const prompts = JSON.parse(fs.readFileSync('./prompts.json', 'utf8'));
 
-// Initialize SDK
-// Make sure process.env.GEMINI_API_KEY is set in your environment
-const genAI = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
-
-export const AIEngine = {
-  /**
-   * 1. PROJECT MANAGER (Reasoning & Delegation)
-   * Uses High-Reasoning Model
-   */
-  callPM: async (history, input) => {
-    const modelId = 'gemini-3-pro-preview'; 
-    
-    const config = {
-      thinkingConfig: { thinkingLevel: 'HIGH' }, 
-      tools: [{ googleSearch: {} }],
-      systemInstruction: {
-        parts: [{ text: prompts.pm_system_prompt }]
-      }
-    };
-
-    const contents = [
-      ...history,
-      { role: 'user', parts: [{ text: input }] }
-    ];
-
-    try {
-      const response = await genAI.models.generateContent({
-        model: modelId,
-        config,
-        contents,
-      });
-
-      console.log(response.usageMetadata.total_token_count);
-      
-      // Return both text and usage metadata
-      return { 
-        text: response.text, 
-        usage: response.usageMetadata
-      };
-
-    } catch (error) {
-      console.error("PM AI Error:", error);
-      throw error;
+// --- CLIENT INITIALIZATION ---
+const bedrockClient = new BedrockRuntimeClient({
+    region: process.env.AWS_REGION || "us-east-1",
+    requestHandler: new NodeHttpHandler({ http2Handler: undefined }),
+    credentials: {
+        accessKey_id: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
     }
-  },
-
-  /**
-   * 2. WORKER (Coding & Execution)
-   * Uses Flash Model (Fast) + Image Support
-   */
-  callWorker: async (history, input, images = []) => {
-    const modelId = "gemini-3-flash-preview"; // 'gemini-3-pro-preview';
-    const config = {
-      thinkingConfig: { thinkingLevel: 'HIGH' }, 
-      // tools: [{ googleSearch: {} }],
-      systemInstruction: {
-        parts: [{ text: prompts.worker_system_prompt }]
-      }
-    };
-    
-
-    const currentParts = [{ text: input }];
+});
+
+const azureOpenAI = new OpenAI({
+    apiKey: process.env.AZURE_OPENAI_API_KEY,
+    baseURL: `${process.env.AZURE_OPENAI_ENDPOINT}/openai/deployments/${process.env.AZURE_DEPLOYMENT_NAME}`,
+    defaultQuery: { "api-version": "2024-05-01-preview" },
+    defaultHeaders: { "api-key": process.env.AZURE_OPENAI_API_KEY }
+});
+
+// Helper to convert Google history format to Standard Chat format
+function transformHistory(history) {
+    return history.map(h => ({
+        role: h.role === 'model' ? 'assistant' : h.role,
+        content: h.parts[0].text
+    }));
+}
 
-    // Handle Image Injection (Base64)
-    if (images && images.length > 0) {
-      images.forEach(base64String => {
-        // Strip prefix if present
-        const cleanData = base64String.replace(/^data:image\/\w+;base64,/, "");
-        currentParts.push({
-            inlineData: {
-                mimeType: "image/png",
-                data: cleanData
+export const AIEngine = {
+    // PM -> Claude Sonnet 4.6 (via Bedrock)
+    callPM: async (history, input) => {
+        const chatHistory = transformHistory(history);
+        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 }],
+            messages: [...chatHistory, { role: "user", content: [{ text: input }] }],
+            inferenceConfig: { maxTokens: 50000, temperature: 0.7 },
+            additionalModelRequestFields: { 
+                thinking: { type: "adaptive" },
+                output_config: { effort: "high" }
             }
         });
-      });
-    }
-
-    const contents = [
-      ...history,
-      { role: 'user', parts: currentParts }
-    ];
-
-    try {
-      const response = await genAI.models.generateContent({
-        model: modelId,
-        config,
-        contents,
-      });
-      
- console.log(response.usageMetadata.total_token_count);
-     
-      // Return both text and usage metadata
-      return { 
-        text: response.text, 
-        usage: response.usageMetadata
-      };
-
-    } catch (error) {
-      console.error("Worker AI Error:", error);
-      throw error;
-    }
-  },
-
-  /**
-   * 3. ONBOARDING ANALYST (Question Generation)
-   * Returns STRICT JSON for the Frontend
-   */
-  generateEntryQuestions: async (description) => {
-    const modelId = "gemini-3-flash-preview"; // 'gemini-2.5-flash';
-    // Using the updated prompt which handles REJECTED/ACCEPTED logic
-    const input = `[MODE 1: QUESTIONS]\nAnalyze this game idea: "${description}". Check for TOS violations or nonsense. If good, ask 3 questions. Output ONLY raw JSON.`;
-    
-    try {
-      const response = await genAI.models.generateContent({
-        model: modelId,
-        config: { 
-            responseMimeType: "application/json",
-            systemInstruction: { parts: [{ text: prompts.analyst_system_prompt }] }
-        },
-        contents: [{ role: 'user', parts: [{ text: input }] }]
-      });
-      
-      const text = response.text;
-      const parsed = JSON.parse(text);
 
-      console.log(response.usageMetadata.total_token_count)
-      
-      // Attach usage to the JSON object
-      return { 
-        ...parsed, 
-        usage: response.usageMetadata
-      };
-
-    } catch (e) {
-      console.error("Analyst Error:", e);
-      // On failure, we don't return usage, so no charge applies
-      // return { status: "ACCEPTED", questions: [{ id: "fallback", label: "Please describe the core gameplay loop in detail.", type: "textarea" }] };
-    throw e;
-    }
-  },
-
-  /**
-   * 4. PROJECT GRADER (Feasibility Check)
-   * Returns STRICT JSON
-   */
-  gradeProject: async (description, answers) => {
-    const modelId = "gemini-3-flash-preview"; // 'gemini-2.5-flash';
-    // Using the updated prompt to respect Title and relaxed Grading
-    const input = `[MODE 2: GRADING]\nIdea: "${description}"\nUser Answers: ${JSON.stringify(answers)}\n\nAssess feasibility. Output JSON with title and rating.`;
-
-    try {
-      const response = await genAI.models.generateContent({
-        model: modelId,
-        config: { 
-            responseMimeType: "application/json",
-            systemInstruction: { parts: [{ text: prompts.analyst_system_prompt }] }
-        },
-        contents: [{ role: 'user', parts: [{ text: input }] }]
-      });
-      
-      const parsed = JSON.parse(response.text);
-      console.log(response.usageMetadata.total_token_count);
-      
-      // Attach usage to the JSON object
-      return { 
-        ...parsed, 
-        usage: response.usageMetadata
-      };
-
-    } catch (e) {
-      console.error("Grading Error:", e);
-      // On failure, no usage returned
-     // return { feasibility: 80, rating: "B", title: "Untitled Project", summary: "Standard project structure detected." };
-  throw e;
-    }
-  },
-
-  /**
-   * 5. IMAGE GENERATOR (Visual Assets)
-   * Uses Gemini 2.5 Flash Image with Stream (Correct Implementation)
-   */
-  generateImage: async (prompt) => {
-    // Inject the prompt template from JSON to ensure adherence to instructions
-    const finalPrompt = prompts.image_gen_prompt.replace('{{DESCRIPTION}}', prompt);
-
-    const config = {
-      responseModalities: ['IMAGE', 'TEXT'],
-    };
-    const model = 'gemini-2.5-flash-image';
-    const contents = [
-      {
-        role: 'user',
-        parts: [{ text: finalPrompt }],
-      },
-    ];
-
-    try {
-      const response = await genAI.models.generateContentStream({
-        model,
-        config,
-        contents,
-      });
-
-      let finalDataUrl = null;
-
-      for await (const chunk of response) {
-        if (!chunk.candidates || !chunk.candidates[0].content || !chunk.candidates[0].content.parts) {
-          continue;
-        }
+        const response = await bedrockClient.send(command);
+        const text = response.output.message.content.find(b => b.text)?.text;
+        
+        return { 
+            text, 
+            usage: { totalTokenCount: response.usage?.totalTokens || 0 } 
+        };
+    },
+
+    // Worker -> GPT-5 Mini (via Azure)
+    callWorker: async (history, input, images = []) => {
+        const chatHistory = transformHistory(history);
         
-        // Capture image data if present
-        if (chunk.candidates?.[0]?.content?.parts?.[0]?.inlineData) {
-            const inlineData = chunk.candidates[0].content.parts[0].inlineData;
-            const rawB64 = (inlineData.data || "").replace(/\s+/g, ""); 
-            const mimeType = inlineData.mimeType || "image/png";
-            const buffer = Buffer.from(rawB64, "base64");
-            const base64 = buffer.toString("base64");
-            
-            finalDataUrl = `data:${mimeType};base64,${base64}`;
-            // We do NOT return here immediately, we continue to allow the stream to finish 
-            // so we can access the aggregated usage metadata at the end.
-        } 
-      }
-      
-      // Retrieve the full response object to get usage metadata
-      const aggregatedResponse = await response.response;
-// console.log(aggregatedResponse.usageMetadata.total_token_count);
-      return { 
-          image: finalDataUrl, 
-          usage: 2000// aggregatedResponse.usageMetadata
-      };
+        // Note: GPT-5 Mini handles images via the content array if needed
+        const response = await azureOpenAI.chat.completions.create({
+            model: process.env.AZURE_DEPLOYMENT_NAME,
+            messages: [
+                { role: "system", content: prompts.worker_system_prompt },
+                ...chatHistory,
+                { role: "user", content: input }
+            ],
+            reasoning_effort: "high"
+        });
 
-    } catch (error) {
-      console.error("Image Gen Error:", error);
-      // On failure, return null (logic in backend handles null as no-op)
-      return null; 
+        return { 
+            text: response.choices[0].message.content, 
+            usage: { totalTokenCount: response.usage?.total_tokens || 0 } 
+        };
+    },
+
+    // Standard tasks use the faster Worker model
+    generateEntryQuestions: async (description) => {
+        const response = await azureOpenAI.chat.completions.create({
+            model: process.env.AZURE_DEPLOYMENT_NAME,
+            messages: [
+                { role: "system", content: prompts.analyst_system_prompt },
+                { role: "user", content: `[MODE 1: QUESTIONS]\nIdea: "${description}"` }
+            ],
+            response_format: { type: "json_object" }
+        });
+        const parsed = JSON.parse(response.choices[0].message.content);
+        return { ...parsed, usage: { totalTokenCount: response.usage.total_tokens } };
+    },
+
+    gradeProject: async (description, answers) => {
+        const response = await azureOpenAI.chat.completions.create({
+            model: process.env.AZURE_DEPLOYMENT_NAME,
+            messages: [
+                { role: "system", content: prompts.analyst_system_prompt },
+                { role: "user", content: `[MODE 2: GRADING]\nIdea: ${description}\nAnswers: ${JSON.stringify(answers)}` }
+            ],
+            response_format: { type: "json_object" }
+        });
+        return { ...JSON.parse(response.choices[0].message.content), usage: { totalTokenCount: response.usage.total_tokens } };
     }
-  }
 };