Update services/geminiService.ts

services/geminiService.ts

@@ -1,7 +1,7 @@
 
+import { GoogleGenAI, GenerateContentResponse } from "@google/genai";
 import { SimulationResult, AIInsight } from "../types/index";
 
-// Added exported constants for TTS voices and languages as required by the UI in views/Broadcast.tsx
 export const TTS_VOICES = [
   { name: 'Puck', style: 'Energetic' },
   { name: 'Charon', style: 'Calm' },
@@ -21,131 +21,100 @@ export const TTS_LANGUAGES = [
   { code: 'zh', name: 'Chinese' }
 ];
 
+const TEXT_MODEL = 'gemini-3-flash-preview';
+const IMAGE_MODEL = 'gemini-2.5-flash-image';
+
+const getAI = () => {
+  const apiKey = localStorage.getItem('LQI_API_KEY') || process.env.API_KEY || process.env.GEMINI_API_KEY;
+  if (!apiKey) throw new Error("API_KEY_MISSING");
+  return new GoogleGenAI({ apiKey });
+};
+
 export const callGemini = async (model: string, contents: any, config: any = {}) => {
-  // Ensure contents matches the expected API structure
-  const normalizedContents = typeof contents === 'string' ? [{ parts: [{ text: contents }] }] : 
-                             (Array.isArray(contents) ? contents : [contents]);
-  
-  const response = await fetch('/api/gemini/generate', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ contents: normalizedContents })
+  const ai = getAI();
+  const response: GenerateContentResponse = await ai.models.generateContent({
+    model: model || TEXT_MODEL,
+    contents: typeof contents === 'string' ? contents : contents,
+    config: config,
   });
-  
-  if (!response.ok) {
-    const err = await response.json().catch(() => ({ error: 'Handshake Failed' }));
-    throw new Error(err.error || 'AI Bridge Failed');
-  }
-  return await response.json();
+  return response;
 };
 
-// Helper function for base64 decoding
-function decode(base64: string) {
-  const binaryString = atob(base64);
-  const len = binaryString.length;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
-  }
-  return bytes;
-}
-
-// Helper function for audio decoding
-async function decodeAudioData(
-  data: Uint8Array,
-  ctx: AudioContext,
-  sampleRate: number,
-  numChannels: number,
-): Promise<AudioBuffer> {
-  const dataInt16 = new Int16Array(data.buffer);
-  const frameCount = dataInt16.length / numChannels;
-  const buffer = ctx.createBuffer(numChannels, frameCount, sampleRate);
-
-  for (let channel = 0; channel < numChannels; channel++) {
-    const channelData = buffer.getChannelData(channel);
-    for (let i = 0; i < frameCount; i++) {
-      channelData[i] = dataInt16[i * numChannels + channel] / 32768.0;
-    }
-  }
-  return buffer;
-}
-
-// Fixed: Updated synthesizeSpeech to include multiSpeaker parameter as expected by views/Broadcast.tsx
 export const synthesizeSpeech = async (params: {
   text: string;
   voiceName: string;
   directorNotes?: string;
-  multiSpeaker?: {
-    speaker1: string;
-    voice1: string;
-    speaker2: string;
-    voice2: string;
-  };
+  multiSpeaker?: any;
 }) => {
-  // This is a simplified proxy call for TTS since the server endpoint is hardcoded to gemini-2.5-flash for content
-  // Note: Standard content generation and TTS share the same proxy logic here for simplicity
-  try {
-    const prompt = params.directorNotes ? `${params.directorNotes} Text: ${params.text}` : params.text;
-    const data = await callGemini('gemini-2.5-flash', prompt);
-    // If the proxy were expanded for Audio modalities, we would handle data.audio here
-    return true;
-  } catch (error) {
-    console.error("Speech synthesis failed:", error);
-    return false;
-  }
+  console.log(`Synthesizing: ${params.text}`);
+  return true;
 };
 
 export const speakText = async (text: string) => {
-  console.log("Synthesizing Signal: ", text);
+  console.log("Neural Audio Signal: ", text);
   return true;
 };
 
 export const processVoiceCommand = async (command: string) => {
   try {
-    const prompt = `Analyze: "${command}". Return JSON: { "action": "SEND_MONEY", "amount": number, "recipient": string, "category": string, "narration": "Confirming..." }`;
-    const data = await callGemini('gemini-2.5-flash', prompt);
-    return JSON.parse(data.text || '{}');
+    const ai = getAI();
+    const response = await ai.models.generateContent({
+      model: TEXT_MODEL,
+      contents: `Analyze this treasury command: "${command}". Return a JSON object with: { "action": "SEND_MONEY" | "QUERY", "amount": number, "recipient": string, "category": string, "narration": string }.`,
+      config: { responseMimeType: "application/json" }
+    });
+    return JSON.parse(response.text || '{}');
   } catch (error) {
-    return { action: "ERROR", narration: "Link unstable." };
+    return { action: "ERROR", narration: "Handshake sync failed." };
   }
 };
 
 export const getFinancialAdviceStream = async (query: string, context: any) => {
-  const prompt = `Context: ${JSON.stringify(context)}. User: ${query}`;
-  const data = await callGemini('gemini-2.5-flash', prompt);
-  // Return an array to mimic the structure expected by the Advisor view iterator
-  return [{ text: data.text }];
+  const ai = getAI();
+  const response = await ai.models.generateContent({
+    model: TEXT_MODEL,
+    contents: `Context: ${JSON.stringify(context)}. User: ${query}`,
+  });
+  return [{ text: response.text }];
 };
 
 export const getSystemIntelligenceFeed = async (): Promise<AIInsight[]> => {
   try {
-    const prompt = "Generate 4 brief alerts JSON: [{title, description, severity: 'INFO'|'CRITICAL'}]";
-    const data = await callGemini('gemini-2.5-flash', prompt);
-    // Use a regex to extract JSON if the model returns markdown
-    const jsonStr = data.text.match(/\[.*\]/s)?.[0] || '[]';
-    return JSON.parse(jsonStr);
+    const ai = getAI();
+    const response = await ai.models.generateContent({
+      model: TEXT_MODEL,
+      contents: "Generate 4 brief institutional ledger alerts in JSON format: [{title, description, severity: 'INFO'|'CRITICAL'}]",
+      config: { responseMimeType: "application/json" }
+    });
+    return JSON.parse(response.text || '[]');
   } catch {
-    return [{ id: '1', title: "Node Sync Active", description: "Operational parity.", severity: "INFO" }];
+    return [{ id: '1', title: "Node Sync Active", description: "Operational parity achieved.", severity: "INFO" }];
   }
 };
 
 export const runSimulationForecast = async (prompt: string): Promise<SimulationResult> => {
   try {
-    const fullPrompt = `Simulate: ${prompt}. Return JSON with outcomeNarrative, projectedValue, confidenceScore, status, simulationId.`;
-    const data = await callGemini('gemini-2.5-flash', fullPrompt);
-    const jsonStr = data.text.match(/\{.*\}/s)?.[0] || '{}';
-    return JSON.parse(jsonStr);
+    const ai = getAI();
+    const response = await ai.models.generateContent({
+      model: TEXT_MODEL,
+      contents: `Simulate this scenario: ${prompt}. Return JSON: { outcomeNarrative, projectedValue, confidenceScore, status, simulationId }.`,
+      config: { responseMimeType: "application/json" }
+    });
+    return JSON.parse(response.text || '{}');
   } catch {
-    return { outcomeNarrative: "Simulation Failed.", projectedValue: 0, confidenceScore: 0, status: "ERROR", simulationId: "ERR_A1" };
+    return { outcomeNarrative: "Handshake failed.", projectedValue: 0, confidenceScore: 0, status: "ERROR", simulationId: "ERR_01" };
   }
 };
 
 export const getPortfolioSuggestions = async (context: any) => {
   try {
-    const prompt = `Strategize based on: ${JSON.stringify(context)}. Return JSON array of 3 objects with type, title, description.`;
-    const data = await callGemini('gemini-2.5-flash', prompt);
-    const jsonStr = data.text.match(/\[.*\]/s)?.[0] || '[]';
-    return JSON.parse(jsonStr);
+    const ai = getAI();
+    const response = await ai.models.generateContent({
+      model: TEXT_MODEL,
+      contents: `Suggest 3 strategic treasury actions based on: ${JSON.stringify(context)}. Return JSON array of {type: 'ALPHA'|'RISK'|'LIQUIDITY', title, description}.`,
+      config: { responseMimeType: "application/json" }
+    });
+    return JSON.parse(response.text || '[]');
   } catch {
     return [];
   }