Feat/multi languages support

src/app/MainHeader.js

@@ -549,6 +549,7 @@ export class MainHeader extends LitElement {
     }
 
     async _handleListenClick() {
+
         if (this.wasJustDragged) return;
         if (this.isTogglingSession) {
             return;

src/app/PickleGlassApp.js

@@ -69,6 +69,23 @@ export class PickleGlassApp extends LitElement {
         this.selectedImageQuality = localStorage.getItem('selectedImageQuality') || 'medium';
         this._isClickThrough = false;
 
+        // Initialize structured data for Live insights
+        this.structuredData = {
+            summary: [],
+            topic: { header: '', bullets: [] },
+            actions: [],
+            followUps: [],
+        };
+
+        // Set up structured data callback for Live insights
+        if (window.pickleGlass) {
+            window.pickleGlass.setStructuredData = data => {
+                this.updateStructuredData(data);
+            };
+        }
+
+        // Load language from settings on startup
+        this.loadLanguageFromSettings();
     }
 
     connectedCallback() {
@@ -80,6 +97,14 @@ export class PickleGlassApp extends LitElement {
             ipcRenderer.on('click-through-toggled', (_, isEnabled) => {
                 this._isClickThrough = isEnabled;
             });
+
+            // Language change listener for multi-language support
+            ipcRenderer.on('language-changed', (_, languageCode) => {
+                console.log('Language changed to:', languageCode);
+                this.selectedLanguage = languageCode;
+                localStorage.setItem('selectedLanguage', languageCode);
+            });
+
             // ipcRenderer.on('start-listening-session', () => {
             //     console.log('Received start-listening-session command, calling handleListenClick.');
             //     this.handleListenClick();
@@ -92,6 +117,7 @@ export class PickleGlassApp extends LitElement {
         if (window.require) {
             const { ipcRenderer } = window.require('electron');
             ipcRenderer.removeAllListeners('click-through-toggled');
+            ipcRenderer.removeAllListeners('language-changed');
             // ipcRenderer.removeAllListeners('start-listening-session');
         }
     }
@@ -159,6 +185,34 @@ export class PickleGlassApp extends LitElement {
     //     this.isMainViewVisible = true;
     // }
 
+    async loadLanguageFromSettings() {
+        if (!window.require) return;
+
+        try {
+            const { ipcRenderer } = window.require('electron');
+            const currentLanguage = await ipcRenderer.invoke('settings:get-current-language');
+            if (currentLanguage && currentLanguage !== this.selectedLanguage) {
+                this.selectedLanguage = currentLanguage;
+                localStorage.setItem('selectedLanguage', currentLanguage);
+                console.log(`[PickleGlassApp] Language loaded from settings: ${currentLanguage}`);
+            }
+        } catch (error) {
+            console.warn('[PickleGlassApp] Failed to load language from settings:', error);
+        }
+    }
+
+    updateStructuredData(data) {
+        console.log('📝 PickleGlassApp updateStructuredData:', data);
+        this.structuredData = data;
+        this.requestUpdate();
+
+        const assistantView = this.shadowRoot?.querySelector('assistant-view');
+        if (assistantView) {
+            assistantView.structuredData = data;
+            console.log('✅ Structured data passed to AssistantView');
+        }
+    }
+
     async handleClose() {
         if (window.require) {
             const { ipcRenderer } = window.require('electron');
@@ -169,6 +223,7 @@ export class PickleGlassApp extends LitElement {
 
 
 
+
     render() {
         switch (this.currentView) {
             case 'listen':

src/common/ai/providers/gemini.js

@@ -1,5 +1,6 @@
 const { GoogleGenerativeAI } = require("@google/generative-ai")
 const { GoogleGenAI } = require("@google/genai")
+const { getLanguageForProvider } = require('../../config/languages')
 
 class GeminiProvider {
     static async validateApiKey(key) {
@@ -34,11 +35,12 @@ class GeminiProvider {
  * @param {object} [opts.callbacks] - Event callbacks
  * @returns {Promise<object>} STT session
  */
-async function createSTT({ apiKey, language = "en-US", callbacks = {}, ...config }) {
+async function createSTT({ apiKey, language = "en", callbacks = {}, ...config }) {
   const liveClient = new GoogleGenAI({ vertexai: false, apiKey })
 
-  // Language code BCP-47 conversion
-  const lang = language.includes("-") ? language : `${language}-US`
+  // Get the proper language code for Gemini (BCP-47 format)
+  const geminiLanguage = getLanguageForProvider(language, 'gemini');
+  console.log(`[Gemini STT] Using language: ${geminiLanguage} (from ${language})`);
 
   const session = await liveClient.live.connect({
 
@@ -54,7 +56,7 @@ async function createSTT({ apiKey, language = "en-US", callbacks = {}, ...config
 
     config: {
       inputAudioTranscription: {},
-      speechConfig: { languageCode: lang },
+      speechConfig: { languageCode: geminiLanguage },
     },
   })
 

src/common/ai/providers/openai.js

@@ -1,5 +1,6 @@
 const OpenAI = require('openai');
 const WebSocket = require('ws');
+const { getLanguageForProvider } = require('../../config/languages');
 const { Portkey } = require('portkey-ai');
 const { Readable } = require('stream');
 const { getProviderForModel } = require('../factory.js');
@@ -30,7 +31,6 @@ class OpenAIProvider {
     }
 }
 
-
 /**
  * Creates an OpenAI STT session
  * @param {object} opts - Configuration options
@@ -45,6 +45,10 @@ async function createSTT({ apiKey, language = 'en', callbacks = {}, usePortkey =
   const keyType = usePortkey ? 'vKey' : 'apiKey';
   const key = usePortkey ? (portkeyVirtualKey || apiKey) : apiKey;
 
+  // Get the proper language code for OpenAI
+  const openaiLanguage = getLanguageForProvider(language, 'openai');
+  console.log(`[OpenAI STT] Using language: ${openaiLanguage} (from ${language})`);
+
   const wsUrl = keyType === 'apiKey'
     ? 'wss://api.openai.com/v1/realtime?intent=transcription'
     : 'wss://api.portkey.ai/v1/realtime?intent=transcription';
@@ -64,7 +68,7 @@ async function createSTT({ apiKey, language = 'en', callbacks = {}, usePortkey =
 
   return new Promise((resolve, reject) => {
     ws.onopen = () => {
-      console.log("WebSocket session opened.");
+      console.log(`[OpenAI STT] WebSocket session opened for language: ${openaiLanguage}`);
 
       const sessionConfig = {
         type: 'transcription_session.update',
@@ -73,7 +77,7 @@ async function createSTT({ apiKey, language = 'en', callbacks = {}, usePortkey =
           input_audio_transcription: {
             model: 'gpt-4o-mini-transcribe',
             prompt: config.prompt || '',
-            language: language || 'en'
+            language: openaiLanguage
           },
           turn_detection: {
             type: 'server_vad',

src/common/ai/providers/whisper.js

@@ -1,24 +1,27 @@
-let spawn, path, EventEmitter;
+let spawn, path, EventEmitter, getLanguageForProvider;
 
 if (typeof window === 'undefined') {
     spawn = require('child_process').spawn;
     path = require('path');
     EventEmitter = require('events').EventEmitter;
+    getLanguageForProvider = require('../../config/languages').getLanguageForProvider;
 } else {
     class DummyEventEmitter {
         on() {}
         emit() {}
         removeAllListeners() {}
     }
     EventEmitter = DummyEventEmitter;
+    getLanguageForProvider = () => 'en';
 }
 
 class WhisperSTTSession extends EventEmitter {
-    constructor(model, whisperService, sessionId) {
+    constructor(model, whisperService, sessionId, language = 'en') {
         super();
         this.model = model;
         this.whisperService = whisperService;
         this.sessionId = sessionId || `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.language = language;
         this.process = null;
         this.isRunning = false;
         this.audioBuffer = Buffer.alloc(0);
@@ -71,13 +74,17 @@ class WhisperSTTSession extends EventEmitter {
                 return;
             }
 
+            // Get the proper language code for Whisper
+            const whisperLanguage = getLanguageForProvider(this.language, 'whisper');
+            console.log(`[WhisperSTT-${this.sessionId}] Using language: ${whisperLanguage} (from ${this.language})`);
+
             this.process = spawn(whisperPath, [
                 '-m', modelPath,
                 '-f', tempFile,
                 '--no-timestamps',
                 '--output-txt',
                 '--output-json',
-                '--language', 'auto',
+                '--language', whisperLanguage,
                 '--threads', '4',
                 '--print-progress', 'false'
             ]);
@@ -195,11 +202,12 @@ class WhisperProvider {
 
         const model = config.model || 'whisper-tiny';
         const sessionType = config.sessionType || 'unknown';
-        console.log(`[WhisperProvider] Creating ${sessionType} STT session with model: ${model}`);
+        const language = config.language || 'en';
+        console.log(`[WhisperProvider] Creating ${sessionType} STT session with model: ${model}, language: ${language}`);
 
         // Create unique session ID based on type
         const sessionId = `${sessionType}_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
-        const session = new WhisperSTTSession(model, this.whisperService, sessionId);
+        const session = new WhisperSTTSession(model, this.whisperService, sessionId, language);
 
         // Log session creation
         console.log(`[WhisperProvider] Created session: ${sessionId}`);