feat(ai): add OpenAI-compatible provider and endpoint normalization; fix pill feedback timing; cleanups

- Always call baseURL + /v1/chat/completions for OpenAI-compatible
- Add OpenAI provider, config modal, and backend validation incl. no-auth
- Show short "Formatting failed" on pill for ~2s on enhancement errors
- Remove unused validate_api_key; drop unnecessary mut; adjust gating logic
- Wire keyring helpers and UI to new flow

Author: moinulmoin

package.json

@@ -70,5 +70,6 @@
     "typescript": "~5.6.2",
     "vite": "^6.3.6",
     "vitest": "^3.2.4"
-  }
+  },
+  "packageManager": "pnpm@10.13.1+sha512.37ebf1a5c7a30d5fabe0c5df44ee8da4c965ca0c5af3dbab28c3a1681b70a256218d05c81c9c0dcf767ef6b8551eb5b960042b9ed4300c59242336377e01cfad"
 }

src-tauri/src/ai/mod.rs

@@ -5,6 +5,7 @@ use std::collections::HashMap;
 pub mod config;
 pub mod gemini;
 pub mod groq;
+pub mod openai;
 pub mod prompts;
 
 pub use config::{MAX_CUSTOM_VOCABULARY, MAX_TEXT_LENGTH, MAX_VOCABULARY_TERM_LENGTH};
@@ -115,11 +116,16 @@ impl AIProviderFactory {
                 config.model.clone(),
                 config.options.clone(),
             )?)),
+            "openai" => Ok(Box::new(openai::OpenAIProvider::new(
+                config.api_key.clone(),
+                config.model.clone(),
+                config.options.clone(),
+            )?)),
             provider => Err(AIError::ProviderNotFound(provider.to_string())),
         }
     }
 
     fn is_valid_provider(provider: &str) -> bool {
-        matches!(provider, "groq" | "gemini")
+        matches!(provider, "groq" | "gemini" | "openai")
     }
 }

src-tauri/src/ai/openai.rs

@@ -0,0 +1,264 @@
+use super::config::*;
+use super::{prompts, AIEnhancementRequest, AIEnhancementResponse, AIError, AIProvider};
+use async_trait::async_trait;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::time::Duration;
+
+// Accept common OpenAI chat models. Keep minimal allowlist but include the requested one.
+const SUPPORTED_MODELS: &[&str] = &["gpt-5-nano", "gpt-5", "gpt-4.1-2025-04-14"];
+
+pub struct OpenAIProvider {
+    #[allow(dead_code)]
+    api_key: String,
+    model: String,
+    client: Client,
+    base_url: String,
+    options: HashMap<String, serde_json::Value>,
+}
+
+impl OpenAIProvider {
+    pub fn new(
+        api_key: String,
+        model: String,
+        mut options: HashMap<String, serde_json::Value>,
+    ) -> Result<Self, AIError> {
+        // Validate model (allow if in list; otherwise accept for forward compatibility)
+        if !SUPPORTED_MODELS.contains(&model.as_str()) {
+            // Don’t hard fail; just log a warning and continue
+            log::warn!("OpenAI model not in local allowlist: {}", model);
+        }
+
+        // Determine if auth is required
+        let no_auth = options
+            .get("no_auth")
+            .and_then(|v| v.as_bool())
+            .unwrap_or(false);
+
+        // Validate API key format (basic check) only if auth is required
+        if !no_auth {
+            if api_key.trim().is_empty() || api_key.len() < MIN_API_KEY_LENGTH {
+                return Err(AIError::ValidationError(
+                    "Invalid API key format".to_string(),
+                ));
+            }
+        }
+
+        let client = Client::builder()
+            .timeout(Duration::from_secs(DEFAULT_TIMEOUT_SECS))
+            .build()
+            .map_err(|e| AIError::NetworkError(format!("Failed to create HTTP client: {}", e)))?;
+
+        // Resolve base URL: always map base to /v1/chat/completions
+        let base_root = options
+            .get("base_url")
+            .and_then(|v| v.as_str())
+            .unwrap_or("https://api.openai.com");
+        let base_trim = base_root.trim_end_matches('/');
+        let base_url = format!("{}/v1/chat/completions", base_trim);
+
+        // Ensure the normalized values are kept in options for downstream if needed
+        options.insert(
+            "base_url".into(),
+            serde_json::Value::String(base_root.to_string()),
+        );
+
+        Ok(Self { api_key, model, client, base_url, options })
+    }
+
+    async fn make_request_with_retry(
+        &self,
+        request: &OpenAIRequest,
+    ) -> Result<OpenAIResponse, AIError> {
+        let mut last_error = None;
+
+        for attempt in 1..=MAX_RETRIES {
+            match self.make_single_request(request).await {
+                Ok(response) => return Ok(response),
+                Err(e) => {
+                    log::warn!("API request attempt {} failed: {}", attempt, e);
+                    last_error = Some(e);
+
+                    if attempt < MAX_RETRIES {
+                        tokio::time::sleep(Duration::from_millis(
+                            RETRY_BASE_DELAY_MS * attempt as u64,
+                        ))
+                        .await;
+                    }
+                }
+            }
+        }
+
+        Err(last_error.unwrap_or_else(|| AIError::NetworkError("Unknown error".to_string())))
+    }
+
+    async fn make_single_request(&self, request: &OpenAIRequest) -> Result<OpenAIResponse, AIError> {
+        // Determine if auth header should be sent
+        let no_auth = self
+            .options
+            .get("no_auth")
+            .and_then(|v| v.as_bool())
+            .unwrap_or(false);
+
+        let mut req = self
+            .client
+            .post(&self.base_url)
+            .header("Content-Type", "application/json")
+            .json(request);
+
+        if !no_auth {
+            req = req.header("Authorization", format!("Bearer {}", self.api_key));
+        }
+
+        let response = req
+            .send()
+            .await
+            .map_err(|e| AIError::NetworkError(e.to_string()))?;
+
+        let status = response.status();
+
+        if status.as_u16() == 429 {
+            return Err(AIError::RateLimitExceeded);
+        }
+
+        if !status.is_success() {
+            let error_text = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "Unknown error".to_string());
+            return Err(AIError::ApiError(format!(
+                "API returned {}: {}",
+                status, error_text
+            )));
+        }
+
+        response
+            .json()
+            .await
+            .map_err(|e| AIError::InvalidResponse(e.to_string()))
+    }
+}
+
+#[derive(Serialize)]
+struct OpenAIRequest {
+    model: String,
+    messages: Vec<Message>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    temperature: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    max_tokens: Option<u32>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct Message {
+    role: String,
+    content: String,
+}
+
+#[derive(Deserialize)]
+struct OpenAIResponse {
+    choices: Vec<Choice>,
+}
+
+#[derive(Deserialize)]
+struct Choice {
+    message: Message,
+}
+
+#[async_trait]
+impl AIProvider for OpenAIProvider {
+    async fn enhance_text(
+        &self,
+        request: AIEnhancementRequest,
+    ) -> Result<AIEnhancementResponse, AIError> {
+        request.validate()?;
+
+        let prompt = prompts::build_enhancement_prompt(
+            &request.text,
+            request.context.as_deref(),
+            &request.options.unwrap_or_default(),
+        );
+
+        let temperature = self
+            .options
+            .get("temperature")
+            .and_then(|v| v.as_f64())
+            .map(|v| v as f32)
+            .unwrap_or(DEFAULT_TEMPERATURE);
+
+        let max_tokens = self
+            .options
+            .get("max_tokens")
+            .and_then(|v| v.as_u64())
+            .map(|v| v as u32);
+
+        let request_body = OpenAIRequest {
+            model: self.model.clone(),
+            messages: vec![
+                Message {
+                    role: "system".to_string(),
+                    content: "You are a careful text formatter that only returns the cleaned text per the provided rules.".to_string(),
+                },
+                Message {
+                    role: "user".to_string(),
+                    content: prompt,
+                },
+            ],
+            temperature: Some(temperature.clamp(0.0, 2.0)),
+            max_tokens,
+        };
+
+        let api_response = self.make_request_with_retry(&request_body).await?;
+
+        let enhanced_text = api_response
+            .choices
+            .first()
+            .ok_or_else(|| AIError::InvalidResponse("No choices in response".to_string()))?
+            .message
+            .content
+            .trim()
+            .to_string();
+
+        if enhanced_text.is_empty() {
+            return Err(AIError::InvalidResponse("Empty response from API".to_string()));
+        }
+
+        Ok(AIEnhancementResponse {
+            enhanced_text,
+            original_text: request.text,
+            provider: self.name().to_string(),
+            model: self.model.clone(),
+        })
+    }
+
+    fn name(&self) -> &str {
+        "openai"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_provider_creation() {
+        let result = OpenAIProvider::new("".to_string(), "gpt-5-nano".to_string(), HashMap::new());
+        assert!(result.is_err());
+
+        let result = OpenAIProvider::new(
+            "test_key_12345".to_string(),
+            "gpt-unknown".to_string(),
+            HashMap::new(),
+        );
+        // Unknown model should be allowed with a warning (not hard error)
+        assert!(result.is_ok());
+
+        let result = OpenAIProvider::new(
+            "test_key_12345".to_string(),
+            "gpt-5-nano".to_string(),
+            HashMap::new(),
+        );
+        assert!(result.is_ok());
+    }
+}