feat: Add Groq LLM service adapter and integrate with existing LLM command structure

- Implement GroqService for interacting with Groq's API, including model fetching and text generation.
- Update LLM service module to include Groq as a provider.
- Enhance OpenAIService for better model context window estimation.
- Create Tauri commands for managing LLM services, including fetching models and generating insights.
- Introduce prompt templates for various insight types to standardize prompt generation.
- Add frontend API bindings for generating insights and managing prompts.

Author: srprasanna

apps/desktop/src-tauri/migrations/003_add_prompt_templates.sql

@@ -0,0 +1,74 @@
+-- Prompt templates table for customizable LLM prompts
+CREATE TABLE IF NOT EXISTS prompt_templates (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    insight_type TEXT NOT NULL CHECK(insight_type IN ('summary', 'action_item', 'key_point', 'decision')),
+    name TEXT NOT NULL,
+    prompt_text TEXT NOT NULL,
+    is_default BOOLEAN NOT NULL DEFAULT 0,
+    is_active BOOLEAN NOT NULL DEFAULT 0,
+    created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+    updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+    UNIQUE(insight_type, name)
+);
+
+CREATE INDEX idx_prompt_templates_type ON prompt_templates(insight_type);
+CREATE INDEX idx_prompt_templates_active ON prompt_templates(is_active);
+
+-- Insert default templates for each insight type
+INSERT INTO prompt_templates (insight_type, name, prompt_text, is_default, is_active) VALUES
+('summary', 'Default Summary', 'You are an expert meeting summarizer. Analyze the following meeting transcript and create a concise summary.
+
+Meeting Transcript:
+{transcript}
+
+{context}
+
+Create a clear, concise summary in 3-5 bullet points covering:
+- Main topics discussed
+- Key decisions or conclusions
+- Important highlights
+
+Format your response as a bulleted list with each point starting with "- ".', 1, 1),
+
+('action_item', 'Default Action Items', 'You are an expert at extracting action items from meetings. Analyze the following meeting transcript and identify all actionable tasks.
+
+Meeting Transcript:
+{transcript}
+
+{context}
+
+Extract all action items, decisions requiring follow-up, and tasks mentioned. For each action item, provide:
+- The specific task or action
+- Who is responsible (if mentioned)
+- Any deadlines or timeframes (if mentioned)
+
+Format each action item on a separate line starting with "- ". Be specific and actionable.', 1, 1),
+
+('key_point', 'Default Key Points', 'You are an expert at identifying key discussion points from meetings. Analyze the following meeting transcript and extract the most important points.
+
+Meeting Transcript:
+{transcript}
+
+{context}
+
+Identify 3-7 key points, insights, or important statements from the meeting. Focus on:
+- Critical information shared
+- Important questions raised
+- Significant agreements or disagreements
+- Notable insights or revelations
+
+Format your response as a bulleted list with each point starting with "- ".', 1, 1),
+
+('decision', 'Default Decisions', 'You are an expert at identifying decisions made in meetings. Analyze the following meeting transcript and extract all decisions.
+
+Meeting Transcript:
+{transcript}
+
+{context}
+
+Identify all explicit or implicit decisions made during the meeting. For each decision, provide:
+- What was decided
+- The rationale or context (if provided)
+- Who made or approved the decision (if mentioned)
+
+Format each decision on a separate line starting with "- ". Focus on concrete decisions, not just discussions.', 1, 1);

apps/desktop/src-tauri/migrations/004_add_model_overrides.sql

@@ -0,0 +1,15 @@
+-- Model configuration overrides table
+-- Allows users to customize model-specific settings like context window
+CREATE TABLE IF NOT EXISTS model_overrides (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    provider TEXT NOT NULL,  -- 'openai', 'anthropic', 'google', 'groq'
+    model_id TEXT NOT NULL,  -- Model identifier (e.g., 'gpt-4', 'claude-3-opus-20240229')
+    context_window INTEGER,  -- User-configured context window (overrides default)
+    notes TEXT,              -- User notes about this model
+    created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+    updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+    UNIQUE(provider, model_id)
+);
+
+CREATE INDEX idx_model_overrides_provider ON model_overrides(provider);
+CREATE INDEX idx_model_overrides_model ON model_overrides(model_id);

apps/desktop/src-tauri/migrations/005_add_speaker_label_to_transcripts.sql

@@ -0,0 +1,5 @@
+-- Add speaker_label to transcripts table for diarization support
+-- This allows storing speaker identification directly on transcript segments
+ALTER TABLE transcripts ADD COLUMN speaker_label TEXT;
+
+CREATE INDEX IF NOT EXISTS idx_transcripts_speaker_label ON transcripts(speaker_label);

apps/desktop/src-tauri/src/adapters/services/asr/deepgram.rs

@@ -51,9 +51,35 @@ impl DeepgramService {
             .await
             .map_err(|e| AppError::Transcription(format!("Failed to read audio file: {}", e)))?;
 
+        // Log WAV file details
+        if buffer.len() > 44 {
+            // WAV header is 44 bytes - check if this looks like a valid WAV
+            let is_wav = &buffer[0..4] == b"RIFF" && &buffer[8..12] == b"WAVE";
+            println!(
+                ">>> WAV file check: is_valid_wav={}, total_bytes={}",
+                is_wav,
+                buffer.len()
+            );
+
+            if is_wav {
+                // Parse basic WAV info
+                let audio_format = u16::from_le_bytes([buffer[20], buffer[21]]);
+                let num_channels = u16::from_le_bytes([buffer[22], buffer[23]]);
+                let sample_rate =
+                    u32::from_le_bytes([buffer[24], buffer[25], buffer[26], buffer[27]]);
+                let bits_per_sample = u16::from_le_bytes([buffer[34], buffer[35]]);
+
+                println!(">>> WAV format: audio_format={}, channels={}, sample_rate={}, bits_per_sample={}",
+                    audio_format, num_channels, sample_rate, bits_per_sample);
+            } else {
+                println!("!!! WARNING: File doesn't have valid WAV header!");
+            }
+        }
+
         // Build query parameters
         let mut url = format!("{}/listen", DEEPGRAM_API_BASE);
         let mut params = vec![
+            ("model", "nova-2-meeting"), // Use Nova-2-meeting optimized for meetings
             ("punctuate", "true"),
             (
                 "diarize",
@@ -78,6 +104,11 @@ impl DeepgramService {
 
         url = format!("{}?{}", url, query_string);
 
+        println!(">>> Sending request to Deepgram API: {}", url);
+        println!(">>> Audio file size: {} bytes", buffer.len());
+        log::info!("Sending request to Deepgram API: {}", url);
+        log::info!("Audio file size: {} bytes", buffer.len());
+
         // Send request
         let response = self
             .client
@@ -87,22 +118,39 @@ impl DeepgramService {
             .body(buffer)
             .send()
             .await
-            .map_err(|e| AppError::Transcription(format!("Deepgram request failed: {}", e)))?;
+            .map_err(|e| {
+                log::error!("Deepgram HTTP request failed: {}", e);
+                AppError::Transcription(format!("Deepgram request failed: {}", e))
+            })?;
 
-        if !response.status().is_success() {
-            let status = response.status();
+        let status = response.status();
+        println!(">>> Deepgram API response status: {}", status);
+        log::info!("Deepgram API response status: {}", status);
+
+        if !status.is_success() {
             let error_text = response.text().await.unwrap_or_default();
+            println!("!!! Deepgram API error ({}): {}", status, error_text);
+            log::error!("Deepgram API error response: {}", error_text);
             return Err(AppError::Transcription(format!(
                 "Deepgram API error ({}): {}",
                 status, error_text
             )));
         }
 
         let deepgram_response: DeepgramResponse = response.json().await.map_err(|e| {
+            println!("!!! Failed to parse Deepgram JSON response: {}", e);
+            log::error!("Failed to parse Deepgram JSON response: {}", e);
             AppError::Transcription(format!("Failed to parse Deepgram response: {}", e))
         })?;
 
-        self.parse_deepgram_response(deepgram_response)
+        println!(">>> Successfully parsed Deepgram JSON response");
+        println!(">>> Channels: {}", deepgram_response.results.channels.len());
+
+        let result = self.parse_deepgram_response(deepgram_response)?;
+        println!(">>> Parsed into {} segments", result.segments.len());
+        println!(">>> Transcript text length: {} chars", result.text.len());
+
+        Ok(result)
     }
 
     /// Parse Deepgram response into our TranscriptionResult format
@@ -118,8 +166,20 @@ impl DeepgramService {
         let text = alternative.transcript.clone();
         let confidence = Some(alternative.confidence);
 
+        println!(">>> Transcript text from Deepgram: {} chars", text.len());
+        println!(">>> Has utterances: {}", alternative.utterances.is_some());
+        println!(">>> Has words: {}", alternative.words.is_some());
+
+        if let Some(ref utterances) = alternative.utterances {
+            println!(">>> Utterances count: {}", utterances.len());
+        }
+        if let Some(ref words) = alternative.words {
+            println!(">>> Words count: {}", words.len());
+        }
+
         // Parse utterances with speaker labels
         let segments = if let Some(utterances) = &alternative.utterances {
+            println!(">>> Using utterances for segments");
             utterances
                 .iter()
                 .map(|utt| TranscriptionSegment {
@@ -131,6 +191,7 @@ impl DeepgramService {
                 })
                 .collect()
         } else if let Some(words) = &alternative.words {
+            println!(">>> Using words fallback for segments");
             // Fallback: group words by speaker if utterances not available
             let mut segments = Vec::new();
             let mut current_speaker = None;
@@ -193,16 +254,24 @@ impl DeepgramService {
 
             segments
         } else {
+            println!(">>> No utterances or words - using fallback single segment");
             // No diarization - single segment
-            vec![TranscriptionSegment {
-                text: text.clone(),
-                start_ms: 0,
-                end_ms: (response.metadata.duration * 1000.0) as i64,
-                speaker_label: None,
-                confidence,
-            }]
+            if text.is_empty() {
+                println!("!!! WARNING: Transcript text is empty!");
+                vec![]
+            } else {
+                vec![TranscriptionSegment {
+                    text: text.clone(),
+                    start_ms: 0,
+                    end_ms: (response.metadata.duration * 1000.0) as i64,
+                    speaker_label: None,
+                    confidence,
+                }]
+            }
         };
 
+        println!(">>> Final segments count: {}", segments.len());
+
         Ok(TranscriptionResult {
             text,
             segments,
@@ -246,6 +315,7 @@ impl TranscriptionServicePort for DeepgramService {
         // Build query parameters
         let mut url = format!("{}/listen", DEEPGRAM_API_BASE);
         let mut params = vec![
+            ("model", "nova-2-meeting"), // Use Nova-2-meeting optimized for meetings
             ("punctuate", "true"),
             (
                 "diarize",