Added openai compatible v1 completions and ollama api key compatibility (#73) (#74)

Added:
    - v1 completions (OpenAI compatible) and testing connection
    - Add API key handling for Ollama and v1 completions if required
Co-authored-by: midhun kumar <midh0001@student.monash.edu>
Reviewed-on: https://codeberg.org/ArkHost/HelixNotes/pulls/74

src-tauri/src/ai.rs

@@ -21,6 +21,8 @@ pub fn ai_request(
     std::thread::spawn(move || {
         let rt = tokio::runtime::Runtime::new().unwrap();
         rt.block_on(async {
+            // Handle all API keys as optional; ollama and v1 completions doesnt always require it.
+            let key_opt = if api_key.is_empty() { None } else { Some(api_key.as_str()) };
             let result = match provider.as_str() {
                 "openai" => {
                     stream_openai(
@@ -40,7 +42,7 @@ pub fn ai_request(
                     stream_openai(
                         &app,
                         &url,
-                        None,
+                        key_opt,
                         &model,
                         &system_prompt,
                         &user_message,
@@ -48,6 +50,24 @@ pub fn ai_request(
                     )
                     .await
                 }
+                "openai_compatible" => {
+                    let url = base_url.as_deref().unwrap_or("");
+                    if url.is_empty() {
+                        Err("No base URL configured for OpenAI Compatible provider".to_string())
+                    } else {
+                        let url = format!("{}/v1/completions", url.trim_end_matches('/'));
+                        stream_completions(
+                            &app,
+                            &url,
+                            key_opt,
+                            &model,
+                            &system_prompt,
+                            &user_message,
+                            &request_id,
+                        )
+                        .await
+                    }
+                }
                 _ => {
                     stream_anthropic(
                         &app,
@@ -353,12 +373,21 @@ pub async fn test_connection(
     model: &str,
     base_url: Option<&str>,
 ) -> Result<String, String> {
+    let key_opt = if api_key.is_empty() { None } else { Some(api_key) };
     match provider {
         "openai" => test_openai(OPENAI_API_URL, Some(api_key), model).await,
         "ollama" => {
             let url = base_url.unwrap_or(OLLAMA_DEFAULT_URL);
             let url = format!("{}/v1/chat/completions", url.trim_end_matches('/'));
-            test_openai(&url, None, model).await
+            test_openai(&url, key_opt, model).await
+        }
+        "openai_compatible" => {
+            let url = base_url.unwrap_or("");
+            if url.is_empty() {
+                return Err("No base URL configured for OpenAI Compatible provider".to_string());
+            }
+            let url = format!("{}/v1/completions", url.trim_end_matches('/'));
+            test_completions(&url, key_opt, model).await
         }
         _ => test_anthropic(api_key, model).await,
     }
@@ -397,6 +426,167 @@ async fn test_anthropic(api_key: &str, model: &str) -> Result<String, String> {
     }
 }
 
+async fn stream_completions(
+    app: &AppHandle,
+    url: &str,
+    api_key: Option<&str>,
+    model: &str,
+    system_prompt: &str,
+    user_message: &str,
+    _request_id: &str,
+) -> Result<(), String> {
+    let client = Client::new();
+
+    let prompt = format!("{}\n\nUser: {}\nAssistant:", system_prompt, user_message);
+
+    let body = json!({
+        "model": model,
+        "prompt": prompt,
+        "max_tokens": 4096,
+        "stream": true,
+        "temperature": 0.7
+    });
+
+    let mut req = client
+        .post(url)
+        .header("content-type", "application/json");
+
+    if let Some(key) = api_key {
+        req = req.header("Authorization", format!("Bearer {}", key));
+    }
+
+    let response = req
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("Request failed: {}", e))?;
+
+    if !response.status().is_success() {
+        let status = response.status();
+        let body_text = response.text().await.unwrap_or_default();
+        return Err(format!("API error {}: {}", status, body_text));
+    }
+
+    // Parse SSE stream
+    use futures::StreamExt;
+    let mut stream = response.bytes_stream();
+    let mut buffer = String::new();
+
+    while let Some(chunk) = stream.next().await {
+        let chunk = chunk.map_err(|e| format!("Stream error: {}", e))?;
+        buffer.push_str(&String::from_utf8_lossy(&chunk));
+
+        // Process complete SSE events from buffer
+        while let Some(event_end) = buffer.find("\n\n") {
+            let event_str = buffer[..event_end].to_string();
+            buffer = buffer[event_end + 2..].to_string();
+
+            for line in event_str.lines() {
+                if let Some(data) = line.strip_prefix("data: ") {
+                    if data == "[DONE]" {
+                        let _ = app.emit(
+                            "ai-stream",
+                            AiStreamEvent {
+                                event_type: "done".to_string(),
+                                text: None,
+                                error: None,
+                            },
+                        );
+                        return Ok(());
+                    }
+
+                    if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(data) {
+                        // Completions streaming: choices[0].text
+                        if let Some(text) = parsed["choices"][0]["text"].as_str() {
+                            if !text.is_empty() {
+                                let _ = app.emit(
+                                    "ai-stream",
+                                    AiStreamEvent {
+                                        event_type: "text".to_string(),
+                                        text: Some(text.to_string()),
+                                        error: None,
+                                    },
+                                );
+                            }
+                        }
+
+                        // Check finish_reason
+                        if let Some(reason) = parsed["choices"][0]["finish_reason"].as_str() {
+                            if reason == "stop" || reason == "length" {
+                                let _ = app.emit(
+                                    "ai-stream",
+                                    AiStreamEvent {
+                                        event_type: "done".to_string(),
+                                        text: None,
+                                        error: None,
+                                    },
+                                );
+                                return Ok(());
+                            }
+                        }
+
+                        // Check for error in stream
+                        if let Some(err) = parsed["error"]["message"].as_str() {
+                            let _ = app.emit(
+                                "ai-stream",
+                                AiStreamEvent {
+                                    event_type: "error".to_string(),
+                                    text: None,
+                                    error: Some(err.to_string()),
+                                },
+                            );
+                            return Err(err.to_string());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let _ = app.emit(
+        "ai-stream",
+        AiStreamEvent {
+            event_type: "done".to_string(),
+            text: None,
+            error: None,
+        },
+    );
+
+    Ok(())
+}
+
+async fn test_completions(url: &str, api_key: Option<&str>, model: &str) -> Result<String, String> {
+    let client = Client::new();
+
+    let body = json!({
+        "model": model,
+        "prompt": "Hi",
+        "max_tokens": 10,
+    });
+
+    let mut req = client
+        .post(url)
+        .header("content-type", "application/json");
+
+    if let Some(key) = api_key {
+        req = req.header("Authorization", format!("Bearer {}", key));
+    }
+
+    let response = req
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("Connection failed: {}", e))?;
+
+    if response.status().is_success() {
+        Ok("Connection successful".to_string())
+    } else {
+        let status = response.status();
+        let body_text = response.text().await.unwrap_or_default();
+        Err(format!("API error {}: {}", status, body_text))
+    }
+}
+
 async fn test_openai(url: &str, api_key: Option<&str>, model: &str) -> Result<String, String> {
     let client = Client::new();