feat: groq and openai both working

Author: TwistingTwists

Cargo.lock

@@ -14,11 +14,11 @@ categories = ["api-bindings", "web-programming", "asynchronous"]
 
 
 [dependencies]
-reqwest = { version = "0.12", features = ["json"] }
-serde = { version = "1.0.203", features = ["derive"] }
-tokio = { version = "1", features = ["full"] }
-serde_json = "1.0"
-anyhow = "1.0.86"
+reqwest = { version = "0.12.0", features = ["multipart", "json"] }
+serde = { version = "1.0.197", features = ["derive"] }
+tokio = { version = "1.36.0", features = ["full"] }
+serde_json = "1.0.114"
+anyhow = "1.0.81"
 chrono = { version = "0.4.38", features = ["serde"] }
 reqwest-eventsource = "0.6.0"
 futures = "0.3.30"
@@ -33,10 +33,11 @@ tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 tracing-appender = "0.2.2"
 hound = "3.5.1"
 bytes = { version = "1.10.1", features = ["serde"] }
-clap = { version = "4.3", features = ["derive"] }
+clap = { version = "4.5", features = ["derive"] }
 global-hotkey = "0.6"
 colored = "3.0"
 bytemuck = { version = "1.15.0", features = ["derive"] } # Added for safe byte casting
 dialoguer = "0.11.0"
 thiserror = "2.0.12"
 rubato = "0.16.2"
+groq-api-rust = "0.2.51"

Cargo.toml

@@ -6,4 +6,5 @@ export RUST_BACKTRACE=1
 
 cargo build 
 
-./target/debug/groq-api-rs
+# ./target/debug/groq-api-rs -t groq
+./target/debug/groq-api-rs -t open-ai

scripts/local_run.sh

@@ -39,8 +39,8 @@ impl App {
         let shutdown_manager = Arc::new(ShutdownManager::new("tts-groq"));
 
         let provider: Box<dyn TranscriptionProvider + Send + Sync> = match config.transcription_provider {
-            TranscriptionProviderAPI::Groq => Box::new(providers::GroqProvider::new()),
-            TranscriptionProviderAPI::OpenAI => Box::new(providers::OpenAIProvider::new()),
+            TranscriptionProviderAPI::Groq => Box::new(providers::GroqProvider::new().await),
+            TranscriptionProviderAPI::OpenAI => Box::new(providers::OpenAIProvider::new().await),
         };
 
         Ok(Self {

src/app.rs

@@ -10,7 +10,7 @@ pub struct OpenAIProvider {
 }
 
 impl OpenAIProvider {
-    pub fn new() -> Self {
+    pub async fn new() -> Self {
         Self {
             client: async_openai::Client::new(),
         }

src/providers/async_openai_self.rs

@@ -2,29 +2,20 @@
 use crate::providers::TranscriptionProvider;
 use anyhow::{Context, Result};
 use async_trait::async_trait;
-use reqwest::{multipart, Client};
-use serde::Deserialize;
+use groq_api_rust::{AsyncGroqClient, SpeechToTextRequest};
 use std::env;
 use std::time::Duration;
-use tracing::{debug, error, info, instrument};
-
-#[derive(Debug, Deserialize)]
-struct GroqTranscriptionResponse {
-    text: String,
-}
+use tracing::{debug, info, instrument};
 
 pub struct GroqProvider {
-    client: Client,
-    api_key: String,
+    client: AsyncGroqClient,
 }
 
 impl GroqProvider {
-    pub fn new() -> Self {
+    pub async fn new() -> Self {
         let api_key = env::var("GROQ_API_KEY").expect("GROQ_API_KEY environment variable not set");
-
         Self {
-            client: Client::new(),
-            api_key,
+            client: AsyncGroqClient::new(api_key, None).await,
         }
     }
 }
@@ -44,48 +35,17 @@ impl TranscriptionProvider for GroqProvider {
         info!("Starting Groq transcription request");
         debug!("Audio data size: {} bytes", audio_data.len());
 
-        // Create multipart form with audio data
-        let form = multipart::Form::new()
-            .part(
-                "file",
-                multipart::Part::bytes(audio_data.to_vec())
-                    .file_name("audio.wav")
-                    .mime_str("audio/wav")?,
-            )
-            .text("model", "whisper-large-v3");
+        let request = SpeechToTextRequest::new(audio_data.to_vec())
+            .temperature(0.7)
+            .language("en")
+            .model("whisper-large-v3");
 
-        // Send request to Groq API
-        let response = self
-            .client
-            .post("https://api.groq.com/v1/audio/transcriptions")
-            .header("Authorization", format!("Bearer {}", self.api_key))
-            .multipart(form)
-            .send()
-            .await
-            .context("Failed to send request to Groq API")?;
+        let response = self.client.speech_to_text(request).await
+            .context("Failed to get response from Groq")?;
 
-        // Parse response
-        if response.status().is_success() {
-            let transcription: GroqTranscriptionResponse = response
-                .json()
-                .await
-                .context("Failed to parse Groq API response")?;
+        info!("Groq transcription successful");
+        debug!("Received transcription: {}", response.text);
 
-            info!("Groq transcription successful");
-            debug!(
-                "Received transcription with {} characters",
-                transcription.text.len()
-            );
-
-            Ok(transcription.text)
-        } else {
-            let error_text = response
-                .text()
-                .await
-                .unwrap_or_else(|_| "Unable to get error message".to_string());
-
-            error!("Groq transcription failed: {}", error_text);
-            Err(anyhow::anyhow!("Groq API error: {}", error_text))
-        }
+        Ok(response.text)
     }
 }

src/providers/groq.rs

@@ -53,28 +53,26 @@ impl TranscriptionProvider for MockProvider {
     }
 }
 
-pub fn create_provider(provider_name: &str) -> Box<dyn TranscriptionProvider + Send + Sync> {
-    info!("Creating transcription provider: {}", provider_name);
+/// Create a new transcription provider based on the provider name
+pub async fn create_provider(provider_name: &str) -> Box<dyn TranscriptionProvider + Send + Sync> {
+    debug!("Creating provider: {}", provider_name);
 
     match provider_name.to_lowercase().as_str() {
         "openai" => {
             debug!("Initializing OpenAI provider");
-            Box::new(OpenAIProvider::new())
+            Box::new(OpenAIProvider::new().await)
         }
         "groq" => {
             debug!("Initializing Groq provider");
-            Box::new(self::groq::GroqProvider::new())
+            Box::new(GroqProvider::new().await)
         }
         "mock" => {
             debug!("Initializing Mock provider");
             Box::new(MockProvider::new())
         }
         _ => {
-            warn!(
-                "Unknown provider: {}, falling back to OpenAI",
-                provider_name
-            );
-            Box::new(OpenAIProvider::new())
+            warn!("Unknown provider '{}', using mock provider", provider_name);
+            Box::new(MockProvider::new())
         }
     }
 }