refactor(ollama)!: remove Ollama provider crate and implementation

Deletes the `owlen-ollama` Cargo.toml and source files, fully removing the Ollama provider from the workspace. This aligns the project with the MCP‑only architecture and eliminates direct provider dependencies.

crates/owlen-mcp-llm-server/src/main.rs

@@ -14,13 +14,14 @@ use owlen_core::mcp::protocol::{
 };
 use owlen_core::mcp::{McpToolCall, McpToolDescriptor, McpToolResponse};
 use owlen_core::provider::ProviderConfig;
+use owlen_core::providers::OllamaProvider;
 use owlen_core::types::{ChatParameters, ChatRequest, Message};
 use owlen_core::Provider;
-use owlen_ollama::OllamaProvider;
 use serde::Deserialize;
 use serde_json::{json, Value};
 use std::collections::HashMap;
 use std::env;
+use std::sync::Arc;
 use tokio::io::{self, AsyncBufReadExt, AsyncWriteExt};
 use tokio_stream::StreamExt;
 
@@ -108,42 +109,56 @@ fn resources_list_descriptor() -> McpToolDescriptor {
     }
 }
 
-fn provider_from_config() -> Result<OllamaProvider, RpcError> {
+fn provider_from_config() -> Result<Arc<dyn Provider>, RpcError> {
     let mut config = OwlenConfig::load(None).unwrap_or_default();
-    let provider_name =
+    let requested_name =
         env::var("OWLEN_PROVIDER").unwrap_or_else(|_| config.general.default_provider.clone());
-    if config.provider(&provider_name).is_none() {
-        ensure_provider_config(&mut config, &provider_name);
+    let provider_key = canonical_provider_name(&requested_name);
+    if config.provider(&provider_key).is_none() {
+        ensure_provider_config(&mut config, &provider_key);
     }
     let provider_cfg: ProviderConfig =
-        config.provider(&provider_name).cloned().ok_or_else(|| {
+        config.provider(&provider_key).cloned().ok_or_else(|| {
             RpcError::internal_error(format!(
-                "Provider '{provider_name}' not found in configuration"
+                "Provider '{provider_key}' not found in configuration"
             ))
         })?;
 
-    if provider_cfg.provider_type != "ollama" && provider_cfg.provider_type != "ollama-cloud" {
-        return Err(RpcError::internal_error(format!(
-            "Unsupported provider type '{}' for MCP LLM server",
-            provider_cfg.provider_type
-        )));
+    match provider_cfg.provider_type.as_str() {
+        "ollama" | "ollama-cloud" => {
+            let provider = OllamaProvider::from_config(&provider_cfg, Some(&config.general))
+                .map_err(|e| {
+                    RpcError::internal_error(format!(
+                        "Failed to init Ollama provider from config: {e}"
+                    ))
+                })?;
+            Ok(Arc::new(provider) as Arc<dyn Provider>)
+        }
+        other => Err(RpcError::internal_error(format!(
+            "Unsupported provider type '{other}' for MCP LLM server"
+        ))),
     }
-
-    OllamaProvider::from_config(&provider_cfg, Some(&config.general)).map_err(|e| {
-        RpcError::internal_error(format!("Failed to init OllamaProvider from config: {}", e))
-    })
 }
 
-fn create_provider() -> Result<OllamaProvider, RpcError> {
+fn create_provider() -> Result<Arc<dyn Provider>, RpcError> {
     if let Ok(url) = env::var("OLLAMA_URL") {
-        return OllamaProvider::new(&url).map_err(|e| {
-            RpcError::internal_error(format!("Failed to init OllamaProvider: {}", e))
-        });
+        let provider = OllamaProvider::new(&url).map_err(|e| {
+            RpcError::internal_error(format!("Failed to init Ollama provider: {e}"))
+        })?;
+        return Ok(Arc::new(provider) as Arc<dyn Provider>);
     }
 
     provider_from_config()
 }
 
+fn canonical_provider_name(name: &str) -> String {
+    if name.eq_ignore_ascii_case("ollama-cloud") {
+        "ollama".to_string()
+    } else {
+        name.to_string()
+    }
+}
+
 async fn handle_generate_text(args: GenerateTextArgs) -> Result<String, RpcError> {
     let provider = create_provider()?;
 
@@ -409,16 +424,14 @@ async fn main() -> anyhow::Result<()> {
                             }
                         };
 
-                    // Initialize Ollama provider and start streaming
-                    let ollama_url = env::var("OLLAMA_URL")
-                        .unwrap_or_else(|_| "http://localhost:11434".to_string());
-                    let provider = match OllamaProvider::new(&ollama_url) {
+                    // Initialize provider and start streaming
+                    let provider = match create_provider() {
                         Ok(p) => p,
                         Err(e) => {
                             let err_resp = RpcErrorResponse::new(
                                 id.clone(),
                                 RpcError::internal_error(format!(
-                                    "Failed to init OllamaProvider: {}",
+                                    "Failed to initialize provider: {:?}",
                                     e
                                 )),
                             );