feat: refactor text generation to use LanguageModel abstraction

- Replace direct use of model string and AIProvider in `GenerateTextRequest` with a `LanguageModel` struct.
- Update OpenAI provider and tests to construct and use `LanguageModel` instances.
- Simplify `GenerateTextRequestBuilder` by removing separate provider field; model now encapsulates provider.
- Adjust internal logic to clone provider from the model.
- Improves type safety and paves the way for richer model metadata.

Author: vidurkhanal

crates/umem_ai/src/providers/openai.rs

@@ -70,7 +70,7 @@ impl OpenAIProvider {
         let normalized_user_messages = self.normalize_user_messages(&request.messages);
 
         serde_json::json!({
-            "model": request.model,
+            "model": request.model.model_name,
             "instructions":system,
             "input": [serde_json::json!({
                 "type": "message",
@@ -408,19 +408,20 @@ impl Default for OpenAIProviderBuilder {
 
 #[cfg(test)]
 mod tests {
+
     use super::*;
     use crate::{
         response_generators::{
             generate_object::{generate_object, GenerateObjectRequestBuilder},
             generate_text, GenerateTextRequestBuilder,
         },
-        LLMProvider, LLM,
+        AIProvider, LanguageModel,
     };
     use std::sync::Arc;
 
     #[tokio::test(flavor = "multi_thread")]
     async fn test_generate_object() {
-        let provider = Arc::new(LLMProvider::from(
+        let provider = Arc::new(AIProvider::from(
             OpenAIProviderBuilder::new()
                 .api_key("")
                 .base_url("https://openrouter.ai/api/v1")
@@ -434,13 +435,13 @@ mod tests {
             traditions: String,
         }
 
-        let llm = Arc::new(LLM {
+        let model = Arc::new(LanguageModel {
             provider,
             model_name: "allenai/olmo-3.1-32b-think:free".to_string(),
         });
 
         let request = GenerateObjectRequestBuilder::<Holiday>::new()
-            .model(llm)
+            .model(model)
             .system("You are a helpful assistant.".to_string())
             .prompt("Invent a new holiday and describe its traditions.".to_string())
             .max_output_tokens(2000)
@@ -455,19 +456,23 @@ mod tests {
 
     #[tokio::test(flavor = "multi_thread")]
     async fn test_generate_text() {
-        let provider = Arc::new(LLMProvider::from(
+        let provider = Arc::new(AIProvider::from(
             OpenAIProviderBuilder::new()
                 .api_key("")
                 .base_url("https://openrouter.ai/api/v1")
                 .build()
                 .unwrap(),
         ));
 
+        let model = Arc::new(LanguageModel {
+            provider,
+            model_name: "arcee-ai/trinity-mini:free".to_string(),
+        });
+
         let request = GenerateTextRequestBuilder::new()
-            .model("arcee-ai/trinity-mini:free".to_string())
+            .model(model)
             .system("You are a helpful assistant.".to_string())
             .prompt("Invent a new holiday and describe its traditions.".to_string())
-            .provider(Arc::clone(&provider))
             .max_output_tokens(10000)
             .temperature(0.7)
             .build()

crates/umem_ai/src/response_generators/generate_text.rs

@@ -1,7 +1,7 @@
 use crate::response_generators::messages::Message;
 use crate::utils;
 use crate::utils::is_retryable_error;
-use crate::AIProvider;
+use crate::LanguageModel;
 use crate::ResponseGeneratorError;
 use backon::ExponentialBuilder;
 use backon::Retryable;
@@ -19,8 +19,10 @@ pub async fn generate_text(
     let total_delay = per_request_timeout.mul_f32(max_retries as f32 / 2.0);
 
     let generation = || {
-        let provider = Arc::clone(&request.provider);
+        let model = Arc::clone(&request.model);
+        let provider = Arc::clone(&model.provider);
         let request = request.clone();
+
         async move {
             tokio::time::timeout(per_request_timeout, provider.do_generate_text(request))
                 .await
@@ -50,8 +52,7 @@ pub struct GenerateTextResponse {
 
 #[derive(Clone)]
 pub struct GenerateTextRequest {
-    pub model: String,
-    pub provider: Arc<AIProvider>,
+    pub model: Arc<LanguageModel>,
     pub messages: Vec<Message>,
     pub max_output_tokens: Option<usize>,
     pub temperature: Option<f32>,
@@ -80,8 +81,7 @@ pub enum GenerateTextRequestBuilderError {
 }
 
 pub struct GenerateTextRequestBuilder {
-    pub model: Option<String>,
-    pub provider: Option<Arc<AIProvider>>,
+    pub model: Option<Arc<LanguageModel>>,
     pub system: Option<String>,
     pub prompt: Option<String>,
     pub messages: Vec<Message>,
@@ -100,7 +100,6 @@ impl GenerateTextRequestBuilder {
     pub fn new() -> Self {
         GenerateTextRequestBuilder {
             model: None,
-            provider: None,
             system: None,
             prompt: None,
             max_output_tokens: None,
@@ -116,13 +115,8 @@ impl GenerateTextRequestBuilder {
         }
     }
 
-    pub fn model(mut self, model: impl Into<String>) -> Self {
-        self.model = Some(model.into());
-        self
-    }
-
-    pub fn provider(mut self, provider: Arc<AIProvider>) -> Self {
-        self.provider = Some(provider);
+    pub fn model(mut self, model: Arc<LanguageModel>) -> Self {
+        self.model = Some(model);
         self
     }
 
@@ -214,9 +208,6 @@ impl GenerateTextRequestBuilder {
                 .model
                 .ok_or(GenerateTextRequestBuilderError::MissingModel)?,
             messages: self.messages,
-            provider: self
-                .provider
-                .ok_or(GenerateTextRequestBuilderError::MissingProvider)?,
             max_output_tokens: self.max_output_tokens,
             top_p: self.top_p,
             top_k: self.top_k,